diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000000..b889a368c1 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,12 @@ +# This file is for unifying the coding style for different editors and IDEs +# editorconfig.org + +root = true + +[*] +charset = utf-8 +end_of_line = lf +indent_size = 2 +indent_style = space +insert_final_newline = true +trim_trailing_whitespace = true diff --git a/.gitattributes b/.gitattributes index d7ea4954ec..176a458f94 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1,5 +1 @@ * text=auto -*.html text eol=lf -*.js text eol=lf -*.md text eol=lf -*.sh text eol=lf diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md new file mode 100644 index 0000000000..c9f7f34f7b --- /dev/null +++ b/.github/CONTRIBUTING.md @@ -0,0 +1,78 @@ +# Contributing to Lodash + +Contributions are always welcome. Before contributing please read the +[code of conduct](https://js.foundation/community/code-of-conduct) & +[search the issue tracker](https://github.com/lodash/lodash/issues); your issue +may have already been discussed or fixed in `master`. To contribute, +[fork](https://help.github.com/articles/fork-a-repo/) Lodash, commit your changes, +& [send a pull request](https://help.github.com/articles/using-pull-requests/). + +## Feature Requests + +Feature requests should be submitted in the +[issue tracker](https://github.com/lodash/lodash/issues), with a description of +the expected behavior & use case, where they’ll remain closed until sufficient interest, +[e.g. :+1: reactions](https://help.github.com/articles/about-discussions-in-issues-and-pull-requests/), +has been [shown by the community](https://github.com/lodash/lodash/issues?q=label%3A%22votes+needed%22+sort%3Areactions-%2B1-desc). +Before submitting a request, please search for similar ones in the +[closed issues](https://github.com/lodash/lodash/issues?q=is%3Aissue+is%3Aclosed+label%3Aenhancement). + +## Pull Requests + +For additions or bug fixes you should only need to modify `lodash.js`. Include +updated unit tests in the `test` directory as part of your pull request. Don’t +worry about regenerating the `dist/` or `doc/` files. + +Before running the unit tests you’ll need to install, `npm i`, +[development dependencies](https://docs.npmjs.com/files/package.json#devdependencies). +Run unit tests from the command-line via `npm test`, or open `test/index.html` & +`test/fp.html` in a web browser. The [Backbone](http://backbonejs.org/) & +[Underscore](http://underscorejs.org/) test suites are included as well. + +## Contributor License Agreement + +Lodash is a member of the [Open JS Foundation](https://openjsf.org/). +As such, we request that all contributors sign our +[contributor license agreement (CLA)](https://js.foundation/CLA/). + +For more information about CLAs, please check out Alex Russell’s excellent post, +[“Why Do I Need to Sign This?”](https://infrequently.org/2008/06/why-do-i-need-to-sign-this/). + +## Coding Guidelines + +In addition to the following guidelines, please follow the conventions already +established in the code. + +- **Spacing**:
+ Use two spaces for indentation. No tabs. + +- **Naming**:
+ Keep variable & method names concise & descriptive.
+ Variable names `index`, `array`, & `iteratee` are preferable to + `i`, `arr`, & `fn`. + +- **Quotes**:
+ Single-quoted strings are preferred to double-quoted strings; however, + please use a double-quoted string if the value contains a single-quote + character to avoid unnecessary escaping. + +- **Comments**:
+ Please use single-line comments to annotate significant additions, & + [JSDoc-style](http://www.2ality.com/2011/08/jsdoc-intro.html) comments for + functions. + +Guidelines are enforced using [JSCS](https://www.npmjs.com/package/jscs): +```bash +$ npm run style +``` + +## Tips + +You can opt-in to a pre-push git hook by adding an `.opt-in` file to the root of +the project containing: +```txt +pre-push +``` + +With that, when you `git push`, the pre-push git hook will trigger and execute +`npm run validate`. diff --git a/.gitignore b/.gitignore index aa025a981e..89f8a6bf9d 100644 --- a/.gitignore +++ b/.gitignore @@ -1,11 +1,4 @@ -.coveralls.yml .DS_Store -*.custom.* -*.template.* -*.map -/*.min.* -modularize +*.log +doc/*.html node_modules -dist/*.backbone.* -dist/*.legacy.* -dist/*.mobile.* diff --git a/.jscsrc b/.jscsrc new file mode 100644 index 0000000000..0ff5f15ada --- /dev/null +++ b/.jscsrc @@ -0,0 +1,97 @@ +{ + "maxErrors": "2000", + "maximumLineLength": { + "value": 180, + "allExcept": ["comments", "functionSignature", "regex"] + }, + "requireCurlyBraces": [ + "if", + "else", + "for", + "while", + "do", + "try", + "catch" + ], + "requireOperatorBeforeLineBreak": [ + "=", + "+", + "-", + "/", + "*", + "==", + "===", + "!=", + "!==", + ">", + ">=", + "<", + "<=" + ], + "requireSpaceAfterKeywords": [ + "if", + "else", + "for", + "while", + "do", + "switch", + "return", + "try", + "catch" + ], + "requireSpaceBeforeBinaryOperators": [ + "=", "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", ">>>=", + "&=", "|=", "^=", + + "+", "-", "*", "/", "%", "<<", ">>", ">>>", "&", + "|", "^", "&&", "||", "===", "==", ">=", + "<=", "<", ">", "!=", "!==" + ], + "requireSpacesInFunctionExpression": { + "beforeOpeningCurlyBrace": true + }, + "requireCamelCaseOrUpperCaseIdentifiers": true, + "requireDotNotation": { "allExcept": ["keywords"] }, + "requireEarlyReturn": true, + "requireLineFeedAtFileEnd": true, + "requireSemicolons": true, + "requireSpaceAfterBinaryOperators": true, + "requireSpacesInConditionalExpression": true, + "requireSpaceBeforeObjectValues": true, + "requireSpaceBeforeBlockStatements": true, + "requireSpacesInForStatement": true, + + "validateIndentation": 2, + "validateParameterSeparator": ", ", + "validateQuoteMarks": { "mark": "'", "escape": true }, + + "disallowSpacesInAnonymousFunctionExpression": { + "beforeOpeningRoundBrace": true + }, + "disallowSpacesInFunctionDeclaration": { + "beforeOpeningRoundBrace": true + }, + "disallowSpacesInFunctionExpression": { + "beforeOpeningRoundBrace": true + }, + "disallowKeywords": ["with"], + "disallowMixedSpacesAndTabs": true, + "disallowMultipleLineBreaks": true, + "disallowNewlineBeforeBlockStatements": true, + "disallowSpaceAfterObjectKeys": true, + "disallowSpaceAfterPrefixUnaryOperators": true, + "disallowSpacesInCallExpression": true, + "disallowSpacesInsideArrayBrackets": true, + "disallowSpacesInsideParentheses": true, + "disallowTrailingWhitespace": true, + "disallowUnusedVariables": true, + + "jsDoc": { + "checkRedundantAccess": true, + "checkTypes": true, + "requireNewlineAfterDescription": true, + "requireParamDescription": true, + "requireParamTypes": true, + "requireReturnTypes": true + } +} diff --git a/.markdown-doctest-setup.js b/.markdown-doctest-setup.js new file mode 100644 index 0000000000..cdb0bbb5c7 --- /dev/null +++ b/.markdown-doctest-setup.js @@ -0,0 +1,11 @@ +'use strict'; + +delete global['__core-js_shared__']; + +const _ = require('./lodash.js'); +const globals = require('lodash-doc-globals'); + +module.exports = { + 'babel': false, + 'globals': _.assign({ '_': _ }, globals) +}; diff --git a/.travis.yml b/.travis.yml index d47b4bcbf4..c6c9d8c8d6 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,79 +1,135 @@ language: node_js +sudo: false node_js: - - "0.6" - - "0.8" - - "0.10" + - 7 + +addons: + jwt: + secure: OYhRpW+8A0Iik+9GmHwa45ZwXeBXw/6zh6I+1w2H9g/LqPRp+Nhq3f4FSpvrrfno8lO8W4h+7s6+JOzF8C8NxNda5UUygKjF9pUphgiQdqls3YZMJlC9zXVl7gQXAHi3nG1s8vWSpwpzYD9fqczE1FX9n0+R63qX3eB6C/LbPeI= + +cache: + directories: + - ~/.npm + - ~/.yarn-cache + - travis_phantomjs + env: global: - - BIN="node" BUILD=false COMPAT=false MAKE=false OPTION="" SAUCE_LABS=false SAUCE_USERNAME="lodash" - - secure: "tg1JFsIFnxzLaTboFPOnm+aJCuMm5+JdhLlESlqg9x3fwro++7KCnwHKLNovhchaPe4otC43ZMB/nfWhDnDm11dKbm/V6HlTkED+dadTsaLxVDg6J+7yK41QhokBPJOxLV78iDaNaAQVYEirAgZ0yn8kFubxmNKV+bpCGQNc9yU=" + - BIN=node ISTANBUL=false OPTION="" + - SAUCE_LABS=false SAUCE_USERNAME=lodash + matrix: - - BUILD="compat" - - BUILD="modern" - - BUILD="legacy" - - BUILD="mobile" - - BIN="phantomjs" BUILD="compat" - - BIN="phantomjs" BUILD="legacy" - - BIN="phantomjs" BUILD="mobile" + - + - BIN=phantomjs + - ISTANBUL=true + - SAUCE_LABS=true + matrix: include: - - node_js: "0.10" - env: BIN="istanbul" - - node_js: "0.10" - env: BIN="narwhal" BUILD="compat" - - node_js: "0.10" - env: BIN="narwhal" BUILD="legacy" - - node_js: "0.10" - env: BIN="rhino" BUILD="compat" - - node_js: "0.10" - env: BIN="rhino" BUILD="legacy" - - node_js: "0.10" - env: BIN="rhino" BUILD="compat" OPTION="-require" - - node_js: "0.10" - env: BIN="rhino" BUILD="legacy" OPTION="-require" - - node_js: "0.10" - env: BIN="ringo" BUILD="compat" - - node_js: "0.10" - env: BIN="ringo" BUILD="legacy" - - node_js: "0.8" - env: SAUCE_LABS=true BUILD="compat" - - node_js: "0.8" - env: SAUCE_LABS=true BUILD="modern" - - node_js: "0.8" - env: SAUCE_LABS=true BUILD="legacy" - - node_js: "0.8" - env: SAUCE_LABS=true BUILD="mobile" - - node_js: "0.8" - env: SAUCE_LABS=true BUILD="underscore" + - node_js: 6 + env: + git: depth: 10 + branches: only: - master + - 4.17 + +notifications: + webhooks: + urls: + - https://webhooks.gitter.im/e/4aab6358b0e9aed0b628 + on_success: change + on_failure: always + before_install: - - "([ $BUILD == 'legacy' ] || [ $BUILD == 'mobile' ] || [ $BUILD == 'modern' ]) && MAKE=true || true" - - "([ $BUILD == 'compat' ] || [ $BUILD == 'legacy' ]) && COMPAT=true || true" - - "[ $SAUCE_LABS != false ] && npm i ecstatic@\"~0.4.0\" request@\"~2.27.0\" sauce-tunnel@\"~1.1.0\" || true" - - "[ $BIN == 'istanbul' ] && npm i -g coveralls@\"~2.5.0\" istanbul@\"~0.1.0\" || true" - - "[ $BIN == 'narwhal' ] && wget https://github.com/280north/narwhal/archive/v0.3.2.zip && sudo unzip v0.3.2 -d /opt/ && rm v0.3.2.zip || true" - - "[ $BIN == 'narwhal' ] && sudo ln -s /opt/narwhal-0.3.2/bin/narwhal /usr/local/bin/narwhal && sudo chmod +x /usr/local/bin/narwhal || true" - - "[ $BIN == 'rhino' ] && sudo mkdir /opt/rhino-1.7R5 && sudo wget -O /opt/rhino-1.7R5/js.jar https://oss.sonatype.org/content/repositories/snapshots/org/mozilla/rhino/1.7R5-SNAPSHOT/rhino-1.7R5-20120629.144839-4.jar || true" - - "[ $BIN == 'rhino' ] && echo -e '#!/bin/sh\\njava -jar /opt/rhino-1.7R5/js.jar $@' | sudo tee /usr/local/bin/rhino && sudo chmod +x /usr/local/bin/rhino || true" - - "[ $BIN == 'ringo' ] && wget http://ringojs.org/downloads/ringojs-0.9.zip && sudo unzip ringojs-0.9 -d /opt && rm ringojs-0.9.zip || true" - - "[ $BIN == 'ringo' ] && sudo ln -s /opt/ringojs-0.9/bin/ringo /usr/local/bin/ringo && sudo chmod +x /usr/local/bin/ringo || true" - - "[ $MAKE != false ] && git clone --depth=10 --branch=master git://github.com/lodash/lodash-cli.git ./node_modules/lodash-cli || true" - - "[ $MAKE != false ] && mkdir ./node_modules/lodash-cli/node_modules && cd ./node_modules/lodash-cli/node_modules/ && ln -s ../../../ ./lodash && cd ../ && npm i . && cd ../../ || true" - - "[ $MAKE != false ] && node ./node_modules/lodash-cli/bin/lodash $BUILD -o ./dist/lodash.$BUILD.js || true" + # Upgrade PhantomJS. + - | + export PHANTOMJS_VERSION=2.1.1 + export PATH=$PWD/travis_phantomjs/phantomjs-$PHANTOMJS_VERSION-linux-x86_64/bin:$PATH + if [ $(phantomjs --version) != $PHANTOMJS_VERSION ]; then + rm -rf $PWD/travis_phantomjs + mkdir -p $PWD/travis_phantomjs + wget https://github.com/Medium/phantomjs/releases/download/v$PHANTOMJS_VERSION/phantomjs-$PHANTOMJS_VERSION-linux-x86_64.tar.bz2 + tar -xvf phantomjs-$PHANTOMJS_VERSION-linux-x86_64.tar.bz2 -C $PWD/travis_phantomjs + fi + phantomjs -v + + # Use exact Node version. + - nvm use $TRAVIS_NODE_VERSION + + # Setup package managers. + - npm set loglevel error + - npm set progress false + - npm i -g yarn@0.16.1 + - yarn -V + + # Remove code skipped on the coverage run. + - | + PATTERN[0]="|\s*while\s*$[^)]+$\s*\{\s*iteratee$index$;\s*\}|" + PATTERN[1]="|\bindex,\s*iterable\)\s*===\s*false\)[^}]+?(break;)|" + PATTERN[2]="|\bcase\s+(?:dataView|promise|set|map|weakMap)CtorString:.+|g" + PATTERN[3]="|\s*if\s*$cache\.size\b[\s\S]+?\}|" + PATTERN[4]="|\s*if\s*\(\!lodashFunc$\s*\{\s*return;\s*\}|" + PATTERN[5]="|\s*define$[\s\S]+?$;|" + PATTERN[6]="|\s*root\._\s*=\s*_;|" + + if [ $ISTANBUL = true ]; then + set -e + for PTRN in ${PATTERN[@]}; do + node ./test/remove.js $PTRN ./lodash.js + done + fi + +install: + # Install packages. + - yarn + + # Use lodash-cli from GitHub. Temporarily use a fork. + - git clone --depth=10 --branch=master git://github.com/bnjmnt4n/lodash-cli ./node_modules/lodash-cli + - cd ./node_modules/lodash-cli/; npm i --production; cd ../../ + - mkdir -p ./node_modules/lodash-cli/node_modules/lodash; cd $_; cp ../../../../lodash.js ./lodash.js; cp ../../../../package.json ./package.json; cd ../../../../ + script: - - "[ $BIN == 'istanbul' ] && $BIN cover -x \"**/vendor/**\" --report lcovonly ./test/test.js -- ./dist/lodash.js && cat ./coverage/lcov.info | coveralls && rm -rf ./coverage || true" - - "([ $SAUCE_LABS != false ] || [ $BUILD == false ]) && true || cd ./test" - - "([ $SAUCE_LABS != false ] || [ $BUILD == false ]) && true || $BIN $OPTION ./test.js ../dist/lodash.$BUILD.js" - - "([ $SAUCE_LABS != false ] || [ $BUILD == false ]) && true || $BIN $OPTION ./test.js ../dist/lodash.$BUILD.min.js" - - "([ $SAUCE_LABS == false ] || [ $BUILD == 'underscore' ]) && true || node ./test/saucelabs.js runner=\"test/index.html?build=lodash-$BUILD\" tags=\"$BUILD,production\"" - - "([ $SAUCE_LABS == false ] || [ $COMPAT == false ]) && true || node ./test/saucelabs.js runner=\"test/index.html?build=lodash-$BUILD\" tags=\"$BUILD,production,ie-compat\" compatMode=7" - - "([ $SAUCE_LABS == false ] || [ $BUILD == 'underscore' ]) && true || node ./test/saucelabs.js runner=\"test/index.html?build=../dist/lodash.$BUILD.js\" tags=\"$BUILD,development\"" - - "([ $SAUCE_LABS == false ] || [ $COMPAT == false ]) && true || node ./test/saucelabs.js runner=\"test/index.html?build=../dist/lodash.$BUILD.js\" tags=\"$BUILD,development,ie-compat\" compatMode=7" - - "[ $SAUCE_LABS == false ] && true || node ./test/saucelabs.js name=\"backbone tests\" runner=\"test/backbone.html?build=lodash-$BUILD\" tags=\"$BUILD,production,backbone\"" - - "[ $SAUCE_LABS == false ] && true || node ./test/saucelabs.js name=\"backbone tests\" runner=\"test/backbone.html?build=../dist/lodash.$BUILD.js\" tags=\"$BUILD,development,backbone\"" - - "[ $SAUCE_LABS == false ] && true || node ./test/saucelabs.js name=\"underscore tests\" runner=\"test/underscore.html?build=lodash-$BUILD\" tags=\"$BUILD,production,underscore\"" - - "[ $SAUCE_LABS == false ] && true || node ./test/saucelabs.js name=\"underscore tests\" runner=\"test/underscore.html?build=../dist/lodash.$BUILD.js\" tags=\"$BUILD,development,underscore\"" + # Detect code coverage. + - | + if [ $ISTANBUL = true ]; then + istanbul cover -x "**/vendor/**" --report lcovonly ./test/test.js -- ./lodash.js + if [ $TRAVIS_SECURE_ENV_VARS = true ]; then + cat ./coverage/lcov.info | coveralls + cat ./coverage/coverage.json | codecov + fi + fi + + # Test in Node.js and PhantomJS. + - | + if [ $ISTANBUL = false ]; then + node ./node_modules/lodash-cli/bin/lodash -o ./dist/lodash.js + node ./node_modules/lodash-cli/bin/lodash modularize exports=node -o ./ + node ./node_modules/lodash-cli/bin/lodash -d -o ./lodash.js + if [ $SAUCE_LABS = false ]; then + cd ./test + $BIN $OPTION ./test.js ../lodash.js + if [ $TRAVIS_SECURE_ENV_VARS = true ]; then + $BIN $OPTION ./test.js ../dist/lodash.min.js + fi + fi + fi + + # Test in Sauce Labs. + - | + if [ $SAUCE_LABS = true ]; then + node ./node_modules/lodash-cli/bin/lodash core -o ./dist/lodash.core.js + npm run build + $BIN ./test/saucelabs.js name="lodash tests" runner="test/index.html?build=../dist/lodash.js&noglobals=true" tags=development + $BIN ./test/saucelabs.js name="lodash tests" runner="test/index.html?build=../dist/lodash.min.js&noglobals=true" tags=production + $BIN ./test/saucelabs.js name="lodash-fp tests" runner="test/fp.html?noglobals=true" tags=development + $BIN ./test/saucelabs.js name="underscore tests" runner="test/underscore.html?build=../dist/lodash.js" tags=development,underscore + $BIN ./test/saucelabs.js name="underscore tests" runner="test/underscore.html?build=../dist/lodash.min.js" tags=production,underscore + $BIN ./test/saucelabs.js name="backbone tests" runner="test/backbone.html?build=../dist/lodash.js" tags=development,backbone + $BIN ./test/saucelabs.js name="backbone tests" runner="test/backbone.html?build=../dist/lodash.min.js" tags=production,backbone + $BIN ./test/saucelabs.js name="backbone tests" runner="test/backbone.html?build=../dist/lodash.core.js" tags=development,backbone + $BIN ./test/saucelabs.js name="backbone tests" runner="test/backbone.html?build=../dist/lodash.core.min.js" tags=production,backbone + fi diff --git a/CHANGELOG b/CHANGELOG new file mode 100644 index 0000000000..7c0f1e3ee1 --- /dev/null +++ b/CHANGELOG @@ -0,0 +1 @@ +https://github.com/lodash/lodash/wiki/Changelog diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md deleted file mode 100644 index 6aee273d89..0000000000 --- a/CONTRIBUTING.md +++ /dev/null @@ -1,35 +0,0 @@ -# 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/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 `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. - -## Contributor License Agreement - -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/). - -## Coding Guidelines - -In addition to the following guidelines, please follow the conventions already established in the code. - -- **Spacing**:
- Use two spaces for indentation. No tabs. - -- **Naming**:
- Keep variable and method names concise and descriptive.
- Variable names `index`, `collection`, and `callback` are preferable to `i`, `arr`, and `fn`. - -- **Quotes**:
- Single-quoted strings are preferred to double-quoted strings; however, please use a double-quoted string if the value contains a single-quote character to avoid unnecessary escaping. - -- **Comments**:
- Please use single-line comments to annotate significant additions, and [JSDoc-style](http://www.2ality.com/2011/08/jsdoc-intro.html) comments for new methods. diff --git a/LICENSE.txt b/LICENSE similarity index 53% rename from LICENSE.txt rename to LICENSE index 49869bbab3..77c42f1408 100644 --- a/LICENSE.txt +++ b/LICENSE @@ -1,7 +1,17 @@ -Copyright 2012-2013 The Dojo Foundation -Based on Underscore.js 1.5.2, copyright 2009-2013 Jeremy Ashkenas, +Copyright OpenJS Foundation and other contributors + +Based on Underscore.js, copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors +This software consists of voluntary contributions made by many +individuals. For exact contribution history, see the revision history +available at https://github.com/lodash/lodash + +The following license applies to all parts of this software except as +documented below: + +==== + Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including @@ -19,4 +29,19 @@ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION -WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. \ No newline at end of file +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +==== + +Copyright and related rights for sample code are waived via CC0. Sample +code is defined as all source code displayed within the prose of the +documentation. + +CC0: http://creativecommons.org/publicdomain/zero/1.0/ + +==== + +Files located in the node_modules and vendor directories are externally +maintained libraries used by this software which have their own +licenses; we recommend you read them, as their terms may differ from the +terms above. diff --git a/README.md b/README.md index 6f9598e8a9..9d2ce70cb3 100644 --- a/README.md +++ b/README.md @@ -1,163 +1,80 @@ -# Lo-Dash v2.4.1 -A utility library delivering consistency, [customization](http://lodash.com/custom-builds), [performance](http://lodash.com/benchmarks), & [extras](http://lodash.com/#features). +# lodash v4.17.21 + +[Site](https://lodash.com/) | +[Docs](https://lodash.com/docs) | +[FP Guide](https://github.com/lodash/lodash/wiki/FP-Guide) | +[Contributing](https://github.com/lodash/lodash/blob/master/.github/CONTRIBUTING.md) | +[Wiki](https://github.com/lodash/lodash/wiki "Changelog, Roadmap, etc.") | +[Code of Conduct](https://js.foundation/conduct/) | +[Twitter](https://twitter.com/bestiejs) | +[Chat](https://gitter.im/lodash/lodash) + +The [Lodash](https://lodash.com/) library exported as a [UMD](https://github.com/umdjs/umd) module. + +Generated using [lodash-cli](https://www.npmjs.com/package/lodash-cli): +```shell +$ npm run build +$ lodash -o ./dist/lodash.js +$ lodash core -o ./dist/lodash.core.js +``` ## Download -Check out our [wiki]([https://github.com/lodash/lodash/wiki/build-differences]) for details over the differences between builds. - -* Modern builds perfect for newer browsers/environments:
-[Development](https://raw.github.com/lodash/lodash/2.4.1/dist/lodash.js) & -[Production](https://raw.github.com/lodash/lodash/2.4.1/dist/lodash.min.js) - -* Compatibility builds for older environment support too:
-[Development](https://raw.github.com/lodash/lodash/2.4.1/dist/lodash.compat.js) & -[Production](https://raw.github.com/lodash/lodash/2.4.1/dist/lodash.compat.min.js) - -* Underscore builds to use as a drop-in replacement:
-[Development](https://raw.github.com/lodash/lodash/2.4.1/dist/lodash.underscore.js) & -[Production](https://raw.github.com/lodash/lodash/2.4.1/dist/lodash.underscore.min.js) - -CDN copies are available on [cdnjs](http://cdnjs.com/libraries/lodash.js/) & [jsDelivr](http://www.jsdelivr.com/#!lodash). For smaller file sizes, create [custom builds](http://lodash.com/custom-builds) with only the features needed. - -Love modules? We’ve got you covered with [lodash-amd](https://npmjs.org/package/lodash-amd), [lodash-es6](https://github.com/lodash/lodash-es6), [lodash-node](https://npmjs.org/package/lodash-node), & [npm packages](https://npmjs.org/browse/keyword/lodash-modularized) per method. - -## Dive in - -There’s plenty of **[documentation](http://lodash.com/docs)**, [unit tests](http://lodash.com/tests), & [benchmarks](http://lodash.com/benchmarks).
-Check out DevDocs as a fast, organized, & searchable interface for our documentation. - -The full changelog for this release is available on our [wiki](https://github.com/lodash/lodash/wiki/Changelog).
-A list of upcoming features is available on our [roadmap](https://github.com/lodash/lodash/wiki/Roadmap). - -## Features *not* in Underscore - - * 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”*](http://michaux.ca/articles/lazy-function-definition-pattern) defined methods - * [_.clone](http://lodash.com/docs#clone) supports shallow cloning of `Date` & `RegExp` objects - * [_.cloneDeep](http://lodash.com/docs#cloneDeep) for deep cloning arrays & objects - * [_.constant](http://lodash.com/docs#constant) & [_.property](http://lodash.com/docs#property) function generators for composing functions - * [_.contains](http://lodash.com/docs#contains) accepts a `fromIndex` - * [_.create](http://lodash.com/docs#create) for easier object inheritance - * [_.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 additional `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` - * [_.mapValues](http://lodash.com/docs#mapValues) for [mapping](http://lodash.com/docs#map) values to an 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) - * [_.noop](http://lodash.com/docs#noop) for function placeholders - * [_.now](http://lodash.com/docs#now) as a cross-browser `Date.now` alternative - * [_.parseInt](http://lodash.com/docs#parseInt) for consistent behavior - * [_.pull](http://lodash.com/docs#pull) & [_.remove](http://lodash.com/docs#remove) for mutating arrays - * [_.random](http://lodash.com/docs#random) supports returning floating-point numbers - * [_.runInContext](http://lodash.com/docs#runInContext) for easier mocking - * [_.sortBy](http://lodash.com/docs#sortBy) supports sorting by multiple properties - * [_.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-literals-string-literals) - * [_.transform](http://lodash.com/docs#transform) as a powerful alternative to [_.reduce](http://lodash.com/docs#reduce) for transforming objects - * [_.where](http://lodash.com/docs#where) supports deep object comparisons - * [_.xor](http://lodash.com/docs#xor) as a companion to [_.difference](http://lodash.com/docs#difference), [_.intersection](http://lodash.com/docs#intersection), & [_.union](http://lodash.com/docs#union) - * [_.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, _.partialRight") right-associative methods - -## Resources - - * Podcasts - - [JavaScript Jabber](http://javascriptjabber.com/079-jsj-lo-dash-with-john-david-dalton/) - - * 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/) - - * 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) - - A list of other community created podcasts, posts, & videos is available on our [wiki](https://github.com/lodash/lodash/wiki/Resources). - -## Support - -Tested in Chrome 5~31, Firefox 2~25, IE 6-11, Opera 9.25~17, Safari 3-7, Node.js 0.6.21~0.10.22, Narwhal 0.3.2, PhantomJS 1.9.2, RingoJS 0.9, & Rhino 1.7RC5.
-Automated browser test results [are available](https://saucelabs.com/u/lodash) as well as [Travis CI](https://travis-ci.org/) builds for [lodash](https://travis-ci.org/lodash/lodash/), [lodash-cli](https://travis-ci.org/lodash/lodash-cli/), [lodash-amd](https://travis-ci.org/lodash/lodash-amd/), [lodash-node](https://travis-ci.org/lodash/lodash-node/), & [grunt-lodash](https://travis-ci.org/lodash/grunt-lodash). - -Special thanks to [Sauce Labs](https://saucelabs.com/) for providing automated browser testing.
-[![Sauce Labs](http://lodash.com/_img/sauce.png)](https://saucelabs.com/ "Sauce Labs: Selenium Testing & More") - -## Installation & usage - -In browsers: + * [Core build](https://raw.githubusercontent.com/lodash/lodash/4.17.21/dist/lodash.core.js) ([~4 kB gzipped](https://raw.githubusercontent.com/lodash/lodash/4.17.21/dist/lodash.core.min.js)) + * [Full build](https://raw.githubusercontent.com/lodash/lodash/4.17.21/dist/lodash.js) ([~24 kB gzipped](https://raw.githubusercontent.com/lodash/lodash/4.17.21/dist/lodash.min.js)) + * [CDN copies](https://www.jsdelivr.com/projects/lodash) + +Lodash is released under the [MIT license](https://raw.githubusercontent.com/lodash/lodash/4.17.21/LICENSE) & supports modern environments.
+Review the [build differences](https://github.com/lodash/lodash/wiki/build-differences) & pick one that’s right for you. +## Installation + +In a browser: ```html ``` -Using [`npm`](http://npmjs.org/): - -```bash -npm i --save lodash - -{sudo} npm i -g lodash -npm ln lodash +Using npm: +```shell +$ npm i -g npm +$ npm i --save lodash ``` -In [Node.js](http://nodejs.org/) & [Ringo](http://ringojs.org/): - +In Node.js: ```js +// Load the full build. var _ = require('lodash'); -// or as Underscore -var _ = require('lodash/dist/lodash.underscore'); +// Load the core build. +var _ = require('lodash/core'); +// Load the FP build for immutable auto-curried iteratee-first data-last methods. +var fp = require('lodash/fp'); + +// Load method categories. +var array = require('lodash/array'); +var object = require('lodash/fp/object'); + +// Cherry-pick methods for smaller browserify/rollup/webpack bundles. +var at = require('lodash/at'); +var curryN = require('lodash/fp/curryN'); ``` -**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 ln 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 [Rhino](http://www.mozilla.org/rhino/): +**Note:**
+Install [n_](https://www.npmjs.com/package/n_) for Lodash use in the Node.js < 6 REPL. -```js -load('lodash.js'); -``` - -In an AMD loader: - -```js -require({ - 'packages': [ - { 'name': 'lodash', 'location': 'path/to/lodash', 'main': 'lodash' } - ] -}, -['lodash'], function(_) { - console.log(_.VERSION); -}); -``` +## Why Lodash? -## Author +Lodash makes JavaScript easier by taking the hassle out of working with arrays,
+numbers, objects, strings, etc. Lodash’s modular methods are great for: -| [![twitter/jdalton](http://gravatar.com/avatar/299a3d891ff1920b69c364d061007043?s=70)](https://twitter.com/jdalton "Follow @jdalton on Twitter") | -|---| -| [John-David Dalton](http://allyoucanleet.com/) | + * Iterating arrays, objects, & strings + * Manipulating & testing values + * Creating composite functions -## Contributors +## Module Formats -| [![twitter/blainebublitz](http://gravatar.com/avatar/ac1c67fd906c9fecd823ce302283b4c1?s=70)](https://twitter.com/blainebublitz "Follow @BlaineBublitz on Twitter") | [![twitter/kitcambridge](http://gravatar.com/avatar/6662a1d02f351b5ef2f8b4d815804661?s=70)](https://twitter.com/kitcambridge "Follow @kitcambridge on Twitter") | [![twitter/mathias](http://gravatar.com/avatar/24e08a9ea84deb17ae121074d0f17125?s=70)](https://twitter.com/mathias "Follow @mathias on Twitter") | -|---|---|---| -| [Blaine Bublitz](http://www.iceddev.com/) | [Kit Cambridge](http://kitcambridge.be/) | [Mathias Bynens](http://mathiasbynens.be/) | +Lodash is available in a [variety of builds](https://lodash.com/custom-builds) & module formats. -[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/lodash/lodash/trend.png)](https://bitdeli.com/free "Bitdeli Badge") + * [lodash](https://www.npmjs.com/package/lodash) & [per method packages](https://www.npmjs.com/browse/keyword/lodash-modularized) + * [lodash-es](https://www.npmjs.com/package/lodash-es), [babel-plugin-lodash](https://www.npmjs.com/package/babel-plugin-lodash), & [lodash-webpack-plugin](https://www.npmjs.com/package/lodash-webpack-plugin) + * [lodash/fp](https://github.com/lodash/lodash/tree/npm/fp) + * [lodash-amd](https://www.npmjs.com/package/lodash-amd) diff --git a/bower.json b/bower.json deleted file mode 100644 index a6f139d7c3..0000000000 --- a/bower.json +++ /dev/null @@ -1,23 +0,0 @@ -{ - "name": "lodash", - "version": "2.4.1", - "main": "dist/lodash.compat.js", - "ignore": [ - ".*", - "*.custom.*", - "*.template.*", - "*.map", - "*.md", - "/*.min.*", - "/lodash.js", - "index.js", - "component.json", - "package.json", - "doc", - "modularize", - "node_modules", - "perf", - "test", - "vendor" - ] -} diff --git a/component.json b/component.json deleted file mode 100644 index 6cd4698585..0000000000 --- a/component.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "name": "lodash", - "repo": "lodash/lodash", - "version": "2.4.1", - "description": "A utility library delivering consistency, customization, performance, & extras.", - "license": "MIT", - "keywords": ["amd", "browser", "client", "functional", "server", "util"], - "scripts": [ - "index.js", - "dist/lodash.compat.js" - ] -} diff --git a/dist/lodash.compat.js b/dist/lodash.compat.js deleted file mode 100644 index 23798ba853..0000000000 --- a/dist/lodash.compat.js +++ /dev/null @@ -1,7157 +0,0 @@ -/** - * @license - * Lo-Dash 2.4.1 (Custom Build) - * Build: `lodash -o ./dist/lodash.compat.js` - * Copyright 2012-2013 The Dojo Foundation - * Based on Underscore.js 1.5.2 - * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors - * Available under MIT license - */ -;(function() { - - /** Used as a safe reference for `undefined` in pre ES5 environments */ - var undefined; - - /** Used to pool arrays and objects used internally */ - var arrayPool = [], - objectPool = []; - - /** Used to generate unique IDs */ - var idCounter = 0; - - /** Used internally to indicate various things */ - var indicatorObject = {}; - - /** Used to prefix keys to avoid issues with `__proto__` and properties on `Object.prototype` */ - var keyPrefix = +new Date + ''; - - /** Used as the size when optimizations are enabled for large arrays */ - var largeArraySize = 75; - - /** 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 ES6 template delimiters - * http://people.mozilla.org/~jorendorff/es6-draft.html#sec-literals-string-literals - */ - var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g; - - /** Used to match regexp flags from their coerced string values */ - var reFlags = /\w*$/; - - /** Used to detected named functions */ - var reFuncName = /^\s*function[ \n\r\t]+\w/; - - /** Used to match "interpolate" template delimiters */ - var reInterpolate = /<%=([\s\S]+?)%>/g; - - /** 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 detect functions containing a `this` reference */ - var reThis = /\bthis\b/; - - /** Used to match unescaped characters in compiled string literals */ - var reUnescapedString = /['\n\r\t\u2028\u2029\\]/g; - - /** Used to assign default `context` object properties */ - var contextProps = [ - 'Array', 'Boolean', 'Date', 'Error', 'Function', 'Math', 'Number', 'Object', - 'RegExp', 'String', '_', 'attachEvent', 'clearTimeout', 'isFinite', 'isNaN', - 'parseInt', 'setTimeout' - ]; - - /** Used to fix the JScript [[DontEnum]] bug */ - var shadowedProps = [ - 'constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', - 'toLocaleString', 'toString', 'valueOf' - ]; - - /** Used to make template sourceURLs easier to identify */ - var templateCounter = 0; - - /** `Object#toString` result shortcuts */ - var argsClass = '[object Arguments]', - arrayClass = '[object Array]', - boolClass = '[object Boolean]', - dateClass = '[object Date]', - errorClass = '[object Error]', - funcClass = '[object Function]', - numberClass = '[object Number]', - objectClass = '[object Object]', - regexpClass = '[object RegExp]', - stringClass = '[object String]'; - - /** Used to identify object classifications that `_.clone` supports */ - var cloneableClasses = {}; - cloneableClasses[funcClass] = false; - cloneableClasses[argsClass] = cloneableClasses[arrayClass] = - cloneableClasses[boolClass] = cloneableClasses[dateClass] = - cloneableClasses[numberClass] = cloneableClasses[objectClass] = - cloneableClasses[regexpClass] = cloneableClasses[stringClass] = true; - - /** Used as an internal `_.debounce` options object */ - var debounceOptions = { - 'leading': false, - 'maxWait': 0, - 'trailing': false - }; - - /** Used as the property descriptor for `__bindData__` */ - var descriptor = { - 'configurable': false, - 'enumerable': false, - 'value': null, - 'writable': false - }; - - /** Used as the data object for `iteratorTemplate` */ - var iteratorData = { - 'args': '', - 'array': null, - 'bottom': '', - 'firstArg': '', - 'init': '', - 'keys': null, - 'loop': '', - 'shadowedProps': null, - 'support': null, - 'top': '', - 'useHas': false - }; - - /** Used to determine if values are of the language type Object */ - var objectTypes = { - 'boolean': false, - 'function': true, - 'object': true, - 'number': false, - 'string': false, - 'undefined': false - }; - - /** Used to escape characters for inclusion in compiled string literals */ - var stringEscapes = { - '\\': '\\', - "'": "'", - '\n': 'n', - '\r': 'r', - '\t': 't', - '\u2028': 'u2028', - '\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 && !exports.nodeType && exports; - - /** Detect free variable `module` */ - var freeModule = objectTypes[typeof module] && module && !module.nodeType && module; - - /** Detect the popular CommonJS extension `module.exports` */ - var moduleExports = freeModule && freeModule.exports === freeExports && freeExports; - - /** 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)) { - root = freeGlobal; - } - - /*--------------------------------------------------------------------------*/ - - /** - * The base implementation of `_.indexOf` without support for binary searches - * or `fromIndex` constraints. - * - * @private - * @param {Array} array The array to search. - * @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 baseIndexOf(array, value, fromIndex) { - var index = (fromIndex || 0) - 1, - length = array ? array.length : 0; - - while (++index < length) { - if (array[index] === value) { - return index; - } - } - return -1; - } - - /** - * An implementation of `_.contains` for cache objects that mimics the return - * signature of `_.indexOf` by returning `0` if the value is found, else `-1`. - * - * @private - * @param {Object} cache The cache object to inspect. - * @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] ? 0 : -1; - } - if (type != 'number' && type != 'string') { - type = 'object'; - } - var key = type == 'number' ? value : keyPrefix + value; - cache = (cache = cache[type]) && cache[key]; - - return type == 'object' - ? (cache && baseIndexOf(cache, value) > -1 ? 0 : -1) - : (cache ? 0 : -1); - } - - /** - * Adds a given value to the corresponding cache object. - * - * @private - * @param {*} value The value to add to the cache. - */ - function cachePush(value) { - var cache = this.cache, - type = typeof value; - - if (type == 'boolean' || value == null) { - cache[value] = true; - } else { - if (type != 'number' && type != 'string') { - type = 'object'; - } - var key = type == 'number' ? value : keyPrefix + value, - typeCache = cache[type] || (cache[type] = {}); - - if (type == 'object') { - (typeCache[key] || (typeCache[key] = [])).push(value); - } else { - typeCache[key] = true; - } - } - } - - /** - * 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. - */ - function charAtCallback(value) { - return value.charCodeAt(0); - } - - /** - * 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`. - */ - function compareAscending(a, b) { - var ac = a.criteria, - bc = b.criteria, - index = -1, - length = ac.length; - - while (++index < length) { - var value = ac[index], - other = bc[index]; - - if (value !== other) { - if (value > other || typeof value == 'undefined') { - return 1; - } - if (value < other || typeof other == 'undefined') { - return -1; - } - } - } - // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications - // that causes it, under certain circumstances, to return the same value for - // `a` and `b`. See https://github.com/jashkenas/underscore/pull/1247 - // - // This also ensures a stable sort in V8 and other engines. - // See http://code.google.com/p/v8/issues/detail?id=90 - return a.index - b.index; - } - - /** - * Creates a cache object to optimize linear searches of large arrays. - * - * @private - * @param {Array} [array=[]] The array to search. - * @returns {null|Object} Returns the cache object or `null` if caching should not be used. - */ - function createCache(array) { - var index = -1, - length = array.length, - first = array[0], - mid = array[(length / 2) | 0], - last = array[length - 1]; - - if (first && typeof first == 'object' && - mid && typeof mid == 'object' && last && typeof last == 'object') { - return false; - } - var cache = getObject(); - cache['false'] = cache['null'] = cache['true'] = cache['undefined'] = false; - - var result = getObject(); - result.array = array; - result.cache = cache; - result.push = cachePush; - - while (++index < length) { - result.push(array[index]); - } - return result; - } - - /** - * Used by `template` to escape characters for inclusion in compiled - * string literals. - * - * @private - * @param {string} match The matched character to escape. - * @returns {string} Returns the escaped character. - */ - function escapeStringChar(match) { - return '\\' + stringEscapes[match]; - } - - /** - * Gets an array from the array pool or creates a new one if the pool is empty. - * - * @private - * @returns {Array} The array from the pool. - */ - function getArray() { - return arrayPool.pop() || []; - } - - /** - * Gets an object from the object pool or creates a new one if the pool is empty. - * - * @private - * @returns {Object} The object from the pool. - */ - function getObject() { - return objectPool.pop() || { - 'array': null, - 'cache': null, - 'criteria': null, - 'false': false, - 'index': 0, - 'null': false, - 'number': null, - 'object': null, - 'push': null, - 'string': null, - 'true': false, - 'undefined': false, - 'value': null - }; - } - - /** - * Checks if `value` is a DOM node in IE < 9. - * - * @private - * @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` - // methods that are `typeof` "string" and still can coerce nodes to strings - return typeof value.toString != 'function' && typeof (value + '') == 'string'; - } - - /** - * Releases the given array back to the array pool. - * - * @private - * @param {Array} [array] The array to release. - */ - function releaseArray(array) { - array.length = 0; - if (arrayPool.length < maxPoolSize) { - arrayPool.push(array); - } - } - - /** - * Releases the given object back to the object pool. - * - * @private - * @param {Object} [object] The object to release. - */ - function releaseObject(object) { - var cache = object.cache; - if (cache) { - releaseObject(cache); - } - object.array = object.cache = object.criteria = object.object = object.number = object.string = object.value = null; - if (objectPool.length < maxPoolSize) { - objectPool.push(object); - } - } - - /** - * 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 - * 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. - * @returns {Array} Returns the new array. - */ - function slice(array, start, end) { - start || (start = 0); - if (typeof end == 'undefined') { - end = array ? array.length : 0; - } - var index = -1, - length = end - start || 0, - result = Array(length < 0 ? 0 : length); - - while (++index < length) { - result[index] = array[start + index]; - } - return result; - } - - /*--------------------------------------------------------------------------*/ - - /** - * Create a new `lodash` function using the given context object. - * - * @static - * @memberOf _ - * @category Utilities - * @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.io/#x11.1.5. - context = context ? _.defaults(root.Object(), context, _.pick(root, contextProps)) : root; - - /** Native constructor references */ - var Array = context.Array, - Boolean = context.Boolean, - Date = context.Date, - Error = context.Error, - Function = context.Function, - Math = context.Math, - Number = context.Number, - Object = context.Object, - RegExp = context.RegExp, - String = context.String, - TypeError = context.TypeError; - - /** - * Used for `Array` method references. - * - * Normally `Array.prototype` would suffice, however, using an array literal - * avoids issues in Narwhal. - */ - var arrayRef = []; - - /** Used for native method references */ - var errorProto = Error.prototype, - objectProto = Object.prototype, - stringProto = String.prototype; - - /** Used to restore the original `_` reference in `noConflict` */ - var oldDash = context._; - - /** Used to resolve the internal [[Class]] of values */ - var toString = objectProto.toString; - - /** Used to detect if a method is native */ - var reNative = RegExp('^' + - String(toString) - .replace(/[.*+?^${}()|[\]\\]/g, '\\$&') - .replace(/toString| for [^\]]+/g, '.*?') + '$' - ); - - /** Native method shortcuts */ - var ceil = Math.ceil, - clearTimeout = context.clearTimeout, - floor = Math.floor, - fnToString = Function.prototype.toString, - getPrototypeOf = isNative(getPrototypeOf = Object.getPrototypeOf) && getPrototypeOf, - hasOwnProperty = objectProto.hasOwnProperty, - push = arrayRef.push, - propertyIsEnumerable = objectProto.propertyIsEnumerable, - setTimeout = context.setTimeout, - splice = arrayRef.splice, - unshift = arrayRef.unshift; - - /** Used to set meta data on functions */ - var defineProperty = (function() { - // IE 8 only accepts DOM elements - try { - var o = {}, - func = isNative(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 nativeCreate = isNative(nativeCreate = Object.create) && nativeCreate, - nativeIsArray = isNative(nativeIsArray = Array.isArray) && nativeIsArray, - nativeIsFinite = context.isFinite, - nativeIsNaN = context.isNaN, - nativeKeys = isNative(nativeKeys = Object.keys) && nativeKeys, - nativeMax = Math.max, - nativeMin = Math.min, - nativeParseInt = context.parseInt, - nativeRandom = Math.random; - - /** Used to lookup a built-in constructor by [[Class]] */ - var ctorByClass = {}; - ctorByClass[arrayClass] = Array; - ctorByClass[boolClass] = Boolean; - ctorByClass[dateClass] = Date; - ctorByClass[funcClass] = Function; - ctorByClass[objectClass] = Object; - ctorByClass[numberClass] = Number; - ctorByClass[regexpClass] = RegExp; - ctorByClass[stringClass] = String; - - /** Used to avoid iterating non-enumerable properties in IE < 9 */ - var nonEnumProps = {}; - nonEnumProps[arrayClass] = nonEnumProps[dateClass] = nonEnumProps[numberClass] = { 'constructor': true, 'toLocaleString': true, 'toString': true, 'valueOf': true }; - nonEnumProps[boolClass] = nonEnumProps[stringClass] = { 'constructor': true, 'toString': true, 'valueOf': true }; - nonEnumProps[errorClass] = nonEnumProps[funcClass] = nonEnumProps[regexpClass] = { 'constructor': true, 'toString': true }; - nonEnumProps[objectClass] = { 'constructor': true }; - - (function() { - var length = shadowedProps.length; - while (length--) { - var key = shadowedProps[length]; - for (var className in nonEnumProps) { - if (hasOwnProperty.call(nonEnumProps, className) && !hasOwnProperty.call(nonEnumProps[className], key)) { - nonEnumProps[className][key] = false; - } - } - } - }()); - - /*--------------------------------------------------------------------------*/ - - /** - * Creates a `lodash` object which wraps the given value to enable intuitive - * method chaining. - * - * In addition to Lo-Dash methods, wrappers also have the following `Array` methods: - * `concat`, `join`, `pop`, `push`, `reverse`, `shift`, `slice`, `sort`, `splice`, - * and `unshift` - * - * Chaining is supported in custom builds as long as the `value` method is - * implicitly or explicitly included in the build. - * - * The chainable wrapper functions are: - * `after`, `assign`, `bind`, `bindAll`, `bindKey`, `chain`, `compact`, - * `compose`, `concat`, `countBy`, `create`, `createCallback`, `curry`, - * `debounce`, `defaults`, `defer`, `delay`, `difference`, `filter`, `flatten`, - * `forEach`, `forEachRight`, `forIn`, `forInRight`, `forOwn`, `forOwnRight`, - * `functions`, `groupBy`, `indexBy`, `initial`, `intersection`, `invert`, - * `invoke`, `keys`, `map`, `max`, `memoize`, `merge`, `min`, `object`, `omit`, - * `once`, `pairs`, `partial`, `partialRight`, `pick`, `pluck`, `pull`, `push`, - * `range`, `reject`, `remove`, `rest`, `reverse`, `shuffle`, `slice`, `sort`, - * `sortBy`, `splice`, `tap`, `throttle`, `times`, `toArray`, `transform`, - * `union`, `uniq`, `unshift`, `unzip`, `values`, `where`, `without`, `wrap`, - * and `zip` - * - * The non-chainable wrapper functions are: - * `clone`, `cloneDeep`, `contains`, `escape`, `every`, `find`, `findIndex`, - * `findKey`, `findLast`, `findLastIndex`, `findLastKey`, `has`, `identity`, - * `indexOf`, `isArguments`, `isArray`, `isBoolean`, `isDate`, `isElement`, - * `isEmpty`, `isEqual`, `isFinite`, `isFunction`, `isNaN`, `isNull`, `isNumber`, - * `isObject`, `isPlainObject`, `isRegExp`, `isString`, `isUndefined`, `join`, - * `lastIndexOf`, `mixin`, `noConflict`, `parseInt`, `pop`, `random`, `reduce`, - * `reduceRight`, `result`, `shift`, `size`, `some`, `sortedIndex`, `runInContext`, - * `template`, `unescape`, `uniqueId`, and `value` - * - * The wrapper functions `first` and `last` return wrapped values when `n` is - * provided, otherwise they return unwrapped values. - * - * Explicit chaining can be enabled by using the `_.chain` method. - * - * @name _ - * @constructor - * @category Chaining - * @param {*} value The value to wrap in a `lodash` instance. - * @returns {Object} Returns a `lodash` instance. - * @example - * - * var wrapped = _([1, 2, 3]); - * - * // returns an unwrapped value - * wrapped.reduce(function(sum, num) { - * return sum + num; - * }); - * // => 6 - * - * // returns a wrapped value - * var squares = wrapped.map(function(num) { - * return num * num; - * }); - * - * _.isArray(squares); - * // => false - * - * _.isArray(squares.value()); - * // => true - */ - function lodash(value) { - // don't wrap if already wrapped, even if wrapped by a different `lodash` constructor - return (value && typeof value == 'object' && !isArray(value) && hasOwnProperty.call(value, '__wrapped__')) - ? value - : new lodashWrapper(value); - } - - /** - * A fast path for creating `lodash` wrapper objects. - * - * @private - * @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, chainAll) { - this.__chain__ = !!chainAll; - this.__wrapped__ = value; - } - // ensure `new lodashWrapper` is an instance of `lodash` - lodashWrapper.prototype = lodash.prototype; - - /** - * An object used to flag environments features. - * - * @static - * @memberOf _ - * @type Object - */ - var support = lodash.support = {}; - - (function() { - var ctor = function() { this.x = 1; }, - object = { '0': 1, 'length': 1 }, - props = []; - - ctor.prototype = { 'valueOf': 1, 'y': 1 }; - for (var key in new ctor) { props.push(key); } - for (key in arguments) { } - - /** - * Detect if an `arguments` object's [[Class]] is resolvable (all but Firefox < 4, IE < 9). - * - * @memberOf _.support - * @type boolean - */ - support.argsClass = toString.call(arguments) == argsClass; - - /** - * Detect if `arguments` objects are `Object` objects (all but Narwhal and Opera < 10.5). - * - * @memberOf _.support - * @type boolean - */ - support.argsObject = arguments.constructor == Object && !(arguments instanceof Array); - - /** - * Detect if `name` or `message` properties of `Error.prototype` are - * enumerable by default. (IE < 9, Safari < 5.1) - * - * @memberOf _.support - * @type boolean - */ - support.enumErrorProps = propertyIsEnumerable.call(errorProto, 'message') || propertyIsEnumerable.call(errorProto, 'name'); - - /** - * Detect if `prototype` properties are enumerable by default. - * - * Firefox < 3.6, Opera > 9.50 - Opera < 11.60, and Safari < 5.1 - * (if the prototype or a property on the prototype has been set) - * incorrectly sets a function's `prototype` property [[Enumerable]] - * value to `true`. - * - * @memberOf _.support - * @type boolean - */ - support.enumPrototypes = propertyIsEnumerable.call(ctor, 'prototype'); - - /** - * Detect if functions can be decompiled by `Function#toString` - * (all but PS3 and older Opera mobile browsers & avoided in Windows 8 apps). - * - * @memberOf _.support - * @type boolean - */ - support.funcDecomp = !isNative(context.WinRTError) && reThis.test(runInContext); - - /** - * Detect if `Function#name` is supported (all but IE). - * - * @memberOf _.support - * @type boolean - */ - support.funcNames = typeof Function.name == 'string'; - - /** - * Detect if `arguments` object indexes are non-enumerable - * (Firefox < 4, IE < 9, PhantomJS, Safari < 5.1). - * - * @memberOf _.support - * @type boolean - */ - support.nonEnumArgs = key != 0; - - /** - * Detect if properties shadowing those on `Object.prototype` are non-enumerable. - * - * In IE < 9 an objects own properties, shadowing non-enumerable ones, are - * made non-enumerable as well (a.k.a the JScript [[DontEnum]] bug). - * - * @memberOf _.support - * @type boolean - */ - support.nonEnumShadows = !/valueOf/.test(props); - - /** - * Detect if own properties are iterated after inherited properties (all but IE < 9). - * - * @memberOf _.support - * @type boolean - */ - support.ownLast = props[0] != 'x'; - - /** - * Detect if `Array#shift` and `Array#splice` augment array-like objects correctly. - * - * Firefox < 10, IE compatibility mode, and IE < 9 have buggy Array `shift()` - * and `splice()` functions that fail to remove the last element, `value[0]`, - * of array-like objects even though the `length` property is set to `0`. - * The `shift()` method is buggy in IE 8 compatibility mode, while `splice()` - * is buggy regardless of mode in IE < 9 and buggy in compatibility mode in IE 9. - * - * @memberOf _.support - * @type boolean - */ - support.spliceObjects = (arrayRef.splice.call(object, 0, 1), !object[0]); - - /** - * Detect lack of support for accessing string characters by index. - * - * IE < 8 can't access characters by index and IE 8 can only access - * characters by index on string literals. - * - * @memberOf _.support - * @type boolean - */ - support.unindexedChars = ('x'[0] + Object('x')[0]) != 'xx'; - - /** - * Detect if a DOM node's [[Class]] is resolvable (all but IE < 9) - * and that the JS engine errors when attempting to coerce an object to - * a string without a `toString` function. - * - * @memberOf _.support - * @type boolean - */ - try { - support.nodeClass = !(toString.call(document) == objectClass && !({ 'toString': 0 } + '')); - } catch(e) { - support.nodeClass = true; - } - }(1)); - - /** - * By default, the template delimiters used by Lo-Dash are similar to those in - * embedded Ruby (ERB). Change the following template settings to use alternative - * delimiters. - * - * @static - * @memberOf _ - * @type Object - */ - lodash.templateSettings = { - - /** - * Used to detect `data` property values to be HTML-escaped. - * - * @memberOf _.templateSettings - * @type RegExp - */ - 'escape': /<%-([\s\S]+?)%>/g, - - /** - * Used to detect code to be evaluated. - * - * @memberOf _.templateSettings - * @type RegExp - */ - 'evaluate': /<%([\s\S]+?)%>/g, - - /** - * Used to detect `data` property values to inject. - * - * @memberOf _.templateSettings - * @type RegExp - */ - 'interpolate': reInterpolate, - - /** - * Used to reference the data object in the template text. - * - * @memberOf _.templateSettings - * @type string - */ - 'variable': '', - - /** - * Used to import variables into the compiled template. - * - * @memberOf _.templateSettings - * @type Object - */ - 'imports': { - - /** - * A reference to the `lodash` function. - * - * @memberOf _.templateSettings.imports - * @type Function - */ - '_': lodash - } - }; - - /*--------------------------------------------------------------------------*/ - - /** - * The template used to create iterator functions. - * - * @private - * @param {Object} data The data object used to populate the text. - * @returns {string} Returns the interpolated text. - */ - var iteratorTemplate = function(obj) { - - var __p = 'var index, iterable = ' + - (obj.firstArg) + - ', result = ' + - (obj.init) + - ';\nif (!iterable) return result;\n' + - (obj.top) + - ';'; - if (obj.array) { - __p += '\nvar length = iterable.length; index = -1;\nif (' + - (obj.array) + - ') { '; - if (support.unindexedChars) { - __p += '\n if (isString(iterable)) {\n iterable = iterable.split(\'\')\n } '; - } - __p += '\n while (++index < length) {\n ' + - (obj.loop) + - ';\n }\n}\nelse { '; - } else if (support.nonEnumArgs) { - __p += '\n var length = iterable.length; index = -1;\n if (length && isArguments(iterable)) {\n while (++index < length) {\n index += \'\';\n ' + - (obj.loop) + - ';\n }\n } else { '; - } - - if (support.enumPrototypes) { - __p += '\n var skipProto = typeof iterable == \'function\';\n '; - } - - if (support.enumErrorProps) { - __p += '\n var skipErrorProps = iterable === errorProto || iterable instanceof Error;\n '; - } - - var conditions = []; if (support.enumPrototypes) { conditions.push('!(skipProto && index == "prototype")'); } if (support.enumErrorProps) { conditions.push('!(skipErrorProps && (index == "message" || index == "name"))'); } - - 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 += - (obj.loop) + - '; '; - if (conditions.length) { - __p += '\n }'; - } - __p += '\n } '; - } else { - __p += '\n for (index in iterable) {\n'; - if (obj.useHas) { conditions.push("hasOwnProperty.call(iterable, index)"); } if (conditions.length) { - __p += ' if (' + - (conditions.join(' && ')) + - ') {\n '; - } - __p += - (obj.loop) + - '; '; - if (conditions.length) { - __p += '\n }'; - } - __p += '\n } '; - if (support.nonEnumShadows) { - __p += '\n\n if (iterable !== objectProto) {\n var ctor = iterable.constructor,\n isProto = iterable === (ctor && ctor.prototype),\n className = iterable === stringProto ? stringClass : iterable === errorProto ? errorClass : toString.call(iterable),\n nonEnum = nonEnumProps[className];\n '; - for (k = 0; k < 7; k++) { - __p += '\n index = \'' + - (obj.shadowedProps[k]) + - '\';\n if ((!(isProto && nonEnum[index]) && hasOwnProperty.call(iterable, index))'; - if (!obj.useHas) { - __p += ' || (!nonEnum[index] && iterable[index] !== objectProto[index])'; - } - __p += ') {\n ' + - (obj.loop) + - ';\n } '; - } - __p += '\n } '; - } - - } - - if (obj.array || support.nonEnumArgs) { - __p += '\n}'; - } - __p += - (obj.bottom) + - ';\nreturn result'; - - return __p - }; - - /*--------------------------------------------------------------------------*/ - - /** - * The base implementation of `_.bind` that creates the bound function and - * sets its meta data. - * - * @private - * @param {Array} bindData The bind data array. - * @returns {Function} Returns the new bound function. - */ - function baseBind(bindData) { - var func = bindData[0], - partialArgs = bindData[2], - thisArg = bindData[4]; - - function bound() { - // `Function#bind` spec - // http://es5.github.io/#x15.3.4.5 - if (partialArgs) { - // avoid `arguments` object deoptimizations by using `slice` instead - // of `Array.prototype.slice.call` and not assigning `arguments` to a - // variable as a ternary expression - var args = slice(partialArgs); - push.apply(args, arguments); - } - // mimic the constructor's `return` behavior - // http://es5.github.io/#x13.2.2 - if (this instanceof bound) { - // ensure `new bound` is an instance of `func` - var thisBinding = baseCreate(func.prototype), - result = func.apply(thisBinding, args || arguments); - return isObject(result) ? result : thisBinding; - } - return func.apply(thisArg, args || arguments); - } - setBindData(bound, bindData); - return bound; - } - - /** - * The base implementation of `_.clone` without argument juggling or support - * for `thisArg` binding. - * - * @private - * @param {*} value The value to clone. - * @param {boolean} [isDeep=false] Specify a deep clone. - * @param {Function} [callback] The function to customize cloning values. - * @param {Array} [stackA=[]] Tracks traversed source objects. - * @param {Array} [stackB=[]] Associates clones with source counterparts. - * @returns {*} Returns the cloned value. - */ - function baseClone(value, isDeep, callback, stackA, stackB) { - if (callback) { - var result = callback(value); - if (typeof result != 'undefined') { - return result; - } - } - // inspect [[Class]] - var isObj = isObject(value); - if (isObj) { - var className = toString.call(value); - if (!cloneableClasses[className] || (!support.nodeClass && isNode(value))) { - return value; - } - var ctor = ctorByClass[className]; - switch (className) { - case boolClass: - case dateClass: - return new ctor(+value); - - case numberClass: - case stringClass: - return new ctor(value); - - case regexpClass: - result = ctor(value.source, reFlags.exec(value)); - result.lastIndex = value.lastIndex; - return result; - } - } else { - return value; - } - var isArr = isArray(value); - if (isDeep) { - // check for circular references and return corresponding clone - var initedStack = !stackA; - stackA || (stackA = getArray()); - stackB || (stackB = getArray()); - - var length = stackA.length; - while (length--) { - if (stackA[length] == value) { - return stackB[length]; - } - } - result = isArr ? ctor(value.length) : {}; - } - else { - result = isArr ? slice(value) : assign({}, value); - } - // add array properties assigned by `RegExp#exec` - if (isArr) { - if (hasOwnProperty.call(value, 'index')) { - result.index = value.index; - } - if (hasOwnProperty.call(value, 'input')) { - result.input = value.input; - } - } - // exit for shallow clone - if (!isDeep) { - return result; - } - // add the source value to the stack of traversed objects - // and associate it with its clone - stackA.push(value); - stackB.push(result); - - // recursively populate clone (susceptible to call stack limits) - (isArr ? baseEach : forOwn)(value, function(objValue, key) { - result[key] = baseClone(objValue, isDeep, callback, stackA, stackB); - }); - - if (initedStack) { - releaseArray(stackA); - releaseArray(stackB); - } - return result; - } - - /** - * The base implementation of `_.create` without support for assigning - * properties to the created object. - * - * @private - * @param {Object} prototype The object to inherit from. - * @returns {Object} Returns the new object. - */ - function baseCreate(prototype, properties) { - return isObject(prototype) ? nativeCreate(prototype) : {}; - } - // fallback for browsers without `Object.create` - if (!nativeCreate) { - baseCreate = (function() { - function Object() {} - return function(prototype) { - if (isObject(prototype)) { - Object.prototype = prototype; - var result = new Object; - Object.prototype = null; - } - return result || context.Object(); - }; - }()); - } - - /** - * The base implementation of `_.createCallback` without support for creating - * "_.pluck" or "_.where" style callbacks. - * - * @private - * @param {*} [func=identity] The value to convert to a callback. - * @param {*} [thisArg] The `this` binding of the created callback. - * @param {number} [argCount] The number of arguments the callback accepts. - * @returns {Function} Returns a callback function. - */ - function baseCreateCallback(func, thisArg, argCount) { - if (typeof func != 'function') { - return identity; - } - // exit early for no `thisArg` or already bound by `Function#bind` - if (typeof thisArg == 'undefined' || !('prototype' in func)) { - return func; - } - var bindData = func.__bindData__; - if (typeof bindData == 'undefined') { - if (support.funcNames) { - bindData = !func.name; - } - bindData = bindData || !support.funcDecomp; - if (!bindData) { - var source = fnToString.call(func); - if (!support.funcNames) { - bindData = !reFuncName.test(source); - } - if (!bindData) { - // checks if `func` references the `this` keyword and stores the result - bindData = reThis.test(source); - setBindData(func, bindData); - } - } - } - // exit early if there are no `this` references or `func` is bound - if (bindData === false || (bindData !== true && bindData[1] & 1)) { - return func; - } - switch (argCount) { - case 1: return function(value) { - return func.call(thisArg, value); - }; - case 2: return function(a, b) { - return func.call(thisArg, a, b); - }; - case 3: return function(value, index, collection) { - return func.call(thisArg, value, index, collection); - }; - case 4: return function(accumulator, value, index, collection) { - return func.call(thisArg, accumulator, value, index, collection); - }; - } - return bind(func, thisArg); - } - - /** - * The base implementation of `createWrapper` that creates the wrapper and - * sets its meta data. - * - * @private - * @param {Array} bindData The bind data array. - * @returns {Function} Returns the new function. - */ - function baseCreateWrapper(bindData) { - var func = bindData[0], - bitmask = bindData[1], - partialArgs = bindData[2], - partialRightArgs = bindData[3], - thisArg = bindData[4], - arity = bindData[5]; - - var isBind = bitmask & 1, - isBindKey = bitmask & 2, - isCurry = bitmask & 4, - isCurryBound = bitmask & 8, - key = func; - - function bound() { - var thisBinding = isBind ? thisArg : this; - if (partialArgs) { - var args = slice(partialArgs); - push.apply(args, arguments); - } - if (partialRightArgs || isCurry) { - args || (args = slice(arguments)); - if (partialRightArgs) { - push.apply(args, partialRightArgs); - } - if (isCurry && args.length < arity) { - bitmask |= 16 & ~32; - return baseCreateWrapper([func, (isCurryBound ? bitmask : bitmask & ~3), args, null, thisArg, arity]); - } - } - args || (args = arguments); - if (isBindKey) { - func = thisBinding[key]; - } - if (this instanceof bound) { - thisBinding = baseCreate(func.prototype); - var result = func.apply(thisBinding, args); - return isObject(result) ? result : thisBinding; - } - return func.apply(thisBinding, args); - } - setBindData(bound, bindData); - return bound; - } - - /** - * The base implementation of `_.difference` that accepts a single array - * of values to exclude. - * - * @private - * @param {Array} array The array to process. - * @param {Array} [values] The array of values to exclude. - * @returns {Array} Returns a new array of filtered values. - */ - function baseDifference(array, values) { - var index = -1, - indexOf = getIndexOf(), - length = array ? array.length : 0, - isLarge = length >= largeArraySize && indexOf === baseIndexOf, - result = []; - - if (isLarge) { - var cache = createCache(values); - if (cache) { - indexOf = cacheIndexOf; - values = cache; - } else { - isLarge = false; - } - } - while (++index < length) { - var value = array[index]; - if (indexOf(values, value) < 0) { - result.push(value); - } - } - if (isLarge) { - releaseObject(values); - } - return result; - } - - /** - * The base implementation of `_.flatten` without support for callback - * shorthands or `thisArg` binding. - * - * @private - * @param {Array} array The array to flatten. - * @param {boolean} [isShallow=false] A flag to restrict flattening to a single level. - * @param {boolean} [isStrict=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 baseFlatten(array, isShallow, isStrict, fromIndex) { - var index = (fromIndex || 0) - 1, - length = array ? array.length : 0, - result = []; - - while (++index < length) { - var value = array[index]; - - if (value && typeof value == 'object' && typeof value.length == 'number' - && (isArray(value) || isArguments(value))) { - // recursively flatten arrays (susceptible to call stack limits) - if (!isShallow) { - value = baseFlatten(value, isShallow, isStrict); - } - var valIndex = -1, - valLength = value.length, - resIndex = result.length; - - result.length += valLength; - while (++valIndex < valLength) { - result[resIndex++] = value[valIndex]; - } - } else if (!isStrict) { - result.push(value); - } - } - return result; - } - - /** - * The base implementation of `_.isEqual`, without support for `thisArg` binding, - * that allows partial "_.where" style comparisons. - * - * @private - * @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 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; - } - } - // 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 - var aWrapped = hasOwnProperty.call(a, '__wrapped__'), - bWrapped = hasOwnProperty.call(b, '__wrapped__'); - - if (aWrapped || bWrapped) { - return baseIsEqual(aWrapped ? a.__wrapped__ : a, bWrapped ? 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) && - ('constructor' in a && 'constructor' in b) - ) { - 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) { - // compare lengths to determine if a deep comparison is necessary - length = a.length; - size = b.length; - result = size == length; - - if (result || isWhere) { - // 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; - } - } - } - } - else { - // 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); - } - }); - } - } - stackA.pop(); - stackB.pop(); - - 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 `_.random` without argument juggling or support - * for returning floating-point numbers. - * - * @private - * @param {number} min The minimum possible value. - * @param {number} max The maximum possible value. - * @returns {number} Returns a random number. - */ - function baseRandom(min, max) { - return min + floor(nativeRandom() * (max - min + 1)); - } - - /** - * 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); - indexOf = cacheIndexOf; - seen = cache; - } - 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 function. - */ - function createWrapper(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; - - 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 && bindData !== true) { - // clone `bindData` - bindData = slice(bindData); - if (bindData[2]) { - bindData[2] = slice(bindData[2]); - } - if (bindData[3]) { - bindData[3] = slice(bindData[3]); - } - // set `thisBinding` is not previously bound - if (isBind && !(bindData[1] & 1)) { - bindData[4] = thisArg; - } - // set if previously bound but not currently (subsequent curried functions) - if (!isBind && bindData[1] & 1) { - bitmask |= 8; - } - // set curried arity if not yet set - if (isCurry && !(bindData[1] & 4)) { - bindData[5] = arity; - } - // append partial left arguments - if (isPartial) { - push.apply(bindData[2] || (bindData[2] = []), partialArgs); - } - // append partial right arguments - if (isPartialRight) { - unshift.apply(bindData[3] || (bindData[3] = []), partialRightArgs); - } - // merge flags - bindData[1] |= bitmask; - return createWrapper.apply(null, bindData); - } - // fast path for `_.bind` - var creater = (bitmask == 1 || bitmask === 17) ? baseBind : baseCreateWrapper; - return creater([func, bitmask, partialArgs, partialRightArgs, thisArg, arity]); - } - - /** - * 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() { - // data properties - iteratorData.shadowedProps = shadowedProps; - - // iterator options - iteratorData.array = iteratorData.bottom = iteratorData.loop = iteratorData.top = ''; - iteratorData.init = 'iterable'; - iteratorData.useHas = true; - - // merge options into a template data object - for (var object, index = 0; object = arguments[index]; index++) { - for (var key in object) { - iteratorData[key] = object[key]; - } - } - var args = iteratorData.args; - iteratorData.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(iteratorData) + '\n}' - ); - - // return the compiled function - return factory( - baseCreateCallback, errorClass, errorProto, hasOwnProperty, - indicatorObject, isArguments, isArray, isString, iteratorData.keys, objectProto, - objectTypes, nonEnumProps, stringClass, stringProto, toString - ); - } - - /** - * 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; - } - - /** - * Checks if `value` is a native function. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is a native function, else `false`. - */ - function isNative(value) { - return typeof value == 'function' && reNative.test(value); - } - - /** - * Sets `this` binding data on a given function. - * - * @private - * @param {Function} func The function to set data on. - * @param {Array} value The data array to set. - */ - var setBindData = !defineProperty ? noop : function(func, value) { - descriptor.value = value; - defineProperty(func, '__bindData__', 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; - } - // In most environments an object's own properties are iterated before - // its inherited properties. If the last iterated property is an object's - // own property then there are no inherited enumerable properties. - forIn(value, function(value, key) { - result = key; - }); - 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. - */ - function unescapeHtmlChar(match) { - return htmlUnescapes[match]; - } - - /*--------------------------------------------------------------------------*/ - - /** - * Checks if `value` is an `arguments` object. - * - * @static - * @memberOf _ - * @category Objects - * @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); - * // => true - * - * _.isArguments([1, 2, 3]); - * // => false - */ - function isArguments(value) { - return value && typeof value == 'object' && typeof value.length == 'number' && - toString.call(value) == argsClass || false; - } - // fallback for browsers that can't detect `arguments` objects by [[Class]] - if (!support.argsClass) { - isArguments = function(value) { - return value && typeof value == 'object' && typeof value.length == 'number' && - hasOwnProperty.call(value, 'callee') && !propertyIsEnumerable.call(value, 'callee') || false; - }; - } - - /** - * Checks if `value` is an array. - * - * @static - * @memberOf _ - * @type Function - * @category Objects - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is an array, else `false`. - * @example - * - * (function() { return _.isArray(arguments); })(); - * // => false - * - * _.isArray([1, 2, 3]); - * // => true - */ - var isArray = nativeIsArray || function(value) { - return value && typeof value == 'object' && typeof value.length == 'number' && - toString.call(value) == arrayClass || false; - }; - - /** - * A fallback implementation of `Object.keys` which produces an array of the - * given object's own enumerable property names. - * - * @private - * @type Function - * @param {Object} object The object to inspect. - * @returns {Array} Returns an array of property names. - */ - var shimKeys = createIterator({ - 'args': 'object', - 'init': '[]', - 'top': 'if (!(objectTypes[typeof object])) return result', - 'loop': 'result.push(index)' - }); - - /** - * 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 an array of property names. - * @example - * - * _.keys({ 'one': 1, 'two': 2, 'three': 3 }); - * // => ['one', 'two', 'three'] (property order is not guaranteed across environments) - */ - var keys = !nativeKeys ? shimKeys : function(object) { - if (!isObject(object)) { - return []; - } - if ((support.enumPrototypes && typeof object == 'function') || - (support.nonEnumArgs && object.length && isArguments(object))) { - return shimKeys(object); - } - return nativeKeys(object); - }; - - /** 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: - * - * Though the `>` character is escaped for symmetry, characters like `>` and `/` - * don't require escaping in HTML and have no special meaning unless they're part - * of a tag or an unquoted attribute value. - * http://mathiasbynens.be/notes/ambiguous-ampersands (under "semi-related fun fact") - */ - var htmlEscapes = { - '&': '&', - '<': '<', - '>': '>', - '"': '"', - "'": ''' - }; - - /** 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 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 _ - * @type Function - * @alias extend - * @category Objects - * @param {Object} object The destination object. - * @param {...Object} [source] The source objects. - * @param {Function} [callback] The function to customize assigning values. - * @param {*} [thisArg] The `this` binding of `callback`. - * @returns {Object} Returns the destination object. - * @example - * - * _.assign({ 'name': 'fred' }, { 'employer': 'slate' }); - * // => { 'name': 'fred', 'employer': 'slate' } - * - * var defaults = _.partialRight(_.assign, function(a, b) { - * return typeof a == 'undefined' ? b : a; - * }); - * - * var object = { 'name': 'barney' }; - * defaults(object, { 'name': 'fred', 'employer': 'slate' }); - * // => { 'name': 'barney', 'employer': 'slate' } - */ - var assign = createIterator(defaultsIteratorOptions, { - 'top': - defaultsIteratorOptions.top.replace(';', - ';\n' + - "if (argsLength > 3 && typeof args[argsLength - 2] == 'function') {\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' + - '}' - ), - 'loop': 'result[index] = callback ? callback(result[index], iterable[index]) : iterable[index]' - }); - - /** - * Creates a clone of `value`. If `isDeep` 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 {*} value The value to clone. - * @param {boolean} [isDeep=false] Specify a deep clone. - * @param {Function} [callback] The function to customize cloning values. - * @param {*} [thisArg] The `this` binding of `callback`. - * @returns {*} Returns the cloned value. - * @example - * - * var characters = [ - * { 'name': 'barney', 'age': 36 }, - * { 'name': 'fred', 'age': 40 } - * ]; - * - * var shallow = _.clone(characters); - * shallow[0] === characters[0]; - * // => true - * - * var deep = _.clone(characters, true); - * deep[0] === characters[0]; - * // => 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, isDeep, callback, thisArg) { - // allows working with "Collections" methods without using their `index` - // and `collection` arguments for `isDeep` and `callback` - if (typeof isDeep != 'boolean' && isDeep != null) { - thisArg = callback; - callback = isDeep; - isDeep = false; - } - return baseClone(value, isDeep, typeof callback == 'function' && baseCreateCallback(callback, thisArg, 1)); - } - - /** - * 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 - * objects created by constructors other than `Object` are cloned to plain `Object` objects. - * See http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm. - * - * @static - * @memberOf _ - * @category Objects - * @param {*} value The value to deep clone. - * @param {Function} [callback] The function to customize cloning values. - * @param {*} [thisArg] The `this` binding of `callback`. - * @returns {*} Returns the deep cloned value. - * @example - * - * var characters = [ - * { 'name': 'barney', 'age': 36 }, - * { 'name': 'fred', 'age': 40 } - * ]; - * - * var deep = _.cloneDeep(characters); - * deep[0] === characters[0]; - * // => false - * - * var view = { - * 'label': 'docs', - * 'node': element - * }; - * - * var clone = _.cloneDeep(view, function(value) { - * return _.isElement(value) ? value.cloneNode(true) : undefined; - * }); - * - * clone.node == view.node; - * // => false - */ - function cloneDeep(value, callback, thisArg) { - return baseClone(value, true, typeof callback == 'function' && baseCreateCallback(callback, thisArg, 1)); - } - - /** - * Creates an object that inherits from the given `prototype` object. If a - * `properties` object is provided its own enumerable properties are assigned - * to the created object. - * - * @static - * @memberOf _ - * @category Objects - * @param {Object} prototype The object to inherit from. - * @param {Object} [properties] The properties to assign to the object. - * @returns {Object} Returns the new object. - * @example - * - * function Shape() { - * this.x = 0; - * this.y = 0; - * } - * - * function Circle() { - * Shape.call(this); - * } - * - * Circle.prototype = _.create(Shape.prototype, { 'constructor': Circle }); - * - * var circle = new Circle; - * circle instanceof Circle; - * // => true - * - * circle instanceof Shape; - * // => true - */ - function create(prototype, properties) { - var result = baseCreate(prototype); - return properties ? assign(result, properties) : result; - } - - /** - * Assigns own enumerable properties of source object(s) to the destination - * object for all destination properties that resolve to `undefined`. Once a - * property is set, additional defaults of the same property will be ignored. - * - * @static - * @memberOf _ - * @type Function - * @category Objects - * @param {Object} object The destination object. - * @param {...Object} [source] The source objects. - * @param- {Object} [guard] Allows working with `_.reduce` without using its - * `key` and `object` arguments as sources. - * @returns {Object} Returns the destination object. - * @example - * - * var object = { 'name': 'barney' }; - * _.defaults(object, { 'name': 'fred', 'employer': 'slate' }); - * // => { 'name': 'barney', 'employer': 'slate' } - */ - var defaults = createIterator(defaultsIteratorOptions); - - /** - * 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. - * - * 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 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 - * - * var characters = { - * 'barney': { 'age': 36, 'blocked': false }, - * 'fred': { 'age': 40, 'blocked': true }, - * 'pebbles': { 'age': 1, 'blocked': false } - * }; - * - * _.findKey(characters, function(chr) { - * return chr.age < 40; - * }); - * // => 'barney' (property order is not guaranteed across environments) - * - * // using "_.where" callback shorthand - * _.findKey(characters, { 'age': 1 }); - * // => 'pebbles' - * - * // using "_.pluck" callback shorthand - * _.findKey(characters, 'blocked'); - * // => 'fred' - */ - function findKey(object, callback, thisArg) { - var result; - callback = lodash.createCallback(callback, thisArg, 3); - forOwn(object, function(value, key, object) { - if (callback(value, key, object)) { - result = key; - return false; - } - }); - return result; - } - - /** - * This method is like `_.findKey` except that it iterates over elements - * of a `collection` in the opposite order. - * - * 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 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 - * - * var characters = { - * 'barney': { 'age': 36, 'blocked': true }, - * 'fred': { 'age': 40, 'blocked': false }, - * 'pebbles': { 'age': 1, 'blocked': true } - * }; - * - * _.findLastKey(characters, function(chr) { - * return chr.age < 40; - * }); - * // => returns `pebbles`, assuming `_.findKey` returns `barney` - * - * // using "_.where" callback shorthand - * _.findLastKey(characters, { 'age': 40 }); - * // => 'fred' - * - * // using "_.pluck" callback shorthand - * _.findLastKey(characters, 'blocked'); - * // => 'pebbles' - */ - 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 _ - * @type Function - * @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 Shape() { - * this.x = 0; - * this.y = 0; - * } - * - * Shape.prototype.move = function(x, y) { - * this.x += x; - * this.y += y; - * }; - * - * _.forIn(new Shape, function(value, key) { - * console.log(key); - * }); - * // => logs 'x', 'y', and 'move' (property order is not guaranteed across environments) - */ - var forIn = createIterator(eachIteratorOptions, forOwnIteratorOptions, { - 'useHas': 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 Shape() { - * this.x = 0; - * this.y = 0; - * } - * - * Shape.prototype.move = function(x, y) { - * this.x += x; - * this.y += y; - * }; - * - * _.forInRight(new Shape, function(value, key) { - * console.log(key); - * }); - * // => logs 'move', 'y', and 'x' assuming `_.forIn ` logs 'x', 'y', and 'move' - */ - 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 _ - * @type Function - * @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 - * - * _.forOwn({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) { - * console.log(key); - * }); - * // => logs '0', '1', and 'length' (property order is not guaranteed across environments) - */ - var forOwn = createIterator(eachIteratorOptions, forOwnIteratorOptions); - - /** - * 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 an array of property names that have function values. - * @example - * - * _.functions(_); - * // => ['all', 'any', 'bind', 'bindAll', 'clone', 'compact', 'compose', ...] - */ - function functions(object) { - var result = []; - forIn(object, function(value, key) { - if (isFunction(value)) { - result.push(key); - } - }); - return result.sort(); - } - - /** - * Checks if the specified property name exists as a direct property of `object`, - * instead of an inherited property. - * - * @static - * @memberOf _ - * @category Objects - * @param {Object} object The object to inspect. - * @param {string} key The name of the property to check. - * @returns {boolean} Returns `true` if key is a direct property, else `false`. - * @example - * - * _.has({ 'a': 1, 'b': 2, 'c': 3 }, 'b'); - * // => true - */ - function has(object, key) { - return object ? hasOwnProperty.call(object, key) : false; - } - - /** - * Creates an object composed of the inverted keys and values of the given object. - * - * @static - * @memberOf _ - * @category Objects - * @param {Object} object The object to invert. - * @returns {Object} Returns the created inverted object. - * @example - * - * _.invert({ 'first': 'fred', 'second': 'barney' }); - * // => { 'fred': 'first', 'barney': 'second' } - */ - function invert(object) { - var index = -1, - props = keys(object), - length = props.length, - result = {}; - - while (++index < length) { - var key = props[index]; - result[object[key]] = key; - } - return result; - } - - /** - * Checks if `value` is a boolean value. - * - * @static - * @memberOf _ - * @category Objects - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is a boolean value, else `false`. - * @example - * - * _.isBoolean(null); - * // => false - */ - function isBoolean(value) { - return value === true || value === false || - value && typeof value == 'object' && toString.call(value) == boolClass || false; - } - - /** - * Checks if `value` is a date. - * - * @static - * @memberOf _ - * @category Objects - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is a date, else `false`. - * @example - * - * _.isDate(new Date); - * // => true - */ - function isDate(value) { - return value && typeof value == 'object' && toString.call(value) == dateClass || false; - } - - /** - * Checks if `value` is a DOM element. - * - * @static - * @memberOf _ - * @category Objects - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is a DOM element, else `false`. - * @example - * - * _.isElement(document.body); - * // => true - */ - function isElement(value) { - return value && value.nodeType === 1 || false; - } - - /** - * Checks if `value` is empty. Arrays, strings, or `arguments` objects with a - * length of `0` and objects with no own enumerable properties are considered - * "empty". - * - * @static - * @memberOf _ - * @category Objects - * @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]); - * // => false - * - * _.isEmpty({}); - * // => true - * - * _.isEmpty(''); - * // => true - */ - function isEmpty(value) { - var result = true; - if (!value) { - return result; - } - var className = toString.call(value), - length = value.length; - - if ((className == arrayClass || className == stringClass || - (support.argsClass ? className == argsClass : isArguments(value))) || - (className == objectClass && typeof length == 'number' && isFunction(value.splice))) { - return !length; - } - forOwn(value, function() { - return (result = false); - }); - return result; - } - - /** - * Performs a deep comparison between two values to determine if they are - * 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 {*} a The value to compare. - * @param {*} b The other value to compare. - * @param {Function} [callback] The function to customize comparing values. - * @param {*} [thisArg] The `this` binding of `callback`. - * @returns {boolean} Returns `true` if the values are equivalent, else `false`. - * @example - * - * var object = { 'name': 'fred' }; - * var copy = { 'name': 'fred' }; - * - * object == copy; - * // => false - * - * _.isEqual(object, copy); - * // => true - * - * var words = ['hello', 'goodbye']; - * var otherWords = ['hi', 'goodbye']; - * - * _.isEqual(words, otherWords, function(a, b) { - * var reGreet = /^(?:hello|hi)$/i, - * aGreet = _.isString(a) && reGreet.test(a), - * bGreet = _.isString(b) && reGreet.test(b); - * - * return (aGreet || bGreet) ? (aGreet == bGreet) : undefined; - * }); - * // => true - */ - 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.io/#x15.1.2.5. - * - * @static - * @memberOf _ - * @category Objects - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is finite, else `false`. - * @example - * - * _.isFinite(-101); - * // => true - * - * _.isFinite('10'); - * // => true - * - * _.isFinite(true); - * // => false - * - * _.isFinite(''); - * // => false - * - * _.isFinite(Infinity); - * // => false - */ - function isFinite(value) { - return nativeIsFinite(value) && !nativeIsNaN(parseFloat(value)); - } - - /** - * Checks if `value` is a function. - * - * @static - * @memberOf _ - * @category Objects - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is a function, else `false`. - * @example - * - * _.isFunction(_); - * // => true - */ - function isFunction(value) { - return typeof value == 'function'; - } - // fallback for older versions of Chrome and Safari - if (isFunction(/x/)) { - isFunction = function(value) { - return typeof value == 'function' && toString.call(value) == funcClass; - }; - } - - /** - * Checks if `value` is the language type of Object. - * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) - * - * @static - * @memberOf _ - * @category Objects - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is an object, else `false`. - * @example - * - * _.isObject({}); - * // => true - * - * _.isObject([1, 2, 3]); - * // => true - * - * _.isObject(1); - * // => false - */ - function isObject(value) { - // check if the value is the ECMAScript language type of Object - // 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]); - } - - /** - * Checks if `value` is `NaN`. - * - * 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 {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is `NaN`, else `false`. - * @example - * - * _.isNaN(NaN); - * // => true - * - * _.isNaN(new Number(NaN)); - * // => true - * - * isNaN(undefined); - * // => true - * - * _.isNaN(undefined); - * // => false - */ - 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; - } - - /** - * Checks if `value` is `null`. - * - * @static - * @memberOf _ - * @category Objects - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is `null`, else `false`. - * @example - * - * _.isNull(null); - * // => true - * - * _.isNull(undefined); - * // => false - */ - function isNull(value) { - return value === null; - } - - /** - * Checks if `value` is a number. - * - * Note: `NaN` is considered a number. See http://es5.github.io/#x8.5. - * - * @static - * @memberOf _ - * @category Objects - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is a number, else `false`. - * @example - * - * _.isNumber(8.4 * 5); - * // => true - */ - function isNumber(value) { - return typeof value == 'number' || - value && typeof value == 'object' && toString.call(value) == numberClass || false; - } - - /** - * Checks if `value` is an object created by the `Object` constructor. - * - * @static - * @memberOf _ - * @category Objects - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a plain object, else `false`. - * @example - * - * function Shape() { - * this.x = 0; - * this.y = 0; - * } - * - * _.isPlainObject(new Shape); - * // => false - * - * _.isPlainObject([1, 2, 3]); - * // => false - * - * _.isPlainObject({ 'x': 0, 'y': 0 }); - * // => true - */ - var isPlainObject = !getPrototypeOf ? shimIsPlainObject : function(value) { - if (!(value && toString.call(value) == objectClass) || (!support.argsClass && isArguments(value))) { - return false; - } - var valueOf = value.valueOf, - objProto = isNative(valueOf) && (objProto = getPrototypeOf(valueOf)) && getPrototypeOf(objProto); - - return objProto - ? (value == objProto || getPrototypeOf(value) == objProto) - : shimIsPlainObject(value); - }; - - /** - * Checks if `value` is a regular expression. - * - * @static - * @memberOf _ - * @category Objects - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is a regular expression, else `false`. - * @example - * - * _.isRegExp(/fred/); - * // => true - */ - function isRegExp(value) { - return value && objectTypes[typeof value] && toString.call(value) == regexpClass || false; - } - - /** - * Checks if `value` is a string. - * - * @static - * @memberOf _ - * @category Objects - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is a string, else `false`. - * @example - * - * _.isString('fred'); - * // => true - */ - function isString(value) { - return typeof value == 'string' || - value && typeof value == 'object' && toString.call(value) == stringClass || false; - } - - /** - * Checks if `value` is `undefined`. - * - * @static - * @memberOf _ - * @category Objects - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is `undefined`, else `false`. - * @example - * - * _.isUndefined(void 0); - * // => true - */ - function isUndefined(value) { - return typeof value == 'undefined'; - } - - /** - * Creates an object with the same keys as `object` and values generated by - * running each own enumerable property of `object` through the callback. - * The callback is bound to `thisArg` and invoked with three arguments; - * (value, key, object). - * - * 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 Objects - * @param {Object} object The object 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 object with values of the results of each `callback` execution. - * @example - * - * _.mapValues({ 'a': 1, 'b': 2, 'c': 3} , function(num) { return num * 3; }); - * // => { 'a': 3, 'b': 6, 'c': 9 } - * - * var characters = { - * 'fred': { 'name': 'fred', 'age': 40 }, - * 'pebbles': { 'name': 'pebbles', 'age': 1 } - * }; - * - * // using "_.pluck" callback shorthand - * _.mapValues(characters, 'age'); - * // => { 'fred': 40, 'pebbles': 1 } - */ - function mapValues(object, callback, thisArg) { - var result = {}; - callback = lodash.createCallback(callback, thisArg, 3); - - forOwn(object, function(value, key, object) { - result[key] = callback(value, key, object); - }); - return result; - } - - /** - * 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 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} [source] The source objects. - * @param {Function} [callback] The function to customize merging properties. - * @param {*} [thisArg] The `this` binding of `callback`. - * @returns {Object} Returns the destination object. - * @example - * - * var names = { - * 'characters': [ - * { 'name': 'barney' }, - * { 'name': 'fred' } - * ] - * }; - * - * var ages = { - * 'characters': [ - * { 'age': 36 }, - * { 'age': 40 } - * ] - * }; - * - * _.merge(names, ages); - * // => { 'characters': [{ 'name': 'barney', 'age': 36 }, { 'name': 'fred', 'age': 40 }] } - * - * var food = { - * 'fruits': ['apple'], - * 'vegetables': ['beet'] - * }; - * - * var otherFood = { - * '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) { - 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 = slice(arguments, 1, length), - index = -1, - stackA = getArray(), - stackB = getArray(); - - 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 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|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 - * - * _.omit({ 'name': 'fred', 'age': 40 }, 'age'); - * // => { 'name': 'fred' } - * - * _.omit({ 'name': 'fred', 'age': 40 }, function(value) { - * return typeof value == 'number'; - * }); - * // => { 'name': 'fred' } - */ - function omit(object, callback, thisArg) { - var result = {}; - if (typeof callback != 'function') { - var props = []; - forIn(object, function(value, key) { - props.push(key); - }); - props = baseDifference(props, baseFlatten(arguments, true, false, 1)); - - var index = -1, - length = props.length; - - while (++index < length) { - var key = props[index]; - result[key] = object[key]; - } - } else { - callback = lodash.createCallback(callback, thisArg, 3); - forIn(object, function(value, key, object) { - if (!callback(value, key, object)) { - result[key] = value; - } - }); - } - return result; - } - - /** - * Creates a two dimensional array of an object's key-value pairs, - * i.e. `[[key1, value1], [key2, value2]]`. - * - * @static - * @memberOf _ - * @category Objects - * @param {Object} object The object to inspect. - * @returns {Array} Returns new array of key-value pairs. - * @example - * - * _.pairs({ 'barney': 36, 'fred': 40 }); - * // => [['barney', 36], ['fred', 40]] (property order is not guaranteed across environments) - */ - function pairs(object) { - var index = -1, - props = keys(object), - length = props.length, - result = Array(length); - - while (++index < length) { - var key = props[index]; - result[index] = [key, object[key]]; - } - return result; - } - - /** - * 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 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 {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 - * - * _.pick({ 'name': 'fred', '_userid': 'fred1' }, 'name'); - * // => { 'name': 'fred' } - * - * _.pick({ 'name': 'fred', '_userid': 'fred1' }, function(value, key) { - * return key.charAt(0) != '_'; - * }); - * // => { 'name': 'fred' } - */ - function pick(object, callback, thisArg) { - var result = {}; - if (typeof callback != 'function') { - var index = -1, - props = baseFlatten(arguments, true, false, 1), - length = isObject(object) ? props.length : 0; - - while (++index < length) { - var key = props[index]; - if (key in object) { - result[key] = object[key]; - } - } - } else { - callback = lodash.createCallback(callback, thisArg, 3); - forIn(object, function(value, key, object) { - if (callback(value, key, object)) { - result[key] = value; - } - }); - } - return result; - } - - /** - * An alternative to `_.reduce` this method transforms `object` to a new - * `accumulator` object which is the result of running each of its own - * enumerable properties 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`. - * - * @static - * @memberOf _ - * @category Objects - * @param {Array|Object} object The object to iterate over. - * @param {Function} [callback=identity] The function called per iteration. - * @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) { - * num *= num; - * if (num % 2) { - * return result.push(num) < 3; - * } - * }); - * // => [1, 9, 25] - * - * var mapped = _.transform({ 'a': 1, 'b': 2, 'c': 3 }, function(result, num, key) { - * result[key] = num * 3; - * }); - * // => { 'a': 3, 'b': 6, 'c': 9 } - */ - function transform(object, callback, accumulator, thisArg) { - var isArr = isArray(object); - if (accumulator == null) { - if (isArr) { - accumulator = []; - } else { - var ctor = object && object.constructor, - proto = ctor && ctor.prototype; - - accumulator = baseCreate(proto); - } - } - if (callback) { - callback = lodash.createCallback(callback, thisArg, 4); - (isArr ? baseEach : forOwn)(object, function(value, index, object) { - return callback(accumulator, value, index, object); - }); - } - return accumulator; - } - - /** - * Creates an array composed of the own enumerable property values of `object`. - * - * @static - * @memberOf _ - * @category Objects - * @param {Object} object The object to inspect. - * @returns {Array} Returns an array of property values. - * @example - * - * _.values({ 'one': 1, 'two': 2, 'three': 3 }); - * // => [1, 2, 3] (property order is not guaranteed across environments) - */ - function values(object) { - var index = -1, - props = keys(object), - length = props.length, - result = Array(length); - - while (++index < length) { - result[index] = object[props[index]]; - } - return result; - } - - /*--------------------------------------------------------------------------*/ - - /** - * Creates an array of elements from the specified indexes, or keys, of the - * `collection`. Indexes may be specified as individual arguments or as arrays - * of indexes. - * - * @static - * @memberOf _ - * @category Collections - * @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 - * - * _.at(['a', 'b', 'c', 'd', 'e'], [0, 2, 4]); - * // => ['a', 'c', 'e'] - * - * _.at(['fred', 'barney', 'pebbles'], 0, 2); - * // => ['fred', 'pebbles'] - */ - function at(collection) { - 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)) { - collection = collection.split(''); - } - while(++index < length) { - result[index] = collection[props[index]]; - } - return result; - } - - /** - * 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 {*} 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); - * // => true - * - * _.contains([1, 2, 3], 1, 2); - * // => false - * - * _.contains({ 'name': 'fred', 'age': 40 }, 'fred'); - * // => true - * - * _.contains('pebbles', 'eb'); - * // => true - */ - function contains(collection, target, fromIndex) { - var index = -1, - indexOf = getIndexOf(), - length = collection ? collection.length : 0, - result = false; - - fromIndex = (fromIndex < 0 ? nativeMax(0, length + fromIndex) : fromIndex) || 0; - 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 { - baseEach(collection, function(value) { - if (++index >= fromIndex) { - return !(result = value === target); - } - }); - } - return result; - } - - /** - * 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 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 - * - * _.countBy([4.3, 6.1, 6.4], function(num) { return Math.floor(num); }); - * // => { '4': 1, '6': 2 } - * - * _.countBy([4.3, 6.1, 6.4], function(num) { return this.floor(num); }, Math); - * // => { '4': 1, '6': 2 } - * - * _.countBy(['one', 'two', 'three'], 'length'); - * // => { '3': 2, '5': 1 } - */ - var countBy = createAggregator(function(result, value, key) { - (hasOwnProperty.call(result, key) ? result[key]++ : result[key] = 1); - }); - - /** - * 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 provided for `callback` the created "_.pluck" style - * callback will return the property value of the given element. - * - * If an object is provided for `callback` the created "_.where" style callback - * will return `true` for elements that have the properties of the given object, - * else `false`. - * - * @static - * @memberOf _ - * @alias 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 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 - * - * _.every([true, 1, null, 'yes']); - * // => false - * - * var characters = [ - * { 'name': 'barney', 'age': 36 }, - * { 'name': 'fred', 'age': 40 } - * ]; - * - * // using "_.pluck" callback shorthand - * _.every(characters, 'age'); - * // => true - * - * // using "_.where" callback shorthand - * _.every(characters, { 'age': 36 }); - * // => false - */ - function every(collection, callback, thisArg) { - var result = true; - callback = lodash.createCallback(callback, thisArg, 3); - - if (isArray(collection)) { - var index = -1, - length = collection.length; - - while (++index < length) { - if (!(result = !!callback(collection[index], index, collection))) { - break; - } - } - } else { - baseEach(collection, function(value, index, collection) { - return (result = !!callback(value, index, collection)); - }); - } - return result; - } - - /** - * 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 provided for `callback` the created "_.pluck" style - * callback will return the property value of the given element. - * - * If an object is provided for `callback` the created "_.where" style callback - * will return `true` for elements that have the properties of the given object, - * else `false`. - * - * @static - * @memberOf _ - * @alias 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 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 - * - * var evens = _.filter([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; }); - * // => [2, 4, 6] - * - * var characters = [ - * { 'name': 'barney', 'age': 36, 'blocked': false }, - * { 'name': 'fred', 'age': 40, 'blocked': true } - * ]; - * - * // using "_.pluck" callback shorthand - * _.filter(characters, 'blocked'); - * // => [{ 'name': 'fred', 'age': 40, 'blocked': true }] - * - * // using "_.where" callback shorthand - * _.filter(characters, { 'age': 36 }); - * // => [{ 'name': 'barney', 'age': 36, 'blocked': false }] - */ - function filter(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]; - if (callback(value, index, collection)) { - result.push(value); - } - } - } else { - baseEach(collection, function(value, index, collection) { - if (callback(value, index, collection)) { - result.push(value); - } - }); - } - return result; - } - - /** - * 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 provided for `callback` the created "_.pluck" style - * callback will return the property value of the given element. - * - * If an object is provided for `callback` the created "_.where" style callback - * will return `true` for elements that have the properties of the given object, - * else `false`. - * - * @static - * @memberOf _ - * @alias 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 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 - * - * var characters = [ - * { 'name': 'barney', 'age': 36, 'blocked': false }, - * { 'name': 'fred', 'age': 40, 'blocked': true }, - * { 'name': 'pebbles', 'age': 1, 'blocked': false } - * ]; - * - * _.find(characters, function(chr) { - * return chr.age < 40; - * }); - * // => { 'name': 'barney', 'age': 36, 'blocked': false } - * - * // using "_.where" callback shorthand - * _.find(characters, { 'age': 1 }); - * // => { 'name': 'pebbles', 'age': 1, 'blocked': false } - * - * // using "_.pluck" callback shorthand - * _.find(characters, 'blocked'); - * // => { 'name': 'fred', 'age': 40, 'blocked': true } - */ - function find(collection, callback, thisArg) { - callback = lodash.createCallback(callback, thisArg, 3); - - if (isArray(collection)) { - var index = -1, - length = collection.length; - - while (++index < length) { - var value = collection[index]; - if (callback(value, index, collection)) { - return value; - } - } - } else { - var result; - baseEach(collection, function(value, index, collection) { - if (callback(value, index, collection)) { - result = value; - return false; - } - }); - return result; - } - } - - /** - * 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`. - * - * Note: As with other "Collections" methods, objects with a `length` property - * are iterated like arrays. To avoid this behavior `_.forIn` or `_.forOwn` - * may be used for object iteration. - * - * @static - * @memberOf _ - * @alias each - * @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]).forEach(function(num) { console.log(num); }).join(','); - * // => logs each number and returns '1,2,3' - * - * _.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)) { - var index = -1, - length = collection.length; - - while (++index < length) { - if (callback(collection[index], index, collection) === false) { - break; - } - } - } else { - 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 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 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 - * - * _.groupBy([4.2, 6.1, 6.4], function(num) { return Math.floor(num); }); - * // => { '4': [4.2], '6': [6.1, 6.4] } - * - * _.groupBy([4.2, 6.1, 6.4], function(num) { return this.floor(num); }, Math); - * // => { '4': [4.2], '6': [6.1, 6.4] } - * - * // using "_.pluck" callback shorthand - * _.groupBy(['one', 'two', 'three'], 'length'); - * // => { '3': ['one', 'two'], '5': ['three'] } - */ - var groupBy = createAggregator(function(result, value, key) { - (hasOwnProperty.call(result, key) ? result[key] : result[key] = []).push(value); - }); - - /** - * 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(characters, 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` - * returning an array of the results of each invoked method. Additional arguments - * 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 - * the function invoked per iteration. - * @param {...*} [arg] Arguments to invoke the method with. - * @returns {Array} Returns a new array of the results of each invoked method. - * @example - * - * _.invoke([[5, 1, 7], [3, 2, 1]], 'sort'); - * // => [[1, 5, 7], [1, 2, 3]] - * - * _.invoke([123, 456], String.prototype.split, ''); - * // => [['1', '2', '3'], ['4', '5', '6']] - */ - function invoke(collection, methodName) { - var args = slice(arguments, 2), - index = -1, - isFunc = typeof methodName == 'function', - length = collection ? collection.length : 0, - result = Array(typeof length == 'number' ? length : 0); - - forEach(collection, function(value) { - result[++index] = (isFunc ? methodName : value[methodName]).apply(value, args); - }); - return result; - } - - /** - * 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 provided for `callback` the created "_.pluck" style - * callback will return the property value of the given element. - * - * If an object is provided for `callback` the created "_.where" style callback - * will return `true` for elements that have the properties of the given object, - * else `false`. - * - * @static - * @memberOf _ - * @alias 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 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 - * - * _.map([1, 2, 3], function(num) { return num * 3; }); - * // => [3, 6, 9] - * - * _.map({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { return num * 3; }); - * // => [3, 6, 9] (property order is not guaranteed across environments) - * - * var characters = [ - * { 'name': 'barney', 'age': 36 }, - * { 'name': 'fred', 'age': 40 } - * ]; - * - * // using "_.pluck" callback shorthand - * _.map(characters, 'name'); - * // => ['barney', 'fred'] - */ - function map(collection, callback, thisArg) { - var index = -1, - length = collection ? collection.length : 0, - result = Array(typeof length == 'number' ? length : 0); - - callback = lodash.createCallback(callback, thisArg, 3); - if (isArray(collection)) { - while (++index < length) { - result[index] = callback(collection[index], index, collection); - } - } else { - baseEach(collection, function(value, key, collection) { - result[++index] = callback(value, key, collection); - }); - } - return result; - } - - /** - * Retrieves the maximum value of a collection. If the collection is empty or - * falsey `-Infinity` is returned. If a callback is provided it will be executed - * for each value in the collection 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 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 {*} Returns the maximum value. - * @example - * - * _.max([4, 2, 8, 6]); - * // => 8 - * - * var characters = [ - * { 'name': 'barney', 'age': 36 }, - * { 'name': 'fred', 'age': 40 } - * ]; - * - * _.max(characters, function(chr) { return chr.age; }); - * // => { 'name': 'fred', 'age': 40 }; - * - * // using "_.pluck" callback shorthand - * _.max(characters, 'age'); - * // => { 'name': 'fred', 'age': 40 }; - */ - function max(collection, callback, thisArg) { - var computed = -Infinity, - result = computed; - - // allows working with functions like `_.map` without using - // their `index` argument as a callback - if (typeof callback != 'function' && thisArg && thisArg[callback] === collection) { - callback = null; - } - if (callback == null && isArray(collection)) { - var index = -1, - length = collection.length; - - while (++index < length) { - var value = collection[index]; - if (value > result) { - result = value; - } - } - } else { - callback = (callback == null && isString(collection)) - ? charAtCallback - : lodash.createCallback(callback, thisArg, 3); - - baseEach(collection, function(value, index, collection) { - var current = callback(value, index, collection); - if (current > computed) { - computed = current; - result = value; - } - }); - } - return result; - } - - /** - * Retrieves the minimum value of a collection. If the collection is empty or - * falsey `Infinity` is returned. If a callback is provided it will be executed - * for each value in the collection 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 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 {*} Returns the minimum value. - * @example - * - * _.min([4, 2, 8, 6]); - * // => 2 - * - * var characters = [ - * { 'name': 'barney', 'age': 36 }, - * { 'name': 'fred', 'age': 40 } - * ]; - * - * _.min(characters, function(chr) { return chr.age; }); - * // => { 'name': 'barney', 'age': 36 }; - * - * // using "_.pluck" callback shorthand - * _.min(characters, 'age'); - * // => { 'name': 'barney', 'age': 36 }; - */ - function min(collection, callback, thisArg) { - var computed = Infinity, - result = computed; - - // allows working with functions like `_.map` without using - // their `index` argument as a callback - if (typeof callback != 'function' && thisArg && thisArg[callback] === collection) { - callback = null; - } - if (callback == null && isArray(collection)) { - var index = -1, - length = collection.length; - - while (++index < length) { - var value = collection[index]; - if (value < result) { - result = value; - } - } - } else { - callback = (callback == null && isString(collection)) - ? charAtCallback - : lodash.createCallback(callback, thisArg, 3); - - baseEach(collection, function(value, index, collection) { - var current = callback(value, index, collection); - if (current < computed) { - computed = current; - result = value; - } - }); - } - return result; - } - - /** - * Retrieves the value of a specified property from all elements in the collection. - * - * @static - * @memberOf _ - * @type Function - * @category Collections - * @param {Array|Object|string} collection The collection to iterate over. - * @param {string} property The name of the property to pluck. - * @returns {Array} Returns a new array of property values. - * @example - * - * var characters = [ - * { 'name': 'barney', 'age': 36 }, - * { 'name': 'fred', 'age': 40 } - * ]; - * - * _.pluck(characters, 'name'); - * // => ['barney', 'fred'] - */ - 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 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 {Function} [callback=identity] The function called per iteration. - * @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) { - * return sum + num; - * }); - * // => 6 - * - * var mapped = _.reduce({ 'a': 1, 'b': 2, 'c': 3 }, function(result, num, key) { - * result[key] = num * 3; - * return result; - * }, {}); - * // => { 'a': 3, 'b': 6, 'c': 9 } - */ - function reduce(collection, callback, accumulator, thisArg) { - var noaccum = arguments.length < 3; - callback = lodash.createCallback(callback, thisArg, 4); - - if (isArray(collection)) { - var index = -1, - length = collection.length; - - if (noaccum) { - accumulator = collection[++index]; - } - while (++index < length) { - accumulator = callback(accumulator, collection[index], index, collection); - } - } else { - baseEach(collection, function(value, index, collection) { - accumulator = noaccum - ? (noaccum = false, value) - : callback(accumulator, value, index, collection) - }); - } - return accumulator; - } - - /** - * 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 {Function} [callback=identity] The function called per iteration. - * @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]]; - * var flat = _.reduceRight(list, function(a, b) { return a.concat(b); }, []); - * // => [4, 5, 2, 3, 0, 1] - */ - function reduceRight(collection, callback, accumulator, thisArg) { - var noaccum = arguments.length < 3; - callback = lodash.createCallback(callback, thisArg, 4); - forEachRight(collection, function(value, index, collection) { - accumulator = noaccum - ? (noaccum = false, value) - : callback(accumulator, value, index, collection); - }); - return accumulator; - } - - /** - * 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 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 {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; }); - * // => [1, 3, 5] - * - * var characters = [ - * { 'name': 'barney', 'age': 36, 'blocked': false }, - * { 'name': 'fred', 'age': 40, 'blocked': true } - * ]; - * - * // using "_.pluck" callback shorthand - * _.reject(characters, 'blocked'); - * // => [{ 'name': 'barney', 'age': 36, 'blocked': false }] - * - * // using "_.where" callback shorthand - * _.reject(characters, { 'age': 36 }); - * // => [{ 'name': 'fred', 'age': 40, 'blocked': true }] - */ - function reject(collection, callback, thisArg) { - callback = lodash.createCallback(callback, thisArg, 3); - return filter(collection, function(value, index, collection) { - return !callback(value, index, collection); - }); - } - - /** - * 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 `index` arguments as `n`. - * @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) { - if (collection && typeof collection.length != 'number') { - collection = values(collection); - } else if (support.unindexedChars && isString(collection)) { - collection = collection.split(''); - } - if (n == null || guard) { - return collection ? collection[baseRandom(0, collection.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. - * @returns {Array} Returns a new shuffled collection. - * @example - * - * _.shuffle([1, 2, 3, 4, 5, 6]); - * // => [4, 1, 6, 3, 5, 2] - */ - function shuffle(collection) { - var index = -1, - length = collection ? collection.length : 0, - result = Array(typeof length == 'number' ? length : 0); - - forEach(collection, function(value) { - var rand = baseRandom(0, ++index); - result[index] = result[rand]; - result[rand] = value; - }); - return result; - } - - /** - * Gets the size of the `collection` by returning `collection.length` for arrays - * and array-like objects or the number of own enumerable properties for objects. - * - * @static - * @memberOf _ - * @category Collections - * @param {Array|Object|string} collection The collection to inspect. - * @returns {number} Returns `collection.length` or number of own enumerable properties. - * @example - * - * _.size([1, 2]); - * // => 2 - * - * _.size({ 'one': 1, 'two': 2, 'three': 3 }); - * // => 3 - * - * _.size('pebbles'); - * // => 7 - */ - function size(collection) { - var length = collection ? collection.length : 0; - return typeof length == 'number' ? length : keys(collection).length; - } - - /** - * Checks if the callback returns a truey value for **any** element of a - * collection. The function returns as soon as it finds a passing value and - * does not iterate over the entire collection. The callback is bound to - * `thisArg` and invoked with three arguments; (value, index|key, collection). - * - * If a property name is provided for `callback` the created "_.pluck" style - * callback will return the property value of the given element. - * - * If an object is provided for `callback` the created "_.where" style callback - * will return `true` for elements that have the properties of the given object, - * else `false`. - * - * @static - * @memberOf _ - * @alias any - * @category Collections - * @param {Array|Object|string} collection The collection to iterate over. - * @param {Function|Object|string} [callback=identity] The function called - * per iteration. If a property name or object is provided it will be used - * to create a "_.pluck" or "_.where" style callback, respectively. - * @param {*} [thisArg] The `this` binding of `callback`. - * @returns {boolean} Returns `true` if any element passed the callback check, - * else `false`. - * @example - * - * _.some([null, 0, 'yes', false], Boolean); - * // => true - * - * var characters = [ - * { 'name': 'barney', 'age': 36, 'blocked': false }, - * { 'name': 'fred', 'age': 40, 'blocked': true } - * ]; - * - * // using "_.pluck" callback shorthand - * _.some(characters, 'blocked'); - * // => true - * - * // using "_.where" callback shorthand - * _.some(characters, { 'age': 1 }); - * // => false - */ - function some(collection, callback, thisArg) { - var result; - callback = lodash.createCallback(callback, thisArg, 3); - - if (isArray(collection)) { - var index = -1, - length = collection.length; - - while (++index < length) { - if ((result = callback(collection[index], index, collection))) { - break; - } - } - } else { - baseEach(collection, function(value, index, collection) { - return !(result = callback(value, index, collection)); - }); - } - return !!result; - } - - /** - * Creates an array of elements, sorted in ascending order by the results of - * running each element in a collection through the callback. This method - * performs a stable sort, that is, it will preserve the original sort order - * of equal elements. The callback is bound to `thisArg` and invoked with - * three arguments; (value, index|key, collection). - * - * If a property name is provided for `callback` the created "_.pluck" style - * callback will return the property value of the given element. - * - * If an array of property names is provided for `callback` the collection - * will be sorted by each property value. - * - * If an object is provided for `callback` the created "_.where" style callback - * will return `true` for elements that have the properties of the given object, - * else `false`. - * - * @static - * @memberOf _ - * @category Collections - * @param {Array|Object|string} collection The collection to iterate over. - * @param {Array|Function|Object|string} [callback=identity] The function called - * per iteration. If a property name or object is provided it will be used - * to create a "_.pluck" or "_.where" style callback, respectively. - * @param {*} [thisArg] The `this` binding of `callback`. - * @returns {Array} Returns a new array of sorted elements. - * @example - * - * _.sortBy([1, 2, 3], function(num) { return Math.sin(num); }); - * // => [3, 1, 2] - * - * _.sortBy([1, 2, 3], function(num) { return this.sin(num); }, Math); - * // => [3, 1, 2] - * - * var characters = [ - * { 'name': 'barney', 'age': 36 }, - * { 'name': 'fred', 'age': 40 }, - * { 'name': 'barney', 'age': 26 }, - * { 'name': 'fred', 'age': 30 } - * ]; - * - * // using "_.pluck" callback shorthand - * _.map(_.sortBy(characters, 'age'), _.values); - * // => [['barney', 26], ['fred', 30], ['barney', 36], ['fred', 40]] - * - * // sorting by multiple properties - * _.map(_.sortBy(characters, ['name', 'age']), _.values); - * // = > [['barney', 26], ['barney', 36], ['fred', 30], ['fred', 40]] - */ - function sortBy(collection, callback, thisArg) { - var index = -1, - isArr = isArray(callback), - length = collection ? collection.length : 0, - result = Array(typeof length == 'number' ? length : 0); - - if (!isArr) { - callback = lodash.createCallback(callback, thisArg, 3); - } - forEach(collection, function(value, key, collection) { - var object = result[++index] = getObject(); - if (isArr) { - object.criteria = map(callback, function(key) { return value[key]; }); - } else { - (object.criteria = getArray())[0] = callback(value, key, collection); - } - object.index = index; - object.value = value; - }); - - length = result.length; - result.sort(compareAscending); - while (length--) { - var object = result[length]; - result[length] = object.value; - if (!isArr) { - releaseArray(object.criteria); - } - releaseObject(object); - } - return result; - } - - /** - * Converts the `collection` to an array. - * - * @static - * @memberOf _ - * @category Collections - * @param {Array|Object|string} collection The collection to convert. - * @returns {Array} Returns the new converted array. - * @example - * - * (function() { return _.toArray(arguments).slice(1); })(1, 2, 3, 4); - * // => [2, 3, 4] - */ - function toArray(collection) { - if (collection && typeof collection.length == 'number') { - return (support.unindexedChars && isString(collection)) - ? collection.split('') - : slice(collection); - } - return values(collection); - } - - /** - * Performs a deep comparison of each element in a `collection` to the given - * `properties` object, returning an array of all elements that have equivalent - * property values. - * - * @static - * @memberOf _ - * @type Function - * @category Collections - * @param {Array|Object|string} collection The collection to iterate over. - * @param {Object} props The object of property values to filter by. - * @returns {Array} Returns a new array of elements that have the given properties. - * @example - * - * var characters = [ - * { 'name': 'barney', 'age': 36, 'pets': ['hoppy'] }, - * { 'name': 'fred', 'age': 40, 'pets': ['baby puss', 'dino'] } - * ]; - * - * _.where(characters, { 'age': 36 }); - * // => [{ 'name': 'barney', 'age': 36, 'pets': ['hoppy'] }] - * - * _.where(characters, { 'pets': ['dino'] }); - * // => [{ 'name': 'fred', 'age': 40, 'pets': ['baby puss', 'dino'] }] - */ - var where = filter; - - /*--------------------------------------------------------------------------*/ - - /** - * 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 array of filtered values. - * @example - * - * _.compact([0, 1, false, 2, '', 3]); - * // => [1, 2, 3] - */ - function compact(array) { - var index = -1, - length = array ? array.length : 0, - result = []; - - while (++index < length) { - var value = array[index]; - if (value) { - result.push(value); - } - } - return result; - } - - /** - * 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} [values] 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]); - * // => [1, 3, 4] - */ - function difference(array) { - return baseDifference(array, baseFlatten(arguments, true, true, 1)); - } - - /** - * 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. - * - * 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 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 - * - * var characters = [ - * { 'name': 'barney', 'age': 36, 'blocked': false }, - * { 'name': 'fred', 'age': 40, 'blocked': true }, - * { 'name': 'pebbles', 'age': 1, 'blocked': false } - * ]; - * - * _.findIndex(characters, function(chr) { - * return chr.age < 20; - * }); - * // => 2 - * - * // using "_.where" callback shorthand - * _.findIndex(characters, { 'age': 36 }); - * // => 0 - * - * // using "_.pluck" callback shorthand - * _.findIndex(characters, 'blocked'); - * // => 1 - */ - function findIndex(array, callback, thisArg) { - var index = -1, - length = array ? array.length : 0; - - callback = lodash.createCallback(callback, thisArg, 3); - while (++index < length) { - if (callback(array[index], index, array)) { - return index; - } - } - return -1; - } - - /** - * This method is like `_.findIndex` except that it iterates over elements - * of a `collection` from right to left. - * - * 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 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 - * - * var characters = [ - * { 'name': 'barney', 'age': 36, 'blocked': true }, - * { 'name': 'fred', 'age': 40, 'blocked': false }, - * { 'name': 'pebbles', 'age': 1, 'blocked': true } - * ]; - * - * _.findLastIndex(characters, function(chr) { - * return chr.age > 30; - * }); - * // => 1 - * - * // using "_.where" callback shorthand - * _.findLastIndex(characters, { 'age': 36 }); - * // => 0 - * - * // using "_.pluck" callback shorthand - * _.findLastIndex(characters, 'blocked'); - * // => 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 provided for `callback` the created "_.pluck" style - * callback will return the property value of the given element. - * - * If an object is provided for `callback` the created "_.where" style callback - * will return `true` for elements that have the properties of the given object, - * else `false`. - * - * @static - * @memberOf _ - * @alias head, take - * @category Arrays - * @param {Array} array The array to query. - * @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 provided it will be used to create a "_.pluck" or "_.where" - * style callback, respectively. - * @param {*} [thisArg] The `this` binding of `callback`. - * @returns {*} Returns the first element(s) of `array`. - * @example - * - * _.first([1, 2, 3]); - * // => 1 - * - * _.first([1, 2, 3], 2); - * // => [1, 2] - * - * _.first([1, 2, 3], function(num) { - * return num < 3; - * }); - * // => [1, 2] - * - * var characters = [ - * { 'name': 'barney', 'blocked': true, 'employer': 'slate' }, - * { 'name': 'fred', 'blocked': false, 'employer': 'slate' }, - * { 'name': 'pebbles', 'blocked': true, 'employer': 'na' } - * ]; - * - * // using "_.pluck" callback shorthand - * _.first(characters, 'blocked'); - * // => [{ 'name': 'barney', 'blocked': true, 'employer': 'slate' }] - * - * // using "_.where" callback shorthand - * _.pluck(_.first(characters, { 'employer': 'slate' }), 'name'); - * // => ['barney', 'fred'] - */ - function first(array, callback, thisArg) { - var n = 0, - length = array ? array.length : 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)); - } - - /** - * Flattens a nested array (the nesting can be to any depth). If `isShallow` - * 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 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 flatten. - * @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 - * - * _.flatten([1, [2], [3, [[4]]]]); - * // => [1, 2, 3, 4]; - * - * _.flatten([1, [2], [3, [[4]]]], true); - * // => [1, 2, 3, [[4]]]; - * - * var characters = [ - * { 'name': 'barney', 'age': 30, 'pets': ['hoppy'] }, - * { 'name': 'fred', 'age': 40, 'pets': ['baby puss', 'dino'] } - * ]; - * - * // using "_.pluck" callback shorthand - * _.flatten(characters, 'pets'); - * // => ['hoppy', 'baby puss', 'dino'] - */ - function flatten(array, isShallow, callback, thisArg) { - // juggle arguments - if (typeof isShallow != 'boolean' && isShallow != null) { - thisArg = callback; - callback = (typeof isShallow != 'function' && thisArg && thisArg[isShallow] === array) ? null : isShallow; - isShallow = false; - } - 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 - * providing `true` for `fromIndex` will run a faster binary search. - * - * @static - * @memberOf _ - * @category Arrays - * @param {Array} array The array to search. - * @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); - * // => 1 - * - * _.indexOf([1, 2, 3, 1, 2, 3], 2, 3); - * // => 4 - * - * _.indexOf([1, 1, 2, 2, 3, 3], 2, true); - * // => 2 - */ - function indexOf(array, value, fromIndex) { - if (typeof fromIndex == 'number') { - var length = array ? array.length : 0; - fromIndex = (fromIndex < 0 ? nativeMax(0, length + fromIndex) : fromIndex || 0); - } else if (fromIndex) { - var index = sortedIndex(array, value); - return array[index] === value ? index : -1; - } - return baseIndexOf(array, value, fromIndex); - } - - /** - * 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 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 query. - * @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 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 slice of `array`. - * @example - * - * _.initial([1, 2, 3]); - * // => [1, 2] - * - * _.initial([1, 2, 3], 2); - * // => [1] - * - * _.initial([1, 2, 3], function(num) { - * return num > 1; - * }); - * // => [1] - * - * var characters = [ - * { 'name': 'barney', 'blocked': false, 'employer': 'slate' }, - * { 'name': 'fred', 'blocked': true, 'employer': 'slate' }, - * { 'name': 'pebbles', 'blocked': true, 'employer': 'na' } - * ]; - * - * // using "_.pluck" callback shorthand - * _.initial(characters, 'blocked'); - * // => [{ 'name': 'barney', 'blocked': false, 'employer': 'slate' }] - * - * // using "_.where" callback shorthand - * _.pluck(_.initial(characters, { 'employer': 'na' }), 'name'); - * // => ['barney', 'fred'] - */ - function initial(array, callback, thisArg) { - var n = 0, - length = array ? array.length : 0; - - 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 == null || thisArg) ? 1 : callback || n; - } - return slice(array, 0, nativeMin(nativeMax(0, length - n), length)); - } - - /** - * Creates an array of unique values present in all provided arrays using - * strict equality for comparisons, i.e. `===`. - * - * @static - * @memberOf _ - * @category Arrays - * @param {...Array} [array] The arrays to inspect. - * @returns {Array} Returns an array of shared values. - * @example - * - * _.intersection([1, 2, 3], [5, 2, 1, 4], [2, 1]); - * // => [1, 2] - */ - function intersection() { - var args = [], - argsIndex = -1, - argsLength = arguments.length, - caches = getArray(), - indexOf = getIndexOf(), - trustIndexOf = indexOf === baseIndexOf, - seen = getArray(); - - while (++argsIndex < argsLength) { - var value = arguments[argsIndex]; - if (isArray(value) || isArguments(value)) { - args.push(value); - caches.push(trustIndexOf && value.length >= largeArraySize && - createCache(argsIndex ? args[argsIndex] : seen)); - } - } - var array = args[0], - index = -1, - length = array ? array.length : 0, - result = []; - - outer: - while (++index < length) { - var cache = caches[0]; - value = array[index]; - - if ((cache ? cacheIndexOf(cache, value) : indexOf(seen, value)) < 0) { - argsIndex = argsLength; - (cache || seen).push(value); - while (--argsIndex) { - cache = caches[argsIndex]; - if ((cache ? cacheIndexOf(cache, value) : indexOf(args[argsIndex], value)) < 0) { - continue outer; - } - } - result.push(value); - } - } - while (argsLength--) { - cache = caches[argsLength]; - if (cache) { - releaseObject(cache); - } - } - releaseArray(caches); - releaseArray(seen); - return result; - } - - /** - * 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 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 query. - * @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 provided it will be used to create a "_.pluck" or "_.where" - * style callback, respectively. - * @param {*} [thisArg] The `this` binding of `callback`. - * @returns {*} Returns the last element(s) of `array`. - * @example - * - * _.last([1, 2, 3]); - * // => 3 - * - * _.last([1, 2, 3], 2); - * // => [2, 3] - * - * _.last([1, 2, 3], function(num) { - * return num > 1; - * }); - * // => [2, 3] - * - * var characters = [ - * { 'name': 'barney', 'blocked': false, 'employer': 'slate' }, - * { 'name': 'fred', 'blocked': true, 'employer': 'slate' }, - * { 'name': 'pebbles', 'blocked': true, 'employer': 'na' } - * ]; - * - * // using "_.pluck" callback shorthand - * _.pluck(_.last(characters, 'blocked'), 'name'); - * // => ['fred', 'pebbles'] - * - * // using "_.where" callback shorthand - * _.last(characters, { 'employer': 'na' }); - * // => [{ 'name': 'pebbles', 'blocked': true, 'employer': 'na' }] - */ - function last(array, callback, thisArg) { - var n = 0, - length = array ? array.length : 0; - - 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)); - } - - /** - * Gets the index at which the last occurrence of `value` is found using strict - * equality for comparisons, i.e. `===`. If `fromIndex` is negative, it is used - * as the offset from the end of the 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 Arrays - * @param {Array} array The array to search. - * @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); - * // => 4 - * - * _.lastIndexOf([1, 2, 3, 1, 2, 3], 2, 3); - * // => 1 - */ - function lastIndexOf(array, value, fromIndex) { - var index = array ? array.length : 0; - if (typeof fromIndex == 'number') { - index = (fromIndex < 0 ? nativeMax(0, index + fromIndex) : nativeMin(fromIndex, index - 1)) + 1; - } - while (index--) { - if (array[index] === value) { - return index; - } - } - 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`. 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. - * @returns {Array} Returns a new range array. - * @example - * - * _.range(4); - * // => [0, 1, 2, 3] - * - * _.range(1, 5); - * // => [1, 2, 3, 4] - * - * _.range(0, 20, 5); - * // => [0, 5, 10, 15] - * - * _.range(0, -4, -1); - * // => [0, -1, -2, -3] - * - * _.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] - * - * console.log(evens); - * // => [2, 4, 6] - */ - function remove(array, callback, thisArg) { - var index = -1, - length = array ? array.length : 0, - result = []; - - callback = lodash.createCallback(callback, thisArg, 3); - while (++index < length) { - 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 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 provided for `callback` the created "_.pluck" style - * callback will return the property value of the given element. - * - * If an object is provided for `callback` the created "_.where" style callback - * will return `true` for elements that have the properties of the given object, - * else `false`. - * - * @static - * @memberOf _ - * @alias drop, tail - * @category Arrays - * @param {Array} array The array to query. - * @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 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 slice of `array`. - * @example - * - * _.rest([1, 2, 3]); - * // => [2, 3] - * - * _.rest([1, 2, 3], 2); - * // => [3] - * - * _.rest([1, 2, 3], function(num) { - * return num < 3; - * }); - * // => [3] - * - * var characters = [ - * { 'name': 'barney', 'blocked': true, 'employer': 'slate' }, - * { 'name': 'fred', 'blocked': false, 'employer': 'slate' }, - * { 'name': 'pebbles', 'blocked': true, 'employer': 'na' } - * ]; - * - * // using "_.pluck" callback shorthand - * _.pluck(_.rest(characters, 'blocked'), 'name'); - * // => ['fred', 'pebbles'] - * - * // using "_.where" callback shorthand - * _.rest(characters, { 'employer': 'slate' }); - * // => [{ 'name': 'pebbles', 'blocked': true, 'employer': 'na' }] - */ - function rest(array, callback, thisArg) { - if (typeof callback != 'number' && callback != null) { - var n = 0, - index = -1, - length = array ? array.length : 0; - - callback = lodash.createCallback(callback, thisArg, 3); - while (++index < length && callback(array[index], index, array)) { - n++; - } - } else { - n = (callback == null || thisArg) ? 1 : nativeMax(0, callback); - } - return slice(array, n); - } - - /** - * 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 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 inspect. - * @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 - * - * _.sortedIndex([20, 30, 50], 40); - * // => 2 - * - * // using "_.pluck" callback shorthand - * _.sortedIndex([{ 'x': 20 }, { 'x': 30 }, { 'x': 50 }], { 'x': 40 }, 'x'); - * // => 2 - * - * var dict = { - * 'wordToNumber': { 'twenty': 20, 'thirty': 30, 'fourty': 40, 'fifty': 50 } - * }; - * - * _.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) { - * return dict.wordToNumber[word]; - * }); - * // => 2 - * - * _.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) { - * return this.wordToNumber[word]; - * }, dict); - * // => 2 - */ - function sortedIndex(array, value, callback, thisArg) { - var low = 0, - high = array ? array.length : low; - - // explicitly reference `identity` for better inlining in Firefox - callback = callback ? lodash.createCallback(callback, thisArg, 1) : identity; - value = callback(value); - - while (low < high) { - var mid = (low + high) >>> 1; - (callback(array[mid]) < value) - ? low = mid + 1 - : high = mid; - } - return low; - } - - /** - * 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} [array] The arrays to inspect. - * @returns {Array} Returns an array of combined values. - * @example - * - * _.union([1, 2, 3], [5, 2, 1, 4], [2, 1]); - * // => [1, 2, 3, 5, 4] - */ - function union() { - return baseUniq(baseFlatten(arguments, true, true)); - } - - /** - * 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 provided for `callback` the created "_.pluck" style - * callback will return the property value of the given element. - * - * If an object is provided for `callback` the created "_.where" style callback - * will return `true` for elements that have the properties of the given object, - * else `false`. - * - * @static - * @memberOf _ - * @alias unique - * @category Arrays - * @param {Array} array The array to process. - * @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 - * - * _.uniq([1, 2, 1, 3, 1]); - * // => [1, 2, 3] - * - * _.uniq([1, 1, 2, 2, 3], true); - * // => [1, 2, 3] - * - * _.uniq(['A', 'b', 'C', 'a', 'B', 'c'], function(letter) { return letter.toLowerCase(); }); - * // => ['A', 'b', 'C'] - * - * _.uniq([1, 2.5, 3, 1.5, 2, 3.5], function(num) { return this.floor(num); }, Math); - * // => [1, 2.5, 3] - * - * // using "_.pluck" callback shorthand - * _.uniq([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x'); - * // => [{ 'x': 1 }, { 'x': 2 }] - */ - function uniq(array, isSorted, callback, thisArg) { - // juggle arguments - if (typeof isSorted != 'boolean' && isSorted != null) { - thisArg = callback; - callback = (typeof isSorted != 'function' && thisArg && thisArg[isSorted] === array) ? null : isSorted; - isSorted = false; - } - if (callback != null) { - callback = lodash.createCallback(callback, thisArg, 3); - } - return baseUniq(array, isSorted, callback); - } - - /** - * 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 {...*} [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); - * // => [2, 3, 4] - */ - function without(array) { - return baseDifference(array, slice(arguments, 1)); - } - - /** - * Creates an array that is the symmetric difference of the provided arrays. - * See http://en.wikipedia.org/wiki/Symmetric_difference. - * - * @static - * @memberOf _ - * @category Arrays - * @param {...Array} [array] The arrays to inspect. - * @returns {Array} Returns an array of values. - * @example - * - * _.xor([1, 2, 3], [5, 2, 1, 4]); - * // => [3, 5, 4] - * - * _.xor([1, 2, 5], [2, 3, 5], [3, 4, 5]); - * // => [1, 4, 5] - */ - function xor() { - var index = -1, - length = arguments.length; - - while (++index < length) { - var array = arguments[index]; - if (isArray(array) || isArguments(array)) { - var result = result - ? baseUniq(baseDifference(result, array).concat(baseDifference(array, result))) - : array; - } - } - return result || []; - } - - /** - * 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} [array] Arrays to process. - * @returns {Array} Returns a new array of grouped elements. - * @example - * - * _.zip(['fred', 'barney'], [30, 40], [true, false]); - * // => [['fred', 30, true], ['barney', 40, false]] - */ - 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`. 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 _ - * @alias object - * @category Arrays - * @param {Array} keys The array of keys. - * @param {Array} [values=[]] The array of values. - * @returns {Object} Returns an object composed of the given keys and - * corresponding values. - * @example - * - * _.zipObject(['fred', 'barney'], [30, 40]); - * // => { 'fred': 30, 'barney': 40 } - */ - function zipObject(keys, values) { - var index = -1, - length = keys ? keys.length : 0, - result = {}; - - if (!values && length && !isArray(keys[0])) { - values = []; - } - while (++index < length) { - var key = keys[index]; - if (values) { - result[key] = values[index]; - } else if (key) { - result[key[0]] = key[1]; - } - } - return result; - } - - /*--------------------------------------------------------------------------*/ - - /** - * Creates a function that executes `func`, with the `this` binding and - * arguments of the created function, only after being called `n` times. - * - * @static - * @memberOf _ - * @category Functions - * @param {number} n The number of times the function must be called before - * `func` is executed. - * @param {Function} func The function to restrict. - * @returns {Function} Returns the new restricted function. - * @example - * - * var saves = ['profile', 'settings']; - * - * var done = _.after(saves.length, function() { - * console.log('Done saving!'); - * }); - * - * _.forEach(saves, function(type) { - * asyncSave({ 'type': type, 'complete': done }); - * }); - * // => logs 'Done saving!', after all saves have completed - */ - function after(n, func) { - if (!isFunction(func)) { - throw new TypeError; - } - return function() { - if (--n < 1) { - return func.apply(this, arguments); - } - }; - } - - /** - * Creates a function that, when called, invokes `func` with the `this` - * binding of `thisArg` and prepends any additional `bind` arguments to those - * provided to the bound function. - * - * @static - * @memberOf _ - * @category Functions - * @param {Function} func The function to bind. - * @param {*} [thisArg] The `this` binding of `func`. - * @param {...*} [arg] Arguments to be partially applied. - * @returns {Function} Returns the new bound function. - * @example - * - * var func = function(greeting) { - * return greeting + ' ' + this.name; - * }; - * - * func = _.bind(func, { 'name': 'fred' }, 'hi'); - * func(); - * // => 'hi fred' - */ - function bind(func, thisArg) { - return arguments.length > 2 - ? createWrapper(func, 17, slice(arguments, 2), null, thisArg) - : createWrapper(func, 1, null, null, thisArg); - } - - /** - * Binds methods of an object to the object itself, overwriting the existing - * method. Method names may be specified as individual arguments or as arrays - * of method names. If no method names are provided all the function properties - * of `object` will be bound. - * - * @static - * @memberOf _ - * @category Functions - * @param {Object} object The object to bind and assign the bound methods to. - * @param {...string} [methodName] The object method names to - * bind, specified as individual method names or arrays of method names. - * @returns {Object} Returns `object`. - * @example - * - * var view = { - * 'label': 'docs', - * 'onClick': function() { console.log('clicked ' + this.label); } - * }; - * - * _.bindAll(view); - * jQuery('#docs').on('click', view.onClick); - * // => logs 'clicked docs', when the button is clicked - */ - function bindAll(object) { - var funcs = arguments.length > 1 ? baseFlatten(arguments, true, false, 1) : functions(object), - index = -1, - length = funcs.length; - - while (++index < length) { - var key = funcs[index]; - object[key] = createWrapper(object[key], 1, null, null, object); - } - return object; - } - - /** - * Creates a function that, when called, invokes the method at `object[key]` - * and prepends any additional `bindKey` arguments to those provided to the bound - * function. This method differs from `_.bind` by allowing bound functions to - * reference methods that will be redefined or don't yet exist. - * See http://michaux.ca/articles/lazy-function-definition-pattern. - * - * @static - * @memberOf _ - * @category Functions - * @param {Object} object The object the method belongs to. - * @param {string} key The key of the method. - * @param {...*} [arg] Arguments to be partially applied. - * @returns {Function} Returns the new bound function. - * @example - * - * var object = { - * 'name': 'fred', - * 'greet': function(greeting) { - * return greeting + ' ' + this.name; - * } - * }; - * - * var func = _.bindKey(object, 'greet', 'hi'); - * func(); - * // => 'hi fred' - * - * object.greet = function(greeting) { - * return greeting + 'ya ' + this.name + '!'; - * }; - * - * func(); - * // => 'hiya fred!' - */ - function bindKey(object, key) { - return arguments.length > 2 - ? createWrapper(key, 19, slice(arguments, 2), null, object) - : createWrapper(key, 3, null, null, object); - } - - /** - * Creates a function that is the composition of the provided functions, - * where each function consumes the return value of the function that follows. - * For example, composing the functions `f()`, `g()`, and `h()` produces `f(g(h()))`. - * Each function is executed with the `this` binding of the composed function. - * - * @static - * @memberOf _ - * @category Functions - * @param {...Function} [func] Functions to compose. - * @returns {Function} Returns the new composed function. - * @example - * - * var realNameMap = { - * 'pebbles': 'penelope' - * }; - * - * var format = function(name) { - * name = realNameMap[name.toLowerCase()] || name; - * return name.charAt(0).toUpperCase() + name.slice(1).toLowerCase(); - * }; - * - * var greet = function(formatted) { - * return 'Hiya ' + formatted + '!'; - * }; - * - * var welcome = _.compose(greet, format); - * welcome('pebbles'); - * // => 'Hiya Penelope!' - */ - function compose() { - var funcs = arguments, - length = funcs.length; - - while (length--) { - if (!isFunction(funcs[length])) { - throw new TypeError; - } - } - return function() { - var args = arguments, - length = funcs.length; - - while (length--) { - args = [funcs[length].apply(this, args)]; - } - return args[0]; - }; - } - - /** - * Creates a function which accepts one or more arguments of `func` that when - * invoked either executes `func` returning its result, if all `func` arguments - * have been provided, or returns a function that accepts one or more of the - * remaining `func` arguments, and so on. The arity of `func` can be specified - * if `func.length` is not sufficient. - * - * @static - * @memberOf _ - * @category Functions - * @param {Function} func The function to curry. - * @param {number} [arity=func.length] The arity of `func`. - * @returns {Function} Returns the new curried function. - * @example - * - * var curried = _.curry(function(a, b, c) { - * console.log(a + b + c); - * }); - * - * curried(1)(2)(3); - * // => 6 - * - * curried(1, 2)(3); - * // => 6 - * - * curried(1, 2, 3); - * // => 6 - */ - function curry(func, arity) { - arity = typeof arity == 'number' ? arity : (+arity || func.length); - return createWrapper(func, 4, null, null, null, arity); - } - - /** - * Creates a function that will delay the execution of `func` until after - * `wait` milliseconds have elapsed since the last time it was invoked. - * Provide an options object to indicate that `func` should be invoked on - * the leading and/or trailing edge of the `wait` timeout. Subsequent calls - * to the debounced function will return the result of the last `func` call. - * - * Note: If `leading` and `trailing` options are `true` `func` will be called - * on the trailing edge of the timeout only if the the debounced function is - * invoked more than once during the `wait` timeout. - * - * @static - * @memberOf _ - * @category Functions - * @param {Function} func The function to debounce. - * @param {number} wait The number of milliseconds to delay. - * @param {Object} [options] The options object. - * @param {boolean} [options.leading=false] Specify execution on the leading edge of the timeout. - * @param {number} [options.maxWait] The maximum time `func` is allowed to be delayed before it's called. - * @param {boolean} [options.trailing=true] Specify execution on the trailing edge of the timeout. - * @returns {Function} Returns the new debounced function. - * @example - * - * // avoid costly calculations while the window size is in flux - * var lazyLayout = _.debounce(calculateLayout, 150); - * jQuery(window).on('resize', lazyLayout); - * - * // execute `sendMail` when the click event is fired, debouncing subsequent calls - * jQuery('#postbox').on('click', _.debounce(sendMail, 300, { - * 'leading': true, - * 'trailing': false - * }); - * - * // ensure `batchLog` is executed once after 1 second of debounced calls - * var source = new EventSource('/stream'); - * source.addEventListener('message', _.debounce(batchLog, 250, { - * 'maxWait': 1000 - * }, false); - */ - function debounce(func, wait, options) { - var args, - maxTimeoutId, - result, - stamp, - thisArg, - timeoutId, - trailingCall, - lastCalled = 0, - maxWait = false, - trailing = true; - - if (!isFunction(func)) { - throw new TypeError; - } - wait = nativeMax(0, wait) || 0; - if (options === true) { - var leading = true; - trailing = false; - } else if (isObject(options)) { - leading = options.leading; - maxWait = 'maxWait' in options && (nativeMax(wait, options.maxWait) || 0); - trailing = 'trailing' in options ? options.trailing : trailing; - } - var delayed = function() { - var remaining = wait - (now() - stamp); - if (remaining <= 0) { - if (maxTimeoutId) { - clearTimeout(maxTimeoutId); - } - var isCalled = trailingCall; - maxTimeoutId = timeoutId = trailingCall = undefined; - if (isCalled) { - lastCalled = now(); - result = func.apply(thisArg, args); - if (!timeoutId && !maxTimeoutId) { - args = thisArg = null; - } - } - } else { - timeoutId = setTimeout(delayed, remaining); - } - }; - - var maxDelayed = function() { - if (timeoutId) { - clearTimeout(timeoutId); - } - maxTimeoutId = timeoutId = trailingCall = undefined; - if (trailing || (maxWait !== wait)) { - lastCalled = now(); - result = func.apply(thisArg, args); - if (!timeoutId && !maxTimeoutId) { - args = thisArg = null; - } - } - }; - - return function() { - args = arguments; - stamp = now(); - thisArg = this; - trailingCall = trailing && (timeoutId || !leading); - - if (maxWait === false) { - var leadingCall = leading && !timeoutId; - } else { - if (!maxTimeoutId && !leading) { - lastCalled = stamp; - } - var remaining = maxWait - (stamp - lastCalled), - isCalled = remaining <= 0; - - if (isCalled) { - if (maxTimeoutId) { - maxTimeoutId = clearTimeout(maxTimeoutId); - } - lastCalled = stamp; - result = func.apply(thisArg, args); - } - else if (!maxTimeoutId) { - maxTimeoutId = setTimeout(maxDelayed, remaining); - } - } - if (isCalled && timeoutId) { - timeoutId = clearTimeout(timeoutId); - } - else if (!timeoutId && wait !== maxWait) { - timeoutId = setTimeout(delayed, wait); - } - if (leadingCall) { - isCalled = true; - result = func.apply(thisArg, args); - } - if (isCalled && !timeoutId && !maxTimeoutId) { - args = thisArg = null; - } - return result; - }; - } - - /** - * Defers executing the `func` function until the current call stack has cleared. - * Additional arguments will be provided to `func` when it is invoked. - * - * @static - * @memberOf _ - * @category Functions - * @param {Function} func The function to defer. - * @param {...*} [arg] Arguments to invoke the function with. - * @returns {number} Returns the timer id. - * @example - * - * _.defer(function(text) { console.log(text); }, 'deferred'); - * // logs 'deferred' after one or more milliseconds - */ - function defer(func) { - if (!isFunction(func)) { - throw new TypeError; - } - var args = slice(arguments, 1); - return setTimeout(function() { func.apply(undefined, args); }, 1); - } - - /** - * Executes the `func` function after `wait` milliseconds. Additional arguments - * will be provided to `func` when it is invoked. - * - * @static - * @memberOf _ - * @category Functions - * @param {Function} func The function to delay. - * @param {number} wait The number of milliseconds to delay execution. - * @param {...*} [arg] Arguments to invoke the function with. - * @returns {number} Returns the timer id. - * @example - * - * _.delay(function(text) { console.log(text); }, 1000, 'later'); - * // => logs 'later' after one second - */ - function delay(func, wait) { - if (!isFunction(func)) { - throw new TypeError; - } - var args = slice(arguments, 2); - return setTimeout(function() { func.apply(undefined, args); }, wait); - } - - /** - * Creates a function that memoizes the result of `func`. If `resolver` is - * provided it will be used to determine the cache key for storing the result - * based on the arguments provided to the memoized function. By default, the - * first argument provided to the memoized function is used as the cache key. - * The `func` is executed with the `this` binding of the memoized function. - * The result cache is exposed as the `cache` property on the memoized function. - * - * @static - * @memberOf _ - * @category Functions - * @param {Function} func The function to have its output memoized. - * @param {Function} [resolver] A function used to resolve the cache key. - * @returns {Function} Returns the new memoizing function. - * @example - * - * var fibonacci = _.memoize(function(n) { - * return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2); - * }); - * - * fibonacci(9) - * // => 34 - * - * var data = { - * 'fred': { 'name': 'fred', 'age': 40 }, - * 'pebbles': { 'name': 'pebbles', 'age': 1 } - * }; - * - * // modifying the result cache - * var get = _.memoize(function(name) { return data[name]; }, _.identity); - * get('pebbles'); - * // => { 'name': 'pebbles', 'age': 1 } - * - * get.cache.pebbles.name = 'penelope'; - * get('pebbles'); - * // => { 'name': 'penelope', 'age': 1 } - */ - function memoize(func, resolver) { - if (!isFunction(func)) { - throw new TypeError; - } - var memoized = function() { - var cache = memoized.cache, - key = resolver ? resolver.apply(this, arguments) : keyPrefix + arguments[0]; - - return hasOwnProperty.call(cache, key) - ? cache[key] - : (cache[key] = func.apply(this, arguments)); - } - memoized.cache = {}; - return memoized; - } - - /** - * Creates a function that is restricted to execute `func` once. Repeat calls to - * the function will return the value of the first call. The `func` is executed - * with the `this` binding of the created function. - * - * @static - * @memberOf _ - * @category Functions - * @param {Function} func The function to restrict. - * @returns {Function} Returns the new restricted function. - * @example - * - * var initialize = _.once(createApplication); - * initialize(); - * initialize(); - * // `initialize` executes `createApplication` once - */ - function once(func) { - var ran, - result; - - if (!isFunction(func)) { - throw new TypeError; - } - return function() { - if (ran) { - return result; - } - ran = true; - result = func.apply(this, arguments); - - // clear the `func` variable so the function may be garbage collected - func = null; - return result; - }; - } - - /** - * Creates a function that, when called, invokes `func` with any additional - * `partial` arguments prepended to those provided to the new function. This - * method is similar to `_.bind` except it does **not** alter the `this` binding. - * - * @static - * @memberOf _ - * @category Functions - * @param {Function} func The function to partially apply arguments to. - * @param {...*} [arg] Arguments to be partially applied. - * @returns {Function} Returns the new partially applied function. - * @example - * - * var greet = function(greeting, name) { return greeting + ' ' + name; }; - * var hi = _.partial(greet, 'hi'); - * hi('fred'); - * // => 'hi fred' - */ - function partial(func) { - return createWrapper(func, 16, slice(arguments, 1)); - } - - /** - * This method is like `_.partial` except that `partial` arguments are - * appended to those provided to the new function. - * - * @static - * @memberOf _ - * @category Functions - * @param {Function} func The function to partially apply arguments to. - * @param {...*} [arg] Arguments to be partially applied. - * @returns {Function} Returns the new partially applied function. - * @example - * - * var defaultsDeep = _.partialRight(_.merge, _.defaults); - * - * var options = { - * 'variable': 'data', - * 'imports': { 'jq': $ } - * }; - * - * defaultsDeep(options, _.templateSettings); - * - * options.variable - * // => 'data' - * - * options.imports - * // => { '_': _, 'jq': $ } - */ - function partialRight(func) { - return createWrapper(func, 32, null, slice(arguments, 1)); - } - - /** - * Creates a function that, when executed, will only call the `func` function - * at most once per every `wait` milliseconds. Provide an options object to - * indicate that `func` should be invoked on the leading and/or trailing edge - * of the `wait` timeout. Subsequent calls to the throttled function will - * return the result of the last `func` call. - * - * Note: If `leading` and `trailing` options are `true` `func` will be called - * on the trailing edge of the timeout only if the the throttled function is - * invoked more than once during the `wait` timeout. - * - * @static - * @memberOf _ - * @category Functions - * @param {Function} func The function to throttle. - * @param {number} wait The number of milliseconds to throttle executions to. - * @param {Object} [options] The options object. - * @param {boolean} [options.leading=true] Specify execution on the leading edge of the timeout. - * @param {boolean} [options.trailing=true] Specify execution on the trailing edge of the timeout. - * @returns {Function} Returns the new throttled function. - * @example - * - * // avoid excessively updating the position while scrolling - * var throttled = _.throttle(updatePosition, 100); - * jQuery(window).on('scroll', throttled); - * - * // execute `renewToken` when the click event is fired, but not more than once every 5 minutes - * jQuery('.interactive').on('click', _.throttle(renewToken, 300000, { - * 'trailing': false - * })); - */ - function throttle(func, wait, options) { - var leading = true, - trailing = true; - - if (!isFunction(func)) { - throw new TypeError; - } - if (options === false) { - leading = false; - } else if (isObject(options)) { - leading = 'leading' in options ? options.leading : leading; - trailing = 'trailing' in options ? options.trailing : trailing; - } - debounceOptions.leading = leading; - debounceOptions.maxWait = wait; - debounceOptions.trailing = trailing; - - return debounce(func, wait, debounceOptions); - } - - /** - * Creates a function that provides `value` to the wrapper function as its - * first argument. Additional arguments provided to the function are appended - * to those provided to the wrapper function. The wrapper is executed with - * the `this` binding of the created function. - * - * @static - * @memberOf _ - * @category Functions - * @param {*} value The value to wrap. - * @param {Function} wrapper The wrapper function. - * @returns {Function} Returns the new function. - * @example - * - * var p = _.wrap(_.escape, function(func, text) { - * return '

' + func(text) + '

'; - * }); - * - * p('Fred, Wilma, & Pebbles'); - * // => '

Fred, Wilma, & Pebbles

' - */ - function wrap(value, wrapper) { - return createWrapper(wrapper, 16, [value]); - } - - /*--------------------------------------------------------------------------*/ - - /** - * Creates a function that returns `value`. - * - * @static - * @memberOf _ - * @category Utilities - * @param {*} value The value to return from the new function. - * @returns {Function} Returns the new function. - * @example - * - * var object = { 'name': 'fred' }; - * var getter = _.constant(object); - * getter() === object; - * // => true - */ - function constant(value) { - return function() { - return value; - }; - } - - /** - * Produces a callback bound to an optional `thisArg`. If `func` is a property - * name the created callback will return the property value for a given element. - * If `func` is an object the created callback will return `true` for elements - * that contain the equivalent object properties, otherwise it will return `false`. - * - * @static - * @memberOf _ - * @category Utilities - * @param {*} [func=identity] The value to convert to a callback. - * @param {*} [thisArg] The `this` binding of the created callback. - * @param {number} [argCount] The number of arguments the callback accepts. - * @returns {Function} Returns a callback function. - * @example - * - * var characters = [ - * { 'name': 'barney', 'age': 36 }, - * { 'name': 'fred', 'age': 40 } - * ]; - * - * // wrap to create custom callback shorthands - * _.createCallback = _.wrap(_.createCallback, function(func, callback, thisArg) { - * var match = /^(.+?)__([gl]t)(.+)$/.exec(callback); - * return !match ? func(callback, thisArg) : function(object) { - * return match[2] == 'gt' ? object[match[1]] > match[3] : object[match[1]] < match[3]; - * }; - * }); - * - * _.filter(characters, 'age__gt38'); - * // => [{ 'name': 'fred', 'age': 40 }] - */ - function createCallback(func, thisArg, argCount) { - var type = typeof func; - if (func == null || type == 'function') { - return baseCreateCallback(func, thisArg, argCount); - } - // handle "_.pluck" style callback shorthands - if (type != 'object') { - return property(func); - } - var props = keys(func), - key = props[0], - a = func[key]; - - // handle "_.where" style callback shorthands - if (props.length == 1 && a === a && !isObject(a)) { - // fast path the common case of providing an object with a single - // property containing a primitive value - return function(object) { - var b = object[key]; - return a === b && (a !== 0 || (1 / a == 1 / b)); - }; - } - return function(object) { - var length = props.length, - result = false; - - while (length--) { - if (!(result = baseIsEqual(object[props[length]], func[props[length]], null, true))) { - break; - } - } - return result; - }; - } - - /** - * Converts the characters `&`, `<`, `>`, `"`, and `'` in `string` to their - * corresponding HTML entities. - * - * @static - * @memberOf _ - * @category Utilities - * @param {string} string The string to escape. - * @returns {string} Returns the escaped string. - * @example - * - * _.escape('Fred, Wilma, & Pebbles'); - * // => 'Fred, Wilma, & Pebbles' - */ - function escape(string) { - return string == null ? '' : String(string).replace(reUnescapedHtml, escapeHtmlChar); - } - - /** - * This method returns the first argument provided to it. - * - * @static - * @memberOf _ - * @category Utilities - * @param {*} value Any value. - * @returns {*} Returns `value`. - * @example - * - * var object = { 'name': 'fred' }; - * _.identity(object) === object; - * // => true - */ - function identity(value) { - return value; - } - - /** - * Adds function properties of a source object to the destination object. - * If `object` is a function methods will be added to its prototype as well. - * - * @static - * @memberOf _ - * @category Utilities - * @param {Function|Object} [object=lodash] object The destination object. - * @param {Object} source The object of functions to add. - * @param {Object} [options] The options object. - * @param {boolean} [options.chain=true] Specify whether the functions added are chainable. - * @example - * - * function capitalize(string) { - * return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase(); - * } - * - * _.mixin({ 'capitalize': capitalize }); - * _.capitalize('fred'); - * // => 'Fred' - * - * _('fred').capitalize().value(); - * // => 'Fred' - * - * _.mixin({ 'capitalize': capitalize }, { 'chain': false }); - * _('fred').capitalize(); - * // => 'Fred' - */ - function mixin(object, source, options) { - var chain = true, - methodNames = source && functions(source); - - if (!source || (!options && !methodNames.length)) { - if (options == null) { - options = source; - } - ctor = lodashWrapper; - source = object; - object = lodash; - methodNames = functions(source); - } - if (options === false) { - chain = false; - } else if (isObject(options) && 'chain' in options) { - chain = options.chain; - } - var ctor = object, - isFunc = isFunction(ctor); - - forEach(methodNames, function(methodName) { - var func = object[methodName] = source[methodName]; - if (isFunc) { - ctor.prototype[methodName] = function() { - var chainAll = this.__chain__, - value = this.__wrapped__, - args = [value]; - - push.apply(args, arguments); - var result = func.apply(object, args); - if (chain || chainAll) { - if (value === result && isObject(result)) { - return this; - } - result = new ctor(result); - result.__chain__ = chainAll; - } - return result; - }; - } - }); - } - - /** - * Reverts the '_' variable to its previous value and returns a reference to - * the `lodash` function. - * - * @static - * @memberOf _ - * @category Utilities - * @returns {Function} Returns the `lodash` function. - * @example - * - * var lodash = _.noConflict(); - */ - function noConflict() { - context._ = oldDash; - return this; - } - - /** - * A no-operation function. - * - * @static - * @memberOf _ - * @category Utilities - * @example - * - * var object = { 'name': 'fred' }; - * _.noop(object) === undefined; - * // => true - */ - function noop() { - // no operation performed - } - - /** - * Gets the number of milliseconds that have elapsed since the Unix epoch - * (1 January 1970 00:00:00 UTC). - * - * @static - * @memberOf _ - * @category Utilities - * @example - * - * var stamp = _.now(); - * _.defer(function() { console.log(_.now() - stamp); }); - * // => logs the number of milliseconds it took for the deferred function to be called - */ - var now = isNative(now = Date.now) && now || function() { - return new Date().getTime(); - }; - - /** - * 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 - * `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.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. - * @example - * - * _.parseInt('08'); - * // => 8 - */ - var parseInt = nativeParseInt(whitespace + '08') == 8 ? nativeParseInt : function(value, radix) { - // Firefox < 21 and Opera < 15 follow the ES3 specified implementation of `parseInt` - return nativeParseInt(isString(value) ? value.replace(reLeadingSpacesAndZeros, '') : value, radix || 0); - }; - - /** - * Creates a "_.pluck" style function, which returns the `key` value of a - * given object. - * - * @static - * @memberOf _ - * @category Utilities - * @param {string} key The name of the property to retrieve. - * @returns {Function} Returns the new function. - * @example - * - * var characters = [ - * { 'name': 'fred', 'age': 40 }, - * { 'name': 'barney', 'age': 36 } - * ]; - * - * var getName = _.property('name'); - * - * _.map(characters, getName); - * // => ['barney', 'fred'] - * - * _.sortBy(characters, getName); - * // => [{ 'name': 'barney', 'age': 36 }, { 'name': 'fred', 'age': 40 }] - */ - function property(key) { - return function(object) { - return object[key]; - }; - } - - /** - * Produces a random number between `min` and `max` (inclusive). If only one - * argument is provided a number between `0` and the given number will be - * returned. If `floating` is truey or either `min` or `max` are floats a - * floating-point number will be returned instead of an integer. - * - * @static - * @memberOf _ - * @category Utilities - * @param {number} [min=0] The minimum possible value. - * @param {number} [max=1] The maximum possible value. - * @param {boolean} [floating=false] Specify returning a floating-point number. - * @returns {number} Returns a random number. - * @example - * - * _.random(0, 5); - * // => an integer between 0 and 5 - * - * _.random(5); - * // => also an integer between 0 and 5 - * - * _.random(5, true); - * // => a floating-point number between 0 and 5 - * - * _.random(1.2, 5.2); - * // => a floating-point number between 1.2 and 5.2 - */ - function random(min, max, floating) { - var noMin = min == null, - noMax = max == null; - - if (floating == null) { - if (typeof min == 'boolean' && noMax) { - floating = min; - min = 1; - } - else if (!noMax && typeof max == 'boolean') { - floating = max; - noMax = true; - } - } - if (noMin && noMax) { - max = 1; - } - min = +min || 0; - if (noMax) { - max = min; - min = 0; - } else { - max = +max || 0; - } - if (floating || min % 1 || max % 1) { - var rand = nativeRandom(); - return nativeMin(min + (rand * (max - min + parseFloat('1e-' + ((rand +'').length - 1)))), max); - } - return baseRandom(min, max); - } - - /** - * Resolves the value of property `key` on `object`. If `key` 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` - * is returned. - * - * @static - * @memberOf _ - * @category Utilities - * @param {Object} object The object to inspect. - * @param {string} key The name of the property to resolve. - * @returns {*} Returns the resolved value. - * @example - * - * var object = { - * 'cheese': 'crumpets', - * 'stuff': function() { - * return 'nonsense'; - * } - * }; - * - * _.result(object, 'cheese'); - * // => 'crumpets' - * - * _.result(object, 'stuff'); - * // => 'nonsense' - */ - function result(object, key) { - if (object) { - var value = object[key]; - return isFunction(value) ? object[key]() : value; - } - } - - /** - * A micro-templating method that handles arbitrary delimiters, preserves - * whitespace, and correctly escapes quotes within interpolated code. - * - * Note: In the development build, `_.template` utilizes sourceURLs for easier - * debugging. See http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl - * - * For more information on precompiling templates see: - * http://lodash.com/custom-builds - * - * For more information on Chrome extension sandboxes see: - * http://developer.chrome.com/stable/extensions/sandboxingEval.html - * - * @static - * @memberOf _ - * @category Utilities - * @param {string} text The template text. - * @param {Object} data The data object used to populate the text. - * @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 the "interpolate" delimiter to create a compiled template - * var compiled = _.template('hello <%= name %>'); - * compiled({ 'name': 'fred' }); - * // => 'hello fred' - * - * // using the "escape" delimiter to escape HTML in data property values - * _.template('<%- value %>', { 'value': ' + +``` + +In Node.js: +```js +// Load the fp build. +var fp = require('lodash/fp'); + +// Load a method category. +var object = require('lodash/fp/object'); + +// Load a single method for smaller builds with browserify/rollup/webpack. +var extend = require('lodash/fp/extend'); +``` + +## Mapping + +Immutable auto-curried iteratee-first data-last methods sound great, but what +does that really mean for each method? Below is a breakdown of the mapping used +to convert each method. + +#### Capped Iteratee Arguments + +Iteratee arguments are capped to avoid gotchas with variadic iteratees. +```js +// The `lodash/map` iteratee receives three arguments: +// (value, index|key, collection) +_.map(['6', '8', '10'], parseInt); +// ➜ [6, NaN, 2] + +// The `lodash/fp/map` iteratee is capped at one argument: +// (value) +fp.map(parseInt)(['6', '8', '10']); +// ➜ [6, 8, 10] +``` + +Methods that cap iteratees to one argument:
+<%= toFuncList(_.keys(_.pickBy(mapping.iterateeAry, _.partial(_.eq, _, 1)))) %> + +Methods that cap iteratees to two arguments:
+<%= toFuncList(_.keys(_.pickBy(mapping.iterateeAry, _.partial(_.eq, _, 2)))) %> + +The iteratee of `mapKeys` is capped to one argument: `(key)` + +#### Fixed Arity + +Methods have fixed arities to support auto-currying. +```js +// `lodash/padStart` accepts an optional `chars` param. +_.padStart('a', 3, '-') +// ➜ '--a' + +// `lodash/fp/padStart` does not. +fp.padStart(3)('a'); +// ➜ ' a' +fp.padCharsStart('-')(3)('a'); +// ➜ '--a' +``` + +Methods with a fixed arity of one:
+<%= toFuncList(_.difference(mapping.aryMethod[1], _.keys(mapping.skipFixed))) %> + +Methods with a fixed arity of two:
+<%= toFuncList(_.difference(mapping.aryMethod[2], _.keys(mapping.skipFixed))) %> + +Methods with a fixed arity of three:
+<%= toFuncList(_.difference(mapping.aryMethod[3], _.keys(mapping.skipFixed))) %> + +Methods with a fixed arity of four:
+<%= toFuncList(_.difference(mapping.aryMethod[4], _.keys(mapping.skipFixed))) %> + +#### Rearranged Arguments + +Method arguments are rearranged to make composition easier. +```js +// `lodash/filter` is data-first iteratee-last: +// (collection, iteratee) +var compact = _.partial(_.filter, _, Boolean); +compact(['a', null, 'c']); +// ➜ ['a', 'c'] + +// `lodash/fp/filter` is iteratee-first data-last: +// (iteratee, collection) +var compact = fp.filter(Boolean); +compact(['a', null, 'c']); +// ➜ ['a', 'c'] +``` + +##### Most methods follow these rules + +A fixed arity of two has an argument order of:
+<%= toArgOrder(mapping.aryRearg[2]) %> + +A fixed arity of three has an argument order of:
+<%= toArgOrder(mapping.aryRearg[3]) %> + +A fixed arity of four has an argument order of:
+<%= toArgOrder(mapping.aryRearg[4]) %> + +##### Exceptions to the rules + +Methods that accept an array as their last, second to last, or only argument:
+<%= toFuncList(_.keys(mapping.methodSpread)) %> + +Methods with unchanged argument orders:
+<%= toFuncList(_.keys(mapping.skipRearg)) %> + +Methods with custom argument orders:
+<%= _.map(_.keys(mapping.methodRearg), methodName => { + const orders = mapping.methodRearg[methodName]; + return ' * `_.' + methodName + '` has an order of ' + toArgOrder(orders); +}).join('\n') %> + +The iteratee of `reduceRight` has an argument order of: `(b, a)` + +#### New Methods + +Not all variadic methods have corresponding new method variants. Feel free to +[request](https://github.com/lodash/lodash/blob/master/.github/CONTRIBUTING.md#feature-requests) +any additions. + +Methods created to accommodate Lodash’s variadic methods:
+<%= toFuncList(_.keys(mapping.remap)) %> + +#### Aliases + +There are <%= _.size(mapping.aliasToReal) %> method aliases:
+<%= _.map(_.keys(mapping.aliasToReal).sort(), alias => { + const realName = mapping.aliasToReal[alias]; + return ' * `_.' + alias + '` is an alias of `_.' + realName + '`'; +}).join('\n') %> + +## Placeholders + +The placeholder argument, which defaults to `_`, may be used to fill in method +arguments in a different order. Placeholders are filled by the first available +arguments of the curried returned function. +```js +// The equivalent of `2 > 5`. +_.gt(2)(5); +// ➜ false + +// The equivalent of `_.gt(5, 2)` or `5 > 2`. +_.gt(_, 2)(5); +// ➜ true +``` + +## Chaining + +The `lodash/fp` module **does not** convert chain sequence methods. See +[Izaak Schroeder’s article](https://medium.com/making-internets/why-using-chain-is-a-mistake-9bc1f80d51ba) +on using functional composition as an alternative to method chaining. + +## Convert + +Although `lodash/fp` & its method modules come pre-converted, there are times +when you may want to customize the conversion. That’s when the `convert` method +comes in handy. +```js +// Every option is `true` by default. +var _fp = fp.convert({ + // Specify capping iteratee arguments. + 'cap': true, + // Specify currying. + 'curry': true, + // Specify fixed arity. + 'fixed': true, + // Specify immutable operations. + 'immutable': true, + // Specify rearranging arguments. + 'rearg': true +}); + +// The `convert` method is available on each method too. +var mapValuesWithKey = fp.mapValues.convert({ 'cap': false }); + +// Here’s an example of disabling iteratee argument caps to access the `key` param. +mapValuesWithKey(function(value, key) { + return key == 'a' ? -1 : value; +})({ 'a': 1, 'b': 1 }); +// => { 'a': -1, 'b': 1 } +``` + +Manual conversions are also possible with the `convert` module. +```js +var convert = require('lodash/fp/convert'); + +// Convert by name. +var assign = convert('assign', require('lodash.assign')); + +// Convert by object. +var fp = convert({ + 'assign': require('lodash.assign'), + 'chunk': require('lodash.chunk') +}); + +// Convert by `lodash` instance. +var fp = convert(lodash.runInContext()); +``` + +## Tooling + +Use [eslint-plugin-lodash-fp](https://www.npmjs.com/package/eslint-plugin-lodash-fp) +to help use `lodash/fp` more efficiently. diff --git a/lib/fp/template/modules/_falseOptions.jst b/lib/fp/template/modules/_falseOptions.jst new file mode 100644 index 0000000000..773235e343 --- /dev/null +++ b/lib/fp/template/modules/_falseOptions.jst @@ -0,0 +1,7 @@ +module.exports = { + 'cap': false, + 'curry': false, + 'fixed': false, + 'immutable': false, + 'rearg': false +}; diff --git a/lib/fp/template/modules/_util.jst b/lib/fp/template/modules/_util.jst new file mode 100644 index 0000000000..1dbf36f5d2 --- /dev/null +++ b/lib/fp/template/modules/_util.jst @@ -0,0 +1,16 @@ +module.exports = { + 'ary': require('../ary'), + 'assign': require('../_baseAssign'), + 'clone': require('../clone'), + 'curry': require('../curry'), + 'forEach': require('../_arrayEach'), + 'isArray': require('../isArray'), + 'isError': require('../isError'), + 'isFunction': require('../isFunction'), + 'isWeakMap': require('../isWeakMap'), + 'iteratee': require('../iteratee'), + 'keys': require('../_baseKeys'), + 'rearg': require('../rearg'), + 'toInteger': require('../toInteger'), + 'toPath': require('../toPath') +}; diff --git a/lib/fp/template/modules/alias.jst b/lib/fp/template/modules/alias.jst new file mode 100644 index 0000000000..6d72710a34 --- /dev/null +++ b/lib/fp/template/modules/alias.jst @@ -0,0 +1 @@ +module.exports = require('./<%= name %>'); diff --git a/lib/fp/template/modules/category.jst b/lib/fp/template/modules/category.jst new file mode 100644 index 0000000000..62c2db8a16 --- /dev/null +++ b/lib/fp/template/modules/category.jst @@ -0,0 +1,2 @@ +var convert = require('./convert'); +module.exports = convert(require('../<%= name %>')); diff --git a/lib/fp/template/modules/convert.jst b/lib/fp/template/modules/convert.jst new file mode 100644 index 0000000000..4795dc4246 --- /dev/null +++ b/lib/fp/template/modules/convert.jst @@ -0,0 +1,18 @@ +var baseConvert = require('./_baseConvert'), + util = require('./_util'); + +/** + * Converts `func` of `name` to an immutable auto-curried iteratee-first data-last + * version with conversion `options` applied. If `name` is an object its methods + * will be converted. + * + * @param {string} name The name of the function to wrap. + * @param {Function} [func] The function to wrap. + * @param {Object} [options] The options object. See `baseConvert` for more details. + * @returns {Function|Object} Returns the converted function or object. + */ +function convert(name, func, options) { + return baseConvert(util, name, func, options); +} + +module.exports = convert; diff --git a/lib/fp/template/modules/fp.jst b/lib/fp/template/modules/fp.jst new file mode 100644 index 0000000000..e372dbbdf6 --- /dev/null +++ b/lib/fp/template/modules/fp.jst @@ -0,0 +1,2 @@ +var _ = require('./lodash.min').runInContext(); +module.exports = require('./fp/_baseConvert')(_, _); diff --git a/lib/fp/template/modules/module.jst b/lib/fp/template/modules/module.jst new file mode 100644 index 0000000000..1fb809cb22 --- /dev/null +++ b/lib/fp/template/modules/module.jst @@ -0,0 +1,5 @@ +var convert = require('./convert'), + func = convert('<%= name %>', require('../<%= _.get(mapping.remap, name, name) %>')); + +func.placeholder = require('./placeholder'); +module.exports = func; diff --git a/lib/fp/template/modules/thru.jst b/lib/fp/template/modules/thru.jst new file mode 100644 index 0000000000..838e8b03a8 --- /dev/null +++ b/lib/fp/template/modules/thru.jst @@ -0,0 +1,5 @@ +var convert = require('./convert'), + func = convert('<%= name %>', require('../<%= _.get(mapping.remap, name, name) %>'), require('./_falseOptions')); + +func.placeholder = require('./placeholder'); +module.exports = func; diff --git a/lib/main/build-dist.js b/lib/main/build-dist.js new file mode 100644 index 0000000000..35aac82619 --- /dev/null +++ b/lib/main/build-dist.js @@ -0,0 +1,31 @@ +'use strict'; + +const async = require('async'); +const path = require('path'); + +const file = require('../common/file'); +const util = require('../common/util'); + +const basePath = path.join(__dirname, '..', '..'); +const distPath = path.join(basePath, 'dist'); +const filename = 'lodash.js'; + +const baseLodash = path.join(basePath, filename); +const distLodash = path.join(distPath, filename); + +/*----------------------------------------------------------------------------*/ + +/** + * Creates browser builds of Lodash at the `target` path. + * + * @private + * @param {string} target The output directory path. + */ +function build() { + async.series([ + file.copy(baseLodash, distLodash), + file.min(distLodash) + ], util.pitch); +} + +build(); diff --git a/lib/main/build-doc.js b/lib/main/build-doc.js new file mode 100644 index 0000000000..afabe22cc6 --- /dev/null +++ b/lib/main/build-doc.js @@ -0,0 +1,83 @@ +'use strict'; + +const _ = require('lodash'); +const docdown = require('docdown'); +const fs = require('fs-extra'); +const path = require('path'); + +const util = require('../common/util'); + +const basePath = path.join(__dirname, '..', '..'); +const docPath = path.join(basePath, 'doc'); +const readmePath = path.join(docPath, 'README.md'); + +const pkg = require('../../package.json'); +const version = pkg.version; + +const config = { + 'base': { + 'path': path.join(basePath, 'lodash.js'), + 'title': `lodash v${ version }`, + 'toc': 'categories', + 'url': `https://github.com/lodash/lodash/blob/${ version }/lodash.js` + }, + 'github': { + 'style': 'github', + 'sublinks': [npmLink('Ⓝ', 'See the npm package')] + }, + 'site': { + 'entryLink': '', + 'sourceLink': '[source](${sourceHref})', + 'tocHref': '', + 'tocLink': '', + 'sublinks': [npmLink('npm package')] + } +}; + +/** + * Composes a npm link from `text` and optional `title`. + * + * @private + * @param {string} text The link text. + * @param {string} [title] The link title. + * @returns {string} Returns the composed npm link. + */ +function npmLink(text, title) { + return ( + '<% if (name == "templateSettings" || !/^(?:methods|properties|seq)$/i.test(category)) {' + + 'print(' + + '"[' + text + '](https://www.npmjs.com/package/lodash." + name.toLowerCase() + ' + + '"' + (title == null ? '' : ' \\"' + title + '\\"') + ')"' + + ');' + + '} %>' + ); +} + +/** + * Post-process `markdown` to make adjustments. + * + * @private + * @param {string} markdown The markdown to process. + * @returns {string} Returns the processed markdown. + */ +function postprocess(markdown) { + // Wrap symbol property identifiers in brackets. + return markdown.replace(/\.(Symbol\.(?:[a-z]+[A-Z]?)+)/g, '[$1]'); +} + +/*----------------------------------------------------------------------------*/ + +/** + * Creates the documentation markdown formatted for 'github' or 'site'. + * + * @private + * @param {string} type The format type. + */ +function build(type) { + const options = _.defaults({}, config.base, config[type]); + const markdown = docdown(options); + + fs.writeFile(readmePath, postprocess(markdown), util.pitch); +} + +build(_.last(process.argv)); diff --git a/lib/main/build-modules.js b/lib/main/build-modules.js new file mode 100644 index 0000000000..155e42f1ba --- /dev/null +++ b/lib/main/build-modules.js @@ -0,0 +1,34 @@ +'use strict'; + +const _ = require('lodash'); +const async = require('async'); +const path = require('path'); + +const file = require('../common/file'); +const util = require('../common/util'); + +const basePath = path.join(__dirname, '..', '..'); +const distPath = path.join(basePath, 'dist'); + +const filePairs = [ + [path.join(distPath, 'lodash.core.js'), 'core.js'], + [path.join(distPath, 'lodash.core.min.js'), 'core.min.js'], + [path.join(distPath, 'lodash.min.js'), 'lodash.min.js'] +]; + +/*----------------------------------------------------------------------------*/ + +/** + * Creates supplementary Lodash modules at the `target` path. + * + * @private + * @param {string} target The output directory path. + */ +function build(target) { + const actions = _.map(filePairs, pair => + file.copy(pair[0], path.join(target, pair[1]))); + + async.series(actions, util.pitch); +} + +build(_.last(process.argv)); diff --git a/lib/main/build-site.js b/lib/main/build-site.js new file mode 100644 index 0000000000..ab35da8170 --- /dev/null +++ b/lib/main/build-site.js @@ -0,0 +1,224 @@ +'use strict'; + +const _ = require('lodash'); +const cheerio = require('cheerio'); +const fs = require('fs'); +const marky = require('marky-markdown'); +const path = require('path'); +const util = require('../common/util'); + +const basePath = path.join(__dirname, '..', '..'); +const docPath = path.join(basePath, 'doc'); +const readmePath = path.join(docPath, 'README.md'); + +const highlights = { + 'html': [ + 'string' + ], + 'js': [ + 'comment', + 'console', + 'delimiter', + 'method', + 'modifier', + 'name', + 'numeric', + 'string', + 'support', + 'type' + ] +}; + +const exts = _.keys(highlights); + +/** + * Converts Lodash method references into documentation links. + * + * @private + * @param {Object} $ The Cheerio object. + */ +function autoLink($) { + $('.doc-container code').each(function() { + const $code = $(this); + const html = $code.html(); + if (/^_\.\w+$/.test(html)) { + const id = html.split('.')[1]; + $code.replaceWith(`_.${ id }`); + } + }); +} + +/** + * Removes horizontal rules from the document. + * + * @private + * @param {Object} $ The Cheerio object. + */ +function removeHorizontalRules($) { + $('hr').remove(); +} + +/** + * Removes marky-markdown specific ids and class names. + * + * @private + * @param {Object} $ The Cheerio object. + */ +function removeMarkyAttributes($) { + $('[id^="user-content-"]') + .attr('class', null) + .attr('id', null); + + $(':header:not(h3) > a').each(function() { + const $a = $(this); + $a.replaceWith($a.html()); + }); +} + +/** + * Renames "_" id and anchor references to "lodash". + * + * @private + * @param {Object} $ The Cheerio object. + */ +function renameLodashId($) { + $('#_').attr('id', 'lodash'); + $('[href="#_"]').attr('href', '#lodash'); +} + +/** + * Repairs broken marky-markdown headers. + * See https://github.com/npm/marky-markdown/issues/217 for more details. + * + * @private + * @param {Object} $ The Cheerio object. + */ +function repairMarkyHeaders($) { + $('p:empty + h3').prev().remove(); + + $('h3 ~ p:empty').each(function() { + const $p = $(this); + let node = this.prev; + while ((node = node.prev) && node.name != 'h3' && node.name != 'p') { + $p.prepend(node.next); + } + }); + + $('h3 code em').parent().each(function() { + const $code = $(this); + $code.html($code.html().replace(/<\/?em>/g, '_')); + }); +} + +/** + * Cleans up highlights blocks by removing extraneous class names and elements. + * + * @private + * @param {Object} $ The Cheerio object. + */ +function tidyHighlights($) { + $('.highlight').each(function() { + let $spans; + const $parent = $(this); + const classes = $parent.find('.source,.text').first().attr('class').split(' '); + const ext = _(classes).intersection(exts).last(); + + $parent.addClass(ext); + + // Remove line indicators for single line snippets. + $parent.children('pre').each(function() { + const $divs = $(this).children('div'); + if ($divs.length == 1) { + $divs.replaceWith($divs.html()); + } + }); + // Remove extraneous class names. + $parent.find('[class]').each(function() { + const $element = $(this); + const classes = $element.attr('class').split(' '); + const attr = _(classes).intersection(highlights[ext]).join(' '); + $element.attr('class', attr || null); + }); + // Collapse nested comment highlights. + $parent.find(`[class~="comment"]`).each(function() { + const $element = $(this); + $element.text($element.text().trim()); + }); + // Collapse nested string highlights. + $parent.find(`[class~="string"]`).each(function() { + const $element = $(this); + $element.text($element.text()); + }); + // Collapse nested spans. + while (($spans = $parent.find('span:not([class])')).length) { + $spans.each(function() { + let $span = $(this); + while ($span[0] && $span[0].name == 'span' && !$span.attr('class')) { + const $parent = $span.parent(); + $span.replaceWith($span.html()); + $span = $parent; + } + }); + } + }); +} + +/*----------------------------------------------------------------------------*/ + +/** + * Creates the documentation HTML. + * + * @private + */ +function build() { + const markdown = fs + // Load markdown. + .readFileSync(readmePath, 'utf8') + // Uncomment docdown HTML hints. + .replace(/(<)!--\s*|\s*--(>)/g, '$1$2') + // Convert source and npm package links to anchors. + .replace(/\[source\]$([^)]+)$ \[npm package\]$([^)]+)$/g, (match, href1, href2) => + `

source npm package

` + ); + + const $ = cheerio.load(marky(markdown, { + 'enableHeadingLinkIcons': false, + 'sanitize': false + })); + + const $header = $('h1').first().remove(); + const version = $header.find('span').first().text().trim().slice(1); + + // Auto-link Lodash method references. + autoLink($); + // Rename "_" id references to "lodash". + renameLodashId($); + // Remove docdown horizontal rules. + removeHorizontalRules($); + // Remove marky-markdown attribute additions. + removeMarkyAttributes($); + // Repair marky-markdown wrapping around headers. + repairMarkyHeaders($); + // Cleanup highlights. + tidyHighlights($); + + const html = [ + // Append YAML front matter. + '---', + 'id: docs', + 'layout: docs', + 'title: Lodash Documentation', + 'version: ' + (version || null), + '---', + '', + // Wrap in raw tags to avoid Liquid template tag processing. + '{% raw %}', + $.html().trim(), + '{% endraw %}', + '' + ].join('\n'); + + fs.writeFile(path.join(docPath, version + '.html'), html, util.pitch); +} + +build(); diff --git a/lodash.js b/lodash.js index 5b3790361d..4131e936cd 100644 --- a/lodash.js +++ b/lodash.js @@ -1,2860 +1,12808 @@ /** * @license - * Lo-Dash 2.4.1 - * Copyright 2012-2013 The Dojo Foundation - * Based on Underscore.js 1.5.2 - * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors - * Available under MIT license + * Lodash + * Copyright OpenJS Foundation and other contributors + * Released under MIT license + * Based on Underscore.js 1.8.3 + * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors */ ;(function() { - /** Used as a safe reference for `undefined` in pre ES5 environments */ + /** Used as a safe reference for `undefined` in pre-ES5 environments. */ var undefined; - /** Used to pool arrays and objects used internally */ - var arrayPool = [], - objectPool = []; + /** Used as the semantic version number. */ + var VERSION = '4.17.21'; + + /** Used as the size to enable large array optimizations. */ + var LARGE_ARRAY_SIZE = 200; + + /** Error message constants. */ + var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://npms.io/search?q=ponyfill.', + FUNC_ERROR_TEXT = 'Expected a function', + INVALID_TEMPL_VAR_ERROR_TEXT = 'Invalid `variable` option passed into `_.template`'; + + /** Used to stand-in for `undefined` hash values. */ + var HASH_UNDEFINED = '__lodash_hash_undefined__'; + + /** Used as the maximum memoize cache size. */ + var MAX_MEMOIZE_SIZE = 500; + + /** Used as the internal argument placeholder. */ + var PLACEHOLDER = '__lodash_placeholder__'; + + /** Used to compose bitmasks for cloning. */ + var CLONE_DEEP_FLAG = 1, + CLONE_FLAT_FLAG = 2, + CLONE_SYMBOLS_FLAG = 4; + + /** Used to compose bitmasks for value comparisons. */ + var COMPARE_PARTIAL_FLAG = 1, + COMPARE_UNORDERED_FLAG = 2; + + /** Used to compose bitmasks for function metadata. */ + var WRAP_BIND_FLAG = 1, + WRAP_BIND_KEY_FLAG = 2, + WRAP_CURRY_BOUND_FLAG = 4, + WRAP_CURRY_FLAG = 8, + WRAP_CURRY_RIGHT_FLAG = 16, + WRAP_PARTIAL_FLAG = 32, + WRAP_PARTIAL_RIGHT_FLAG = 64, + WRAP_ARY_FLAG = 128, + WRAP_REARG_FLAG = 256, + WRAP_FLIP_FLAG = 512; + + /** Used as default options for `_.truncate`. */ + var DEFAULT_TRUNC_LENGTH = 30, + DEFAULT_TRUNC_OMISSION = '...'; + + /** Used to detect hot functions by number of calls within a span of milliseconds. */ + var HOT_COUNT = 800, + HOT_SPAN = 16; + + /** Used to indicate the type of lazy iteratees. */ + var LAZY_FILTER_FLAG = 1, + LAZY_MAP_FLAG = 2, + LAZY_WHILE_FLAG = 3; + + /** Used as references for various `Number` constants. */ + var INFINITY = 1 / 0, + MAX_SAFE_INTEGER = 9007199254740991, + MAX_INTEGER = 1.7976931348623157e+308, + NAN = 0 / 0; + + /** Used as references for the maximum length and index of an array. */ + var MAX_ARRAY_LENGTH = 4294967295, + MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1, + HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1; + + /** Used to associate wrap methods with their bit flags. */ + var wrapFlags = [ + ['ary', WRAP_ARY_FLAG], + ['bind', WRAP_BIND_FLAG], + ['bindKey', WRAP_BIND_KEY_FLAG], + ['curry', WRAP_CURRY_FLAG], + ['curryRight', WRAP_CURRY_RIGHT_FLAG], + ['flip', WRAP_FLIP_FLAG], + ['partial', WRAP_PARTIAL_FLAG], + ['partialRight', WRAP_PARTIAL_RIGHT_FLAG], + ['rearg', WRAP_REARG_FLAG] + ]; - /** Used to generate unique IDs */ - var idCounter = 0; + /** `Object#toString` result references. */ + var argsTag = '[object Arguments]', + arrayTag = '[object Array]', + asyncTag = '[object AsyncFunction]', + boolTag = '[object Boolean]', + dateTag = '[object Date]', + domExcTag = '[object DOMException]', + errorTag = '[object Error]', + funcTag = '[object Function]', + genTag = '[object GeneratorFunction]', + mapTag = '[object Map]', + numberTag = '[object Number]', + nullTag = '[object Null]', + objectTag = '[object Object]', + promiseTag = '[object Promise]', + proxyTag = '[object Proxy]', + regexpTag = '[object RegExp]', + setTag = '[object Set]', + stringTag = '[object String]', + symbolTag = '[object Symbol]', + undefinedTag = '[object Undefined]', + weakMapTag = '[object WeakMap]', + weakSetTag = '[object WeakSet]'; + + var arrayBufferTag = '[object ArrayBuffer]', + dataViewTag = '[object DataView]', + float32Tag = '[object Float32Array]', + float64Tag = '[object Float64Array]', + int8Tag = '[object Int8Array]', + int16Tag = '[object Int16Array]', + int32Tag = '[object Int32Array]', + uint8Tag = '[object Uint8Array]', + uint8ClampedTag = '[object Uint8ClampedArray]', + uint16Tag = '[object Uint16Array]', + uint32Tag = '[object Uint32Array]'; + + /** 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 internally to indicate various things */ - var indicatorObject = {}; + /** Used to match HTML entities and HTML characters. */ + var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g, + reUnescapedHtml = /[&<>"']/g, + reHasEscapedHtml = RegExp(reEscapedHtml.source), + reHasUnescapedHtml = RegExp(reUnescapedHtml.source); - /** Used to prefix keys to avoid issues with `__proto__` and properties on `Object.prototype` */ - var keyPrefix = +new Date + ''; + /** Used to match template delimiters. */ + var reEscape = /<%-([\s\S]+?)%>/g, + reEvaluate = /<%([\s\S]+?)%>/g, + reInterpolate = /<%=([\s\S]+?)%>/g; - /** Used as the size when optimizations are enabled for large arrays */ - var largeArraySize = 75; + /** Used to match property names within property paths. */ + var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, + reIsPlainProp = /^\w*$/, + rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; - /** Used as the max size of the `arrayPool` and `objectPool` */ - var maxPoolSize = 40; + /** + * Used to match `RegExp` + * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). + */ + var reRegExpChar = /[\\^$.*+?()[\]{}|]/g, + reHasRegExpChar = RegExp(reRegExpChar.source); - /** Used to detect and test whitespace */ - var whitespace = ( - // whitespace - ' \t\x0B\f\xA0\ufeff' + + /** Used to match leading whitespace. */ + var reTrimStart = /^\s+/; - // line terminators - '\n\r\u2028\u2029' + + /** Used to match a single whitespace character. */ + var reWhitespace = /\s/; - // unicode category "Zs" space separators - '\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000' - ); + /** Used to match wrap detail comments. */ + var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/, + reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/, + reSplitDetails = /,? & /; - /** 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 words composed of alphanumeric characters. */ + var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g; + + /** + * Used to validate the `validate` option in `_.template` variable. + * + * Forbids characters which could potentially change the meaning of the function argument definition: + * - "()," (modification of function parameters) + * - "=" (default value) + * - "[]{}" (destructuring of function parameters) + * - "/" (beginning of a comment) + * - whitespace + */ + var reForbiddenIdentifierChars = /[()=,{}\[\]\/\s]/; + + /** Used to match backslashes in property paths. */ + var reEscapeChar = /\$\$?/g; /** - * Used to match ES6 template delimiters - * http://people.mozilla.org/~jorendorff/es6-draft.html#sec-literals-string-literals + * Used to match + * [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components). */ var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g; - /** Used to match regexp flags from their coerced string values */ + /** Used to match `RegExp` flags from their coerced string values. */ var reFlags = /\w*$/; - /** Used to detected named functions */ - var reFuncName = /^\s*function[ \n\r\t]+\w/; + /** Used to detect bad signed hexadecimal string values. */ + var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; - /** Used to match "interpolate" template delimiters */ - var reInterpolate = /<%=([\s\S]+?)%>/g; + /** Used to detect binary string values. */ + var reIsBinary = /^0b[01]+$/i; - /** Used to match leading whitespace and zeros to be removed */ - var reLeadingSpacesAndZeros = RegExp('^[' + whitespace + ']*0+(?=.$)'); + /** Used to detect host constructors (Safari). */ + var reIsHostCtor = /^\[object .+?Constructor\]$/; - /** Used to ensure capturing order of template delimiters */ - var reNoMatch = /($^)/; + /** Used to detect octal string values. */ + var reIsOctal = /^0o[0-7]+$/i; - /** Used to detect functions containing a `this` reference */ - var reThis = /\bthis\b/; + /** Used to detect unsigned integer values. */ + var reIsUint = /^(?:0|[1-9]\d*)$/; - /** Used to match unescaped characters in compiled string literals */ - var reUnescapedString = /['\n\r\t\u2028\u2029\\]/g; + /** Used to match Latin Unicode letters (excluding mathematical operators). */ + var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g; - /** Used to assign default `context` object properties */ - var contextProps = [ - 'Array', 'Boolean', 'Date', 'Error', 'Function', 'Math', 'Number', 'Object', - 'RegExp', 'String', '_', 'attachEvent', 'clearTimeout', 'isFinite', 'isNaN', - 'parseInt', 'setTimeout' - ]; + /** Used to ensure capturing order of template delimiters. */ + var reNoMatch = /($^)/; - /** Used to fix the JScript [[DontEnum]] bug */ - var shadowedProps = [ - 'constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', - 'toLocaleString', 'toString', 'valueOf' - ]; + /** Used to match unescaped characters in compiled string literals. */ + var reUnescapedString = /['\n\r\u2028\u2029\\]/g; + + /** Used to compose unicode character classes. */ + var rsAstralRange = '\\ud800-\\udfff', + rsComboMarksRange = '\\u0300-\\u036f', + reComboHalfMarksRange = '\\ufe20-\\ufe2f', + rsComboSymbolsRange = '\\u20d0-\\u20ff', + rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange, + rsDingbatRange = '\\u2700-\\u27bf', + rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff', + rsMathOpRange = '\\xac\\xb1\\xd7\\xf7', + rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf', + rsPunctuationRange = '\\u2000-\\u206f', + rsSpaceRange = ' \\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', + rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde', + rsVarRange = '\\ufe0e\\ufe0f', + rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange; + + /** Used to compose unicode capture groups. */ + var rsApos = "['\u2019]", + rsAstral = '[' + rsAstralRange + ']', + rsBreak = '[' + rsBreakRange + ']', + rsCombo = '[' + rsComboRange + ']', + rsDigits = '\\d+', + rsDingbat = '[' + rsDingbatRange + ']', + rsLower = '[' + rsLowerRange + ']', + rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']', + rsFitz = '\\ud83c[\\udffb-\\udfff]', + rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')', + rsNonAstral = '[^' + rsAstralRange + ']', + rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}', + rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]', + rsUpper = '[' + rsUpperRange + ']', + rsZWJ = '\\u200d'; + + /** Used to compose unicode regexes. */ + var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')', + rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')', + rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?', + rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?', + reOptMod = rsModifier + '?', + rsOptVar = '[' + rsVarRange + ']?', + rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*', + rsOrdLower = '\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])', + rsOrdUpper = '\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])', + rsSeq = rsOptVar + reOptMod + rsOptJoin, + rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq, + rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')'; + + /** Used to match apostrophes. */ + var reApos = RegExp(rsApos, 'g'); - /** Used to make template sourceURLs easier to identify */ - var templateCounter = 0; - - /** `Object#toString` result shortcuts */ - var argsClass = '[object Arguments]', - arrayClass = '[object Array]', - boolClass = '[object Boolean]', - dateClass = '[object Date]', - errorClass = '[object Error]', - funcClass = '[object Function]', - numberClass = '[object Number]', - objectClass = '[object Object]', - regexpClass = '[object RegExp]', - stringClass = '[object String]'; - - /** Used to identify object classifications that `_.clone` supports */ - var cloneableClasses = {}; - cloneableClasses[funcClass] = false; - cloneableClasses[argsClass] = cloneableClasses[arrayClass] = - cloneableClasses[boolClass] = cloneableClasses[dateClass] = - cloneableClasses[numberClass] = cloneableClasses[objectClass] = - cloneableClasses[regexpClass] = cloneableClasses[stringClass] = true; - - /** Used as an internal `_.debounce` options object */ - var debounceOptions = { - 'leading': false, - 'maxWait': 0, - 'trailing': false - }; + /** + * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and + * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols). + */ + var reComboMark = RegExp(rsCombo, 'g'); + + /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */ + var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g'); + + /** Used to match complex or compound words. */ + var reUnicodeWord = RegExp([ + rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')', + rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')', + rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower, + rsUpper + '+' + rsOptContrUpper, + rsOrdUpper, + rsOrdLower, + rsDigits, + rsEmoji + ].join('|'), 'g'); + + /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */ + var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + ']'); + + /** Used to detect strings that need a more robust regexp to match words. */ + var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/; + + /** Used to assign default `context` object properties. */ + var contextProps = [ + 'Array', 'Buffer', 'DataView', 'Date', 'Error', 'Float32Array', 'Float64Array', + 'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Map', 'Math', 'Object', + 'Promise', 'RegExp', 'Set', 'String', 'Symbol', 'TypeError', 'Uint8Array', + 'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap', + '_', 'clearTimeout', 'isFinite', 'parseInt', 'setTimeout' + ]; - /** Used as the property descriptor for `__bindData__` */ - var descriptor = { - 'configurable': false, - 'enumerable': false, - 'value': null, - 'writable': false + /** Used to make template sourceURLs easier to identify. */ + var templateCounter = -1; + + /** Used to identify `toStringTag` values of typed arrays. */ + var typedArrayTags = {}; + typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = + typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = + typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = + typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = + typedArrayTags[uint32Tag] = true; + typedArrayTags[argsTag] = typedArrayTags[arrayTag] = + typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = + typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = + typedArrayTags[errorTag] = typedArrayTags[funcTag] = + typedArrayTags[mapTag] = typedArrayTags[numberTag] = + typedArrayTags[objectTag] = typedArrayTags[regexpTag] = + typedArrayTags[setTag] = typedArrayTags[stringTag] = + typedArrayTags[weakMapTag] = false; + + /** Used to identify `toStringTag` values supported by `_.clone`. */ + var cloneableTags = {}; + cloneableTags[argsTag] = cloneableTags[arrayTag] = + cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] = + cloneableTags[boolTag] = cloneableTags[dateTag] = + cloneableTags[float32Tag] = cloneableTags[float64Tag] = + cloneableTags[int8Tag] = cloneableTags[int16Tag] = + cloneableTags[int32Tag] = cloneableTags[mapTag] = + cloneableTags[numberTag] = cloneableTags[objectTag] = + cloneableTags[regexpTag] = cloneableTags[setTag] = + cloneableTags[stringTag] = cloneableTags[symbolTag] = + cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = + cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true; + cloneableTags[errorTag] = cloneableTags[funcTag] = + cloneableTags[weakMapTag] = false; + + /** Used to map Latin Unicode letters to basic Latin letters. */ + var deburredLetters = { + // Latin-1 Supplement block. + '\xc0': 'A', '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A', + '\xe0': 'a', '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a', + '\xc7': 'C', '\xe7': 'c', + '\xd0': 'D', '\xf0': 'd', + '\xc8': 'E', '\xc9': 'E', '\xca': 'E', '\xcb': 'E', + '\xe8': 'e', '\xe9': 'e', '\xea': 'e', '\xeb': 'e', + '\xcc': 'I', '\xcd': 'I', '\xce': 'I', '\xcf': 'I', + '\xec': 'i', '\xed': 'i', '\xee': 'i', '\xef': 'i', + '\xd1': 'N', '\xf1': 'n', + '\xd2': 'O', '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O', + '\xf2': 'o', '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o', + '\xd9': 'U', '\xda': 'U', '\xdb': 'U', '\xdc': 'U', + '\xf9': 'u', '\xfa': 'u', '\xfb': 'u', '\xfc': 'u', + '\xdd': 'Y', '\xfd': 'y', '\xff': 'y', + '\xc6': 'Ae', '\xe6': 'ae', + '\xde': 'Th', '\xfe': 'th', + '\xdf': 'ss', + // Latin Extended-A block. + '\u0100': 'A', '\u0102': 'A', '\u0104': 'A', + '\u0101': 'a', '\u0103': 'a', '\u0105': 'a', + '\u0106': 'C', '\u0108': 'C', '\u010a': 'C', '\u010c': 'C', + '\u0107': 'c', '\u0109': 'c', '\u010b': 'c', '\u010d': 'c', + '\u010e': 'D', '\u0110': 'D', '\u010f': 'd', '\u0111': 'd', + '\u0112': 'E', '\u0114': 'E', '\u0116': 'E', '\u0118': 'E', '\u011a': 'E', + '\u0113': 'e', '\u0115': 'e', '\u0117': 'e', '\u0119': 'e', '\u011b': 'e', + '\u011c': 'G', '\u011e': 'G', '\u0120': 'G', '\u0122': 'G', + '\u011d': 'g', '\u011f': 'g', '\u0121': 'g', '\u0123': 'g', + '\u0124': 'H', '\u0126': 'H', '\u0125': 'h', '\u0127': 'h', + '\u0128': 'I', '\u012a': 'I', '\u012c': 'I', '\u012e': 'I', '\u0130': 'I', + '\u0129': 'i', '\u012b': 'i', '\u012d': 'i', '\u012f': 'i', '\u0131': 'i', + '\u0134': 'J', '\u0135': 'j', + '\u0136': 'K', '\u0137': 'k', '\u0138': 'k', + '\u0139': 'L', '\u013b': 'L', '\u013d': 'L', '\u013f': 'L', '\u0141': 'L', + '\u013a': 'l', '\u013c': 'l', '\u013e': 'l', '\u0140': 'l', '\u0142': 'l', + '\u0143': 'N', '\u0145': 'N', '\u0147': 'N', '\u014a': 'N', + '\u0144': 'n', '\u0146': 'n', '\u0148': 'n', '\u014b': 'n', + '\u014c': 'O', '\u014e': 'O', '\u0150': 'O', + '\u014d': 'o', '\u014f': 'o', '\u0151': 'o', + '\u0154': 'R', '\u0156': 'R', '\u0158': 'R', + '\u0155': 'r', '\u0157': 'r', '\u0159': 'r', + '\u015a': 'S', '\u015c': 'S', '\u015e': 'S', '\u0160': 'S', + '\u015b': 's', '\u015d': 's', '\u015f': 's', '\u0161': 's', + '\u0162': 'T', '\u0164': 'T', '\u0166': 'T', + '\u0163': 't', '\u0165': 't', '\u0167': 't', + '\u0168': 'U', '\u016a': 'U', '\u016c': 'U', '\u016e': 'U', '\u0170': 'U', '\u0172': 'U', + '\u0169': 'u', '\u016b': 'u', '\u016d': 'u', '\u016f': 'u', '\u0171': 'u', '\u0173': 'u', + '\u0174': 'W', '\u0175': 'w', + '\u0176': 'Y', '\u0177': 'y', '\u0178': 'Y', + '\u0179': 'Z', '\u017b': 'Z', '\u017d': 'Z', + '\u017a': 'z', '\u017c': 'z', '\u017e': 'z', + '\u0132': 'IJ', '\u0133': 'ij', + '\u0152': 'Oe', '\u0153': 'oe', + '\u0149': "'n", '\u017f': 's' }; - /** Used as the data object for `iteratorTemplate` */ - var iteratorData = { - 'args': '', - 'array': null, - 'bottom': '', - 'firstArg': '', - 'init': '', - 'keys': null, - 'loop': '', - 'shadowedProps': null, - 'support': null, - 'top': '', - 'useHas': false + /** Used to map characters to HTML entities. */ + var htmlEscapes = { + '&': '&', + '<': '<', + '>': '>', + '"': '"', + "'": ''' }; - /** Used to determine if values are of the language type Object */ - var objectTypes = { - 'boolean': false, - 'function': true, - 'object': true, - 'number': false, - 'string': false, - 'undefined': false + /** Used to map HTML entities to characters. */ + var htmlUnescapes = { + '&': '&', + '<': '<', + '>': '>', + '"': '"', + ''': "'" }; - /** Used to escape characters for inclusion in compiled string literals */ + /** Used to escape characters for inclusion in compiled string literals. */ var stringEscapes = { '\\': '\\', "'": "'", '\n': 'n', '\r': 'r', - '\t': 't', '\u2028': 'u2028', '\u2029': 'u2029' }; - /** Used as a reference to the global object */ - var root = (objectTypes[typeof window] && window) || this; + /** Built-in method references without a dependency on `root`. */ + var freeParseFloat = parseFloat, + freeParseInt = parseInt; - /** Detect free variable `exports` */ - var freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports; + /** Detect free variable `global` from Node.js. */ + var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; - /** Detect free variable `module` */ - var freeModule = objectTypes[typeof module] && module && !module.nodeType && module; + /** Detect free variable `self`. */ + var freeSelf = typeof self == 'object' && self && self.Object === Object && self; - /** Detect the popular CommonJS extension `module.exports` */ - var moduleExports = freeModule && freeModule.exports === freeExports && freeExports; + /** Used as a reference to the global object. */ + var root = freeGlobal || freeSelf || Function('return this')(); - /** 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)) { - root = freeGlobal; - } + /** Detect free variable `exports`. */ + var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports; + + /** Detect free variable `module`. */ + var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module; + + /** Detect the popular CommonJS extension `module.exports`. */ + var moduleExports = freeModule && freeModule.exports === freeExports; + + /** Detect free variable `process` from Node.js. */ + var freeProcess = moduleExports && freeGlobal.process; + + /** Used to access faster Node.js helpers. */ + var nodeUtil = (function() { + try { + // Use `util.types` for Node.js 10+. + var types = freeModule && freeModule.require && freeModule.require('util').types; + + if (types) { + return types; + } + + // Legacy `process.binding('util')` for Node.js < 10. + return freeProcess && freeProcess.binding && freeProcess.binding('util'); + } catch (e) {} + }()); + + /* Node.js helper references. */ + var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer, + nodeIsDate = nodeUtil && nodeUtil.isDate, + nodeIsMap = nodeUtil && nodeUtil.isMap, + nodeIsRegExp = nodeUtil && nodeUtil.isRegExp, + nodeIsSet = nodeUtil && nodeUtil.isSet, + nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray; /*--------------------------------------------------------------------------*/ /** - * The base implementation of `_.indexOf` without support for binary searches - * or `fromIndex` constraints. + * A faster alternative to `Function#apply`, this function invokes `func` + * with the `this` binding of `thisArg` and the arguments of `args`. * * @private - * @param {Array} array The array to search. - * @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`. + * @param {Function} func The function to invoke. + * @param {*} thisArg The `this` binding of `func`. + * @param {Array} args The arguments to invoke `func` with. + * @returns {*} Returns the result of `func`. */ - function baseIndexOf(array, value, fromIndex) { - var index = (fromIndex || 0) - 1, - length = array ? array.length : 0; + function apply(func, thisArg, args) { + switch (args.length) { + case 0: return func.call(thisArg); + case 1: return func.call(thisArg, args[0]); + case 2: return func.call(thisArg, args[0], args[1]); + case 3: return func.call(thisArg, args[0], args[1], args[2]); + } + return func.apply(thisArg, args); + } + + /** + * A specialized version of `baseAggregator` for arrays. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} setter The function to set `accumulator` values. + * @param {Function} iteratee The iteratee to transform keys. + * @param {Object} accumulator The initial aggregated object. + * @returns {Function} Returns `accumulator`. + */ + function arrayAggregator(array, setter, iteratee, accumulator) { + var index = -1, + length = array == null ? 0 : array.length; while (++index < length) { - if (array[index] === value) { - return index; - } + var value = array[index]; + setter(accumulator, value, iteratee(value), array); } - return -1; + return accumulator; } /** - * An implementation of `_.contains` for cache objects that mimics the return - * signature of `_.indexOf` by returning `0` if the value is found, else `-1`. + * A specialized version of `_.forEach` for arrays without support for + * iteratee shorthands. * * @private - * @param {Object} cache The cache object to inspect. - * @param {*} value The value to search for. - * @returns {number} Returns `0` if `value` is found, else `-1`. + * @param {Array} [array] The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns `array`. */ - function cacheIndexOf(cache, value) { - var type = typeof value; - cache = cache.cache; + function arrayEach(array, iteratee) { + var index = -1, + length = array == null ? 0 : array.length; - if (type == 'boolean' || value == null) { - return cache[value] ? 0 : -1; - } - if (type != 'number' && type != 'string') { - type = 'object'; + while (++index < length) { + if (iteratee(array[index], index, array) === false) { + break; + } } - var key = type == 'number' ? value : keyPrefix + value; - cache = (cache = cache[type]) && cache[key]; + return array; + } + + /** + * A specialized version of `_.forEachRight` for arrays without support for + * iteratee shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns `array`. + */ + function arrayEachRight(array, iteratee) { + var length = array == null ? 0 : array.length; - return type == 'object' - ? (cache && baseIndexOf(cache, value) > -1 ? 0 : -1) - : (cache ? 0 : -1); + while (length--) { + if (iteratee(array[length], length, array) === false) { + break; + } + } + return array; } /** - * Adds a given value to the corresponding cache object. + * A specialized version of `_.every` for arrays without support for + * iteratee shorthands. * * @private - * @param {*} value The value to add to the cache. + * @param {Array} [array] The array to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {boolean} Returns `true` if all elements pass the predicate check, + * else `false`. */ - function cachePush(value) { - var cache = this.cache, - type = typeof value; + function arrayEvery(array, predicate) { + var index = -1, + length = array == null ? 0 : array.length; - if (type == 'boolean' || value == null) { - cache[value] = true; - } else { - if (type != 'number' && type != 'string') { - type = 'object'; + while (++index < length) { + if (!predicate(array[index], index, array)) { + return false; } - var key = type == 'number' ? value : keyPrefix + value, - typeCache = cache[type] || (cache[type] = {}); + } + return true; + } - if (type == 'object') { - (typeCache[key] || (typeCache[key] = [])).push(value); - } else { - typeCache[key] = true; + /** + * A specialized version of `_.filter` for arrays without support for + * iteratee shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {Array} Returns the new filtered array. + */ + function arrayFilter(array, predicate) { + var index = -1, + length = array == null ? 0 : array.length, + resIndex = 0, + result = []; + + while (++index < length) { + var value = array[index]; + if (predicate(value, index, array)) { + result[resIndex++] = value; } } + return result; } /** - * Used by `_.max` and `_.min` as the default callback when a given - * collection is a string value. + * A specialized version of `_.includes` for arrays without support for + * specifying an index to search from. * * @private - * @param {string} value The character to inspect. - * @returns {number} Returns the code unit of given character. + * @param {Array} [array] The array to inspect. + * @param {*} target The value to search for. + * @returns {boolean} Returns `true` if `target` is found, else `false`. */ - function charAtCallback(value) { - return value.charCodeAt(0); + function arrayIncludes(array, value) { + var length = array == null ? 0 : array.length; + return !!length && baseIndexOf(array, value, 0) > -1; } /** - * Used by `sortBy` to compare transformed `collection` elements, stable sorting - * them in ascending order. + * This function is like `arrayIncludes` except that it accepts a comparator. * * @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`. + * @param {Array} [array] The array to inspect. + * @param {*} target The value to search for. + * @param {Function} comparator The comparator invoked per element. + * @returns {boolean} Returns `true` if `target` is found, else `false`. */ - function compareAscending(a, b) { - var ac = a.criteria, - bc = b.criteria, - index = -1, - length = ac.length; + function arrayIncludesWith(array, value, comparator) { + var index = -1, + length = array == null ? 0 : array.length; while (++index < length) { - var value = ac[index], - other = bc[index]; - - if (value !== other) { - if (value > other || typeof value == 'undefined') { - return 1; - } - if (value < other || typeof other == 'undefined') { - return -1; - } + if (comparator(value, array[index])) { + return true; } } - // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications - // that causes it, under certain circumstances, to return the same value for - // `a` and `b`. See https://github.com/jashkenas/underscore/pull/1247 - // - // This also ensures a stable sort in V8 and other engines. - // See http://code.google.com/p/v8/issues/detail?id=90 - return a.index - b.index; + return false; } /** - * Creates a cache object to optimize linear searches of large arrays. + * A specialized version of `_.map` for arrays without support for iteratee + * shorthands. * * @private - * @param {Array} [array=[]] The array to search. - * @returns {null|Object} Returns the cache object or `null` if caching should not be used. + * @param {Array} [array] The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the new mapped array. */ - function createCache(array) { + function arrayMap(array, iteratee) { var index = -1, - length = array.length, - first = array[0], - mid = array[(length / 2) | 0], - last = array[length - 1]; + length = array == null ? 0 : array.length, + result = Array(length); - if (first && typeof first == 'object' && - mid && typeof mid == 'object' && last && typeof last == 'object') { - return false; + while (++index < length) { + result[index] = iteratee(array[index], index, array); } - var cache = getObject(); - cache['false'] = cache['null'] = cache['true'] = cache['undefined'] = false; + return result; + } - var result = getObject(); - result.array = array; - result.cache = cache; - result.push = cachePush; + /** + * Appends the elements of `values` to `array`. + * + * @private + * @param {Array} array The array to modify. + * @param {Array} values The values to append. + * @returns {Array} Returns `array`. + */ + function arrayPush(array, values) { + var index = -1, + length = values.length, + offset = array.length; while (++index < length) { - result.push(array[index]); + array[offset + index] = values[index]; } - return result; + return array; } /** - * Used by `template` to escape characters for inclusion in compiled - * string literals. + * A specialized version of `_.reduce` for arrays without support for + * iteratee shorthands. * * @private - * @param {string} match The matched character to escape. - * @returns {string} Returns the escaped character. + * @param {Array} [array] The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {*} [accumulator] The initial value. + * @param {boolean} [initAccum] Specify using the first element of `array` as + * the initial value. + * @returns {*} Returns the accumulated value. + */ + function arrayReduce(array, iteratee, accumulator, initAccum) { + var index = -1, + length = array == null ? 0 : array.length; + + if (initAccum && length) { + accumulator = array[++index]; + } + while (++index < length) { + accumulator = iteratee(accumulator, array[index], index, array); + } + return accumulator; + } + + /** + * A specialized version of `_.reduceRight` for arrays without support for + * iteratee shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {*} [accumulator] The initial value. + * @param {boolean} [initAccum] Specify using the last element of `array` as + * the initial value. + * @returns {*} Returns the accumulated value. */ - function escapeStringChar(match) { - return '\\' + stringEscapes[match]; + function arrayReduceRight(array, iteratee, accumulator, initAccum) { + var length = array == null ? 0 : array.length; + if (initAccum && length) { + accumulator = array[--length]; + } + while (length--) { + accumulator = iteratee(accumulator, array[length], length, array); + } + return accumulator; } /** - * Gets an array from the array pool or creates a new one if the pool is empty. + * A specialized version of `_.some` for arrays without support for iteratee + * shorthands. * * @private - * @returns {Array} The array from the pool. + * @param {Array} [array] The array to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {boolean} Returns `true` if any element passes the predicate check, + * else `false`. */ - function getArray() { - return arrayPool.pop() || []; + function arraySome(array, predicate) { + var index = -1, + length = array == null ? 0 : array.length; + + while (++index < length) { + if (predicate(array[index], index, array)) { + return true; + } + } + return false; } /** - * Gets an object from the object pool or creates a new one if the pool is empty. + * Gets the size of an ASCII `string`. * * @private - * @returns {Object} The object from the pool. + * @param {string} string The string inspect. + * @returns {number} Returns the string size. */ - function getObject() { - return objectPool.pop() || { - 'array': null, - 'cache': null, - 'criteria': null, - 'false': false, - 'index': 0, - 'null': false, - 'number': null, - 'object': null, - 'push': null, - 'string': null, - 'true': false, - 'undefined': false, - 'value': null - }; + var asciiSize = baseProperty('length'); + + /** + * Converts an ASCII `string` to an array. + * + * @private + * @param {string} string The string to convert. + * @returns {Array} Returns the converted array. + */ + function asciiToArray(string) { + return string.split(''); } /** - * Checks if `value` is a DOM node in IE < 9. + * Splits an ASCII `string` into an array of its words. * * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is a DOM node, else `false`. + * @param {string} The string to inspect. + * @returns {Array} Returns the words of `string`. */ - function isNode(value) { - // IE < 9 presents DOM nodes as `Object` objects except they have `toString` - // methods that are `typeof` "string" and still can coerce nodes to strings - return typeof value.toString != 'function' && typeof (value + '') == 'string'; + function asciiWords(string) { + return string.match(reAsciiWord) || []; } /** - * Releases the given array back to the array pool. + * The base implementation of methods like `_.findKey` and `_.findLastKey`, + * without support for iteratee shorthands, which iterates over `collection` + * using `eachFunc`. * * @private - * @param {Array} [array] The array to release. + * @param {Array|Object} collection The collection to inspect. + * @param {Function} predicate The function invoked per iteration. + * @param {Function} eachFunc The function to iterate over `collection`. + * @returns {*} Returns the found element or its key, else `undefined`. */ - function releaseArray(array) { - array.length = 0; - if (arrayPool.length < maxPoolSize) { - arrayPool.push(array); - } + function baseFindKey(collection, predicate, eachFunc) { + var result; + eachFunc(collection, function(value, key, collection) { + if (predicate(value, key, collection)) { + result = key; + return false; + } + }); + return result; } /** - * Releases the given object back to the object pool. + * The base implementation of `_.findIndex` and `_.findLastIndex` without + * support for iteratee shorthands. * * @private - * @param {Object} [object] The object to release. + * @param {Array} array The array to inspect. + * @param {Function} predicate The function invoked per iteration. + * @param {number} fromIndex The index to search from. + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {number} Returns the index of the matched value, else `-1`. */ - function releaseObject(object) { - var cache = object.cache; - if (cache) { - releaseObject(cache); - } - object.array = object.cache = object.criteria = object.object = object.number = object.string = object.value = null; - if (objectPool.length < maxPoolSize) { - objectPool.push(object); + function baseFindIndex(array, predicate, fromIndex, fromRight) { + var length = array.length, + index = fromIndex + (fromRight ? 1 : -1); + + while ((fromRight ? index-- : ++index < length)) { + if (predicate(array[index], index, array)) { + return index; + } } + return -1; } /** - * Slices the `collection` from the `start` index up to, but not including, - * the `end` index. + * The base implementation of `_.indexOf` without `fromIndex` bounds checks. * - * 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} array The array to inspect. + * @param {*} value The value to search for. + * @param {number} fromIndex The index to search from. + * @returns {number} Returns the index of the matched value, else `-1`. + */ + function baseIndexOf(array, value, fromIndex) { + return value === value + ? strictIndexOf(array, value, fromIndex) + : baseFindIndex(array, baseIsNaN, fromIndex); + } + + /** + * This function is like `baseIndexOf` except that it accepts a comparator. * * @private - * @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. + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @param {number} fromIndex The index to search from. + * @param {Function} comparator The comparator invoked per element. + * @returns {number} Returns the index of the matched value, else `-1`. */ - function slice(array, start, end) { - start || (start = 0); - if (typeof end == 'undefined') { - end = array ? array.length : 0; - } - var index = -1, - length = end - start || 0, - result = Array(length < 0 ? 0 : length); + function baseIndexOfWith(array, value, fromIndex, comparator) { + var index = fromIndex - 1, + length = array.length; while (++index < length) { - result[index] = array[start + index]; + if (comparator(array[index], value)) { + return index; + } } - return result; + return -1; } - /*--------------------------------------------------------------------------*/ - /** - * Create a new `lodash` function using the given context object. + * The base implementation of `_.isNaN` without support for number objects. * - * @static - * @memberOf _ - * @category Utilities - * @param {Object} [context=root] The context object. - * @returns {Function} Returns the `lodash` function. + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`. */ - 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.io/#x11.1.5. - context = context ? _.defaults(root.Object(), context, _.pick(root, contextProps)) : root; - - /** Native constructor references */ - var Array = context.Array, - Boolean = context.Boolean, - Date = context.Date, - Error = context.Error, - Function = context.Function, - Math = context.Math, - Number = context.Number, - Object = context.Object, - RegExp = context.RegExp, - String = context.String, - TypeError = context.TypeError; + function baseIsNaN(value) { + return value !== value; + } - /** - * Used for `Array` method references. - * - * Normally `Array.prototype` would suffice, however, using an array literal - * avoids issues in Narwhal. - */ - var arrayRef = []; + /** + * The base implementation of `_.mean` and `_.meanBy` without support for + * iteratee shorthands. + * + * @private + * @param {Array} array The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {number} Returns the mean. + */ + function baseMean(array, iteratee) { + var length = array == null ? 0 : array.length; + return length ? (baseSum(array, iteratee) / length) : NAN; + } - /** Used for native method references */ - var errorProto = Error.prototype, - objectProto = Object.prototype, - stringProto = String.prototype; + /** + * The base implementation of `_.property` without support for deep paths. + * + * @private + * @param {string} key The key of the property to get. + * @returns {Function} Returns the new accessor function. + */ + function baseProperty(key) { + return function(object) { + return object == null ? undefined : object[key]; + }; + } - /** Used to restore the original `_` reference in `noConflict` */ - var oldDash = context._; + /** + * The base implementation of `_.propertyOf` without support for deep paths. + * + * @private + * @param {Object} object The object to query. + * @returns {Function} Returns the new accessor function. + */ + function basePropertyOf(object) { + return function(key) { + return object == null ? undefined : object[key]; + }; + } - /** Used to resolve the internal [[Class]] of values */ - var toString = objectProto.toString; + /** + * The base implementation of `_.reduce` and `_.reduceRight`, without support + * for iteratee shorthands, which iterates over `collection` using `eachFunc`. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {*} accumulator The initial value. + * @param {boolean} initAccum Specify using the first or last element of + * `collection` as the initial value. + * @param {Function} eachFunc The function to iterate over `collection`. + * @returns {*} Returns the accumulated value. + */ + function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) { + eachFunc(collection, function(value, index, collection) { + accumulator = initAccum + ? (initAccum = false, value) + : iteratee(accumulator, value, index, collection); + }); + return accumulator; + } - /** Used to detect if a method is native */ - var reNative = RegExp('^' + - String(toString) - .replace(/[.*+?^${}()|[\]\\]/g, '\\$&') - .replace(/toString| for [^\]]+/g, '.*?') + '$' - ); + /** + * The base implementation of `_.sortBy` which uses `comparer` to define the + * sort order of `array` and replaces criteria objects with their corresponding + * values. + * + * @private + * @param {Array} array The array to sort. + * @param {Function} comparer The function to define sort order. + * @returns {Array} Returns `array`. + */ + function baseSortBy(array, comparer) { + var length = array.length; - /** Native method shortcuts */ - var ceil = Math.ceil, - clearTimeout = context.clearTimeout, - floor = Math.floor, - fnToString = Function.prototype.toString, - getPrototypeOf = isNative(getPrototypeOf = Object.getPrototypeOf) && getPrototypeOf, - hasOwnProperty = objectProto.hasOwnProperty, - push = arrayRef.push, - propertyIsEnumerable = objectProto.propertyIsEnumerable, - setTimeout = context.setTimeout, - splice = arrayRef.splice, - unshift = arrayRef.unshift; + array.sort(comparer); + while (length--) { + array[length] = array[length].value; + } + return array; + } - /** Used to set meta data on functions */ - var defineProperty = (function() { - // IE 8 only accepts DOM elements - try { - var o = {}, - func = isNative(func = Object.defineProperty) && func, - result = func(o, o, o) && func; - } catch(e) { } - return result; - }()); + /** + * The base implementation of `_.sum` and `_.sumBy` without support for + * iteratee shorthands. + * + * @private + * @param {Array} array The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {number} Returns the sum. + */ + function baseSum(array, iteratee) { + var result, + index = -1, + length = array.length; - /* Native method shortcuts for methods with the same name as other `lodash` methods */ - var nativeCreate = isNative(nativeCreate = Object.create) && nativeCreate, - nativeIsArray = isNative(nativeIsArray = Array.isArray) && nativeIsArray, - nativeIsFinite = context.isFinite, - nativeIsNaN = context.isNaN, - nativeKeys = isNative(nativeKeys = Object.keys) && nativeKeys, - nativeMax = Math.max, - nativeMin = Math.min, - nativeParseInt = context.parseInt, - nativeRandom = Math.random; - - /** Used to lookup a built-in constructor by [[Class]] */ - var ctorByClass = {}; - ctorByClass[arrayClass] = Array; - ctorByClass[boolClass] = Boolean; - ctorByClass[dateClass] = Date; - ctorByClass[funcClass] = Function; - ctorByClass[objectClass] = Object; - ctorByClass[numberClass] = Number; - ctorByClass[regexpClass] = RegExp; - ctorByClass[stringClass] = String; - - /** Used to avoid iterating non-enumerable properties in IE < 9 */ - var nonEnumProps = {}; - nonEnumProps[arrayClass] = nonEnumProps[dateClass] = nonEnumProps[numberClass] = { 'constructor': true, 'toLocaleString': true, 'toString': true, 'valueOf': true }; - nonEnumProps[boolClass] = nonEnumProps[stringClass] = { 'constructor': true, 'toString': true, 'valueOf': true }; - nonEnumProps[errorClass] = nonEnumProps[funcClass] = nonEnumProps[regexpClass] = { 'constructor': true, 'toString': true }; - nonEnumProps[objectClass] = { 'constructor': true }; - - (function() { - var length = shadowedProps.length; - while (length--) { - var key = shadowedProps[length]; - for (var className in nonEnumProps) { - if (hasOwnProperty.call(nonEnumProps, className) && !hasOwnProperty.call(nonEnumProps[className], key)) { - nonEnumProps[className][key] = false; - } - } + while (++index < length) { + var current = iteratee(array[index]); + if (current !== undefined) { + result = result === undefined ? current : (result + current); } - }()); + } + return result; + } - /*--------------------------------------------------------------------------*/ + /** + * The base implementation of `_.times` without support for iteratee shorthands + * or max array length checks. + * + * @private + * @param {number} n The number of times to invoke `iteratee`. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the array of results. + */ + function baseTimes(n, iteratee) { + var index = -1, + result = Array(n); - /** - * Creates a `lodash` object which wraps the given value to enable intuitive - * method chaining. - * - * In addition to Lo-Dash methods, wrappers also have the following `Array` methods: - * `concat`, `join`, `pop`, `push`, `reverse`, `shift`, `slice`, `sort`, `splice`, - * and `unshift` - * - * Chaining is supported in custom builds as long as the `value` method is - * implicitly or explicitly included in the build. - * - * The chainable wrapper functions are: - * `after`, `assign`, `bind`, `bindAll`, `bindKey`, `chain`, `compact`, - * `compose`, `concat`, `countBy`, `create`, `createCallback`, `curry`, - * `debounce`, `defaults`, `defer`, `delay`, `difference`, `filter`, `flatten`, - * `forEach`, `forEachRight`, `forIn`, `forInRight`, `forOwn`, `forOwnRight`, - * `functions`, `groupBy`, `indexBy`, `initial`, `intersection`, `invert`, - * `invoke`, `keys`, `map`, `max`, `memoize`, `merge`, `min`, `object`, `omit`, - * `once`, `pairs`, `partial`, `partialRight`, `pick`, `pluck`, `pull`, `push`, - * `range`, `reject`, `remove`, `rest`, `reverse`, `shuffle`, `slice`, `sort`, - * `sortBy`, `splice`, `tap`, `throttle`, `times`, `toArray`, `transform`, - * `union`, `uniq`, `unshift`, `unzip`, `values`, `where`, `without`, `wrap`, - * and `zip` - * - * The non-chainable wrapper functions are: - * `clone`, `cloneDeep`, `contains`, `escape`, `every`, `find`, `findIndex`, - * `findKey`, `findLast`, `findLastIndex`, `findLastKey`, `has`, `identity`, - * `indexOf`, `isArguments`, `isArray`, `isBoolean`, `isDate`, `isElement`, - * `isEmpty`, `isEqual`, `isFinite`, `isFunction`, `isNaN`, `isNull`, `isNumber`, - * `isObject`, `isPlainObject`, `isRegExp`, `isString`, `isUndefined`, `join`, - * `lastIndexOf`, `mixin`, `noConflict`, `parseInt`, `pop`, `random`, `reduce`, - * `reduceRight`, `result`, `shift`, `size`, `some`, `sortedIndex`, `runInContext`, - * `template`, `unescape`, `uniqueId`, and `value` - * - * The wrapper functions `first` and `last` return wrapped values when `n` is - * provided, otherwise they return unwrapped values. - * - * Explicit chaining can be enabled by using the `_.chain` method. - * - * @name _ - * @constructor - * @category Chaining - * @param {*} value The value to wrap in a `lodash` instance. - * @returns {Object} Returns a `lodash` instance. - * @example - * - * var wrapped = _([1, 2, 3]); - * - * // returns an unwrapped value - * wrapped.reduce(function(sum, num) { - * return sum + num; - * }); - * // => 6 - * - * // returns a wrapped value - * var squares = wrapped.map(function(num) { - * return num * num; - * }); - * - * _.isArray(squares); - * // => false - * - * _.isArray(squares.value()); - * // => true - */ - function lodash(value) { - // don't wrap if already wrapped, even if wrapped by a different `lodash` constructor - return (value && typeof value == 'object' && !isArray(value) && hasOwnProperty.call(value, '__wrapped__')) - ? value - : new lodashWrapper(value); + while (++index < n) { + result[index] = iteratee(index); } + return result; + } - /** - * A fast path for creating `lodash` wrapper objects. - * - * @private - * @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, chainAll) { - this.__chain__ = !!chainAll; + /** + * The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array + * of key-value pairs for `object` corresponding to the property names of `props`. + * + * @private + * @param {Object} object The object to query. + * @param {Array} props The property names to get values for. + * @returns {Object} Returns the key-value pairs. + */ + function baseToPairs(object, props) { + return arrayMap(props, function(key) { + return [key, object[key]]; + }); + } + + /** + * The base implementation of `_.trim`. + * + * @private + * @param {string} string The string to trim. + * @returns {string} Returns the trimmed string. + */ + function baseTrim(string) { + return string + ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '') + : string; + } + + /** + * The base implementation of `_.unary` without support for storing metadata. + * + * @private + * @param {Function} func The function to cap arguments for. + * @returns {Function} Returns the new capped function. + */ + function baseUnary(func) { + return function(value) { + return func(value); + }; + } + + /** + * The base implementation of `_.values` and `_.valuesIn` which creates an + * array of `object` property values corresponding to the property names + * of `props`. + * + * @private + * @param {Object} object The object to query. + * @param {Array} props The property names to get values for. + * @returns {Object} Returns the array of property values. + */ + function baseValues(object, props) { + return arrayMap(props, function(key) { + return object[key]; + }); + } + + /** + * Checks if a `cache` value for `key` exists. + * + * @private + * @param {Object} cache The cache to query. + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ + function cacheHas(cache, key) { + return cache.has(key); + } + + /** + * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol + * that is not found in the character symbols. + * + * @private + * @param {Array} strSymbols The string symbols to inspect. + * @param {Array} chrSymbols The character symbols to find. + * @returns {number} Returns the index of the first unmatched string symbol. + */ + function charsStartIndex(strSymbols, chrSymbols) { + var index = -1, + length = strSymbols.length; + + while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {} + return index; + } + + /** + * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol + * that is not found in the character symbols. + * + * @private + * @param {Array} strSymbols The string symbols to inspect. + * @param {Array} chrSymbols The character symbols to find. + * @returns {number} Returns the index of the last unmatched string symbol. + */ + function charsEndIndex(strSymbols, chrSymbols) { + var index = strSymbols.length; + + while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {} + return index; + } + + /** + * Gets the number of `placeholder` occurrences in `array`. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} placeholder The placeholder to search for. + * @returns {number} Returns the placeholder count. + */ + function countHolders(array, placeholder) { + var length = array.length, + result = 0; + + while (length--) { + if (array[length] === placeholder) { + ++result; + } + } + return result; + } + + /** + * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A + * letters to basic Latin letters. + * + * @private + * @param {string} letter The matched letter to deburr. + * @returns {string} Returns the deburred letter. + */ + var deburrLetter = basePropertyOf(deburredLetters); + + /** + * Used by `_.escape` to convert characters to HTML entities. + * + * @private + * @param {string} chr The matched character to escape. + * @returns {string} Returns the escaped character. + */ + var escapeHtmlChar = basePropertyOf(htmlEscapes); + + /** + * Used by `_.template` to escape characters for inclusion in compiled string literals. + * + * @private + * @param {string} chr The matched character to escape. + * @returns {string} Returns the escaped character. + */ + function escapeStringChar(chr) { + return '\\' + stringEscapes[chr]; + } + + /** + * Gets the value at `key` of `object`. + * + * @private + * @param {Object} [object] The object to query. + * @param {string} key The key of the property to get. + * @returns {*} Returns the property value. + */ + function getValue(object, key) { + return object == null ? undefined : object[key]; + } + + /** + * Checks if `string` contains Unicode symbols. + * + * @private + * @param {string} string The string to inspect. + * @returns {boolean} Returns `true` if a symbol is found, else `false`. + */ + function hasUnicode(string) { + return reHasUnicode.test(string); + } + + /** + * Checks if `string` contains a word composed of Unicode symbols. + * + * @private + * @param {string} string The string to inspect. + * @returns {boolean} Returns `true` if a word is found, else `false`. + */ + function hasUnicodeWord(string) { + return reHasUnicodeWord.test(string); + } + + /** + * Converts `iterator` to an array. + * + * @private + * @param {Object} iterator The iterator to convert. + * @returns {Array} Returns the converted array. + */ + function iteratorToArray(iterator) { + var data, + result = []; + + while (!(data = iterator.next()).done) { + result.push(data.value); + } + return result; + } + + /** + * Converts `map` to its key-value pairs. + * + * @private + * @param {Object} map The map to convert. + * @returns {Array} Returns the key-value pairs. + */ + function mapToArray(map) { + var index = -1, + result = Array(map.size); + + map.forEach(function(value, key) { + result[++index] = [key, value]; + }); + return result; + } + + /** + * Creates a unary function that invokes `func` with its argument transformed. + * + * @private + * @param {Function} func The function to wrap. + * @param {Function} transform The argument transform. + * @returns {Function} Returns the new function. + */ + function overArg(func, transform) { + return function(arg) { + return func(transform(arg)); + }; + } + + /** + * Replaces all `placeholder` elements in `array` with an internal placeholder + * and returns an array of their indexes. + * + * @private + * @param {Array} array The array to modify. + * @param {*} placeholder The placeholder to replace. + * @returns {Array} Returns the new array of placeholder indexes. + */ + function replaceHolders(array, placeholder) { + var index = -1, + length = array.length, + resIndex = 0, + result = []; + + while (++index < length) { + var value = array[index]; + if (value === placeholder || value === PLACEHOLDER) { + array[index] = PLACEHOLDER; + result[resIndex++] = index; + } + } + return result; + } + + /** + * Converts `set` to an array of its values. + * + * @private + * @param {Object} set The set to convert. + * @returns {Array} Returns the values. + */ + function setToArray(set) { + var index = -1, + result = Array(set.size); + + set.forEach(function(value) { + result[++index] = value; + }); + return result; + } + + /** + * Converts `set` to its value-value pairs. + * + * @private + * @param {Object} set The set to convert. + * @returns {Array} Returns the value-value pairs. + */ + function setToPairs(set) { + var index = -1, + result = Array(set.size); + + set.forEach(function(value) { + result[++index] = [value, value]; + }); + return result; + } + + /** + * A specialized version of `_.indexOf` which performs strict equality + * comparisons of values, i.e. `===`. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @param {number} fromIndex The index to search from. + * @returns {number} Returns the index of the matched value, else `-1`. + */ + function strictIndexOf(array, value, fromIndex) { + var index = fromIndex - 1, + length = array.length; + + while (++index < length) { + if (array[index] === value) { + return index; + } + } + return -1; + } + + /** + * A specialized version of `_.lastIndexOf` which performs strict equality + * comparisons of values, i.e. `===`. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @param {number} fromIndex The index to search from. + * @returns {number} Returns the index of the matched value, else `-1`. + */ + function strictLastIndexOf(array, value, fromIndex) { + var index = fromIndex + 1; + while (index--) { + if (array[index] === value) { + return index; + } + } + return index; + } + + /** + * Gets the number of symbols in `string`. + * + * @private + * @param {string} string The string to inspect. + * @returns {number} Returns the string size. + */ + function stringSize(string) { + return hasUnicode(string) + ? unicodeSize(string) + : asciiSize(string); + } + + /** + * Converts `string` to an array. + * + * @private + * @param {string} string The string to convert. + * @returns {Array} Returns the converted array. + */ + function stringToArray(string) { + return hasUnicode(string) + ? unicodeToArray(string) + : asciiToArray(string); + } + + /** + * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace + * character of `string`. + * + * @private + * @param {string} string The string to inspect. + * @returns {number} Returns the index of the last non-whitespace character. + */ + function trimmedEndIndex(string) { + var index = string.length; + + while (index-- && reWhitespace.test(string.charAt(index))) {} + return index; + } + + /** + * Used by `_.unescape` to convert HTML entities to characters. + * + * @private + * @param {string} chr The matched character to unescape. + * @returns {string} Returns the unescaped character. + */ + var unescapeHtmlChar = basePropertyOf(htmlUnescapes); + + /** + * Gets the size of a Unicode `string`. + * + * @private + * @param {string} string The string inspect. + * @returns {number} Returns the string size. + */ + function unicodeSize(string) { + var result = reUnicode.lastIndex = 0; + while (reUnicode.test(string)) { + ++result; + } + return result; + } + + /** + * Converts a Unicode `string` to an array. + * + * @private + * @param {string} string The string to convert. + * @returns {Array} Returns the converted array. + */ + function unicodeToArray(string) { + return string.match(reUnicode) || []; + } + + /** + * Splits a Unicode `string` into an array of its words. + * + * @private + * @param {string} The string to inspect. + * @returns {Array} Returns the words of `string`. + */ + function unicodeWords(string) { + return string.match(reUnicodeWord) || []; + } + + /*--------------------------------------------------------------------------*/ + + /** + * Create a new pristine `lodash` function using the `context` object. + * + * @static + * @memberOf _ + * @since 1.1.0 + * @category Util + * @param {Object} [context=root] The context object. + * @returns {Function} Returns a new `lodash` function. + * @example + * + * _.mixin({ 'foo': _.constant('foo') }); + * + * var lodash = _.runInContext(); + * lodash.mixin({ 'bar': lodash.constant('bar') }); + * + * _.isFunction(_.foo); + * // => true + * _.isFunction(_.bar); + * // => false + * + * lodash.isFunction(lodash.foo); + * // => false + * lodash.isFunction(lodash.bar); + * // => true + * + * // Create a suped-up `defer` in Node.js. + * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer; + */ + var runInContext = (function runInContext(context) { + context = context == null ? root : _.defaults(root.Object(), context, _.pick(root, contextProps)); + + /** Built-in constructor references. */ + var Array = context.Array, + Date = context.Date, + Error = context.Error, + Function = context.Function, + Math = context.Math, + Object = context.Object, + RegExp = context.RegExp, + String = context.String, + TypeError = context.TypeError; + + /** Used for built-in method references. */ + var arrayProto = Array.prototype, + funcProto = Function.prototype, + objectProto = Object.prototype; + + /** Used to detect overreaching core-js shims. */ + var coreJsData = context['__core-js_shared__']; + + /** Used to resolve the decompiled source of functions. */ + var funcToString = funcProto.toString; + + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; + + /** Used to generate unique IDs. */ + var idCounter = 0; + + /** Used to detect methods masquerading as native. */ + var maskSrcKey = (function() { + var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || ''); + return uid ? ('Symbol(src)_1.' + uid) : ''; + }()); + + /** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ + var nativeObjectToString = objectProto.toString; + + /** Used to infer the `Object` constructor. */ + var objectCtorString = funcToString.call(Object); + + /** Used to restore the original `_` reference in `_.noConflict`. */ + var oldDash = root._; + + /** Used to detect if a method is native. */ + var reIsNative = RegExp('^' + + funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&') + .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' + ); + + /** Built-in value references. */ + var Buffer = moduleExports ? context.Buffer : undefined, + Symbol = context.Symbol, + Uint8Array = context.Uint8Array, + allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined, + getPrototype = overArg(Object.getPrototypeOf, Object), + objectCreate = Object.create, + propertyIsEnumerable = objectProto.propertyIsEnumerable, + splice = arrayProto.splice, + spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined, + symIterator = Symbol ? Symbol.iterator : undefined, + symToStringTag = Symbol ? Symbol.toStringTag : undefined; + + var defineProperty = (function() { + try { + var func = getNative(Object, 'defineProperty'); + func({}, '', {}); + return func; + } catch (e) {} + }()); + + /** Mocked built-ins. */ + var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout, + ctxNow = Date && Date.now !== root.Date.now && Date.now, + ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout; + + /* Built-in method references for those with the same name as other `lodash` methods. */ + var nativeCeil = Math.ceil, + nativeFloor = Math.floor, + nativeGetSymbols = Object.getOwnPropertySymbols, + nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined, + nativeIsFinite = context.isFinite, + nativeJoin = arrayProto.join, + nativeKeys = overArg(Object.keys, Object), + nativeMax = Math.max, + nativeMin = Math.min, + nativeNow = Date.now, + nativeParseInt = context.parseInt, + nativeRandom = Math.random, + nativeReverse = arrayProto.reverse; + + /* Built-in method references that are verified to be native. */ + var DataView = getNative(context, 'DataView'), + Map = getNative(context, 'Map'), + Promise = getNative(context, 'Promise'), + Set = getNative(context, 'Set'), + WeakMap = getNative(context, 'WeakMap'), + nativeCreate = getNative(Object, 'create'); + + /** Used to store function metadata. */ + var metaMap = WeakMap && new WeakMap; + + /** Used to lookup unminified function names. */ + var realNames = {}; + + /** Used to detect maps, sets, and weakmaps. */ + var dataViewCtorString = toSource(DataView), + mapCtorString = toSource(Map), + promiseCtorString = toSource(Promise), + setCtorString = toSource(Set), + weakMapCtorString = toSource(WeakMap); + + /** Used to convert symbols to primitives and strings. */ + var symbolProto = Symbol ? Symbol.prototype : undefined, + symbolValueOf = symbolProto ? symbolProto.valueOf : undefined, + symbolToString = symbolProto ? symbolProto.toString : undefined; + + /*------------------------------------------------------------------------*/ + + /** + * Creates a `lodash` object which wraps `value` to enable implicit method + * chain sequences. Methods that operate on and return arrays, collections, + * and functions can be chained together. Methods that retrieve a single value + * or may return a primitive value will automatically end the chain sequence + * and return the unwrapped value. Otherwise, the value must be unwrapped + * with `_#value`. + * + * Explicit chain sequences, which must be unwrapped with `_#value`, may be + * enabled using `_.chain`. + * + * The execution of chained methods is lazy, that is, it's deferred until + * `_#value` is implicitly or explicitly called. + * + * Lazy evaluation allows several methods to support shortcut fusion. + * Shortcut fusion is an optimization to merge iteratee calls; this avoids + * the creation of intermediate arrays and can greatly reduce the number of + * iteratee executions. Sections of a chain sequence qualify for shortcut + * fusion if the section is applied to an array and iteratees accept only + * one argument. The heuristic for whether a section qualifies for shortcut + * fusion is subject to change. + * + * Chaining is supported in custom builds as long as the `_#value` method is + * directly or indirectly included in the build. + * + * In addition to lodash methods, wrappers have `Array` and `String` methods. + * + * The wrapper `Array` methods are: + * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift` + * + * The wrapper `String` methods are: + * `replace` and `split` + * + * The wrapper methods that support shortcut fusion are: + * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`, + * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`, + * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray` + * + * The chainable wrapper methods are: + * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`, + * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`, + * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`, + * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`, + * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`, + * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`, + * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`, + * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`, + * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`, + * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`, + * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`, + * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`, + * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`, + * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`, + * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`, + * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`, + * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`, + * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`, + * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`, + * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`, + * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`, + * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`, + * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`, + * `zipObject`, `zipObjectDeep`, and `zipWith` + * + * The wrapper methods that are **not** chainable by default are: + * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`, + * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`, + * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`, + * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`, + * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`, + * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`, + * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`, + * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`, + * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`, + * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`, + * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`, + * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`, + * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`, + * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`, + * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`, + * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`, + * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`, + * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`, + * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`, + * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`, + * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`, + * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`, + * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`, + * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`, + * `upperFirst`, `value`, and `words` + * + * @name _ + * @constructor + * @category Seq + * @param {*} value The value to wrap in a `lodash` instance. + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * function square(n) { + * return n * n; + * } + * + * var wrapped = _([1, 2, 3]); + * + * // Returns an unwrapped value. + * wrapped.reduce(_.add); + * // => 6 + * + * // Returns a wrapped value. + * var squares = wrapped.map(square); + * + * _.isArray(squares); + * // => false + * + * _.isArray(squares.value()); + * // => true + */ + function lodash(value) { + if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) { + if (value instanceof LodashWrapper) { + return value; + } + if (hasOwnProperty.call(value, '__wrapped__')) { + return wrapperClone(value); + } + } + return new LodashWrapper(value); + } + + /** + * The base implementation of `_.create` without support for assigning + * properties to the created object. + * + * @private + * @param {Object} proto The object to inherit from. + * @returns {Object} Returns the new object. + */ + var baseCreate = (function() { + function object() {} + return function(proto) { + if (!isObject(proto)) { + return {}; + } + if (objectCreate) { + return objectCreate(proto); + } + object.prototype = proto; + var result = new object; + object.prototype = undefined; + return result; + }; + }()); + + /** + * The function whose prototype chain sequence wrappers inherit from. + * + * @private + */ + function baseLodash() { + // No operation performed. + } + + /** + * The base constructor for creating `lodash` wrapper objects. + * + * @private + * @param {*} value The value to wrap. + * @param {boolean} [chainAll] Enable explicit method chain sequences. + */ + function LodashWrapper(value, chainAll) { + this.__wrapped__ = value; + this.__actions__ = []; + this.__chain__ = !!chainAll; + this.__index__ = 0; + this.__values__ = undefined; + } + + /** + * By default, the template delimiters used by lodash are like those in + * embedded Ruby (ERB) as well as ES2015 template strings. Change the + * following template settings to use alternative delimiters. + * + * @static + * @memberOf _ + * @type {Object} + */ + lodash.templateSettings = { + + /** + * Used to detect `data` property values to be HTML-escaped. + * + * @memberOf _.templateSettings + * @type {RegExp} + */ + 'escape': reEscape, + + /** + * Used to detect code to be evaluated. + * + * @memberOf _.templateSettings + * @type {RegExp} + */ + 'evaluate': reEvaluate, + + /** + * Used to detect `data` property values to inject. + * + * @memberOf _.templateSettings + * @type {RegExp} + */ + 'interpolate': reInterpolate, + + /** + * Used to reference the data object in the template text. + * + * @memberOf _.templateSettings + * @type {string} + */ + 'variable': '', + + /** + * Used to import variables into the compiled template. + * + * @memberOf _.templateSettings + * @type {Object} + */ + 'imports': { + + /** + * A reference to the `lodash` function. + * + * @memberOf _.templateSettings.imports + * @type {Function} + */ + '_': lodash + } + }; + + // Ensure wrappers are instances of `baseLodash`. + lodash.prototype = baseLodash.prototype; + lodash.prototype.constructor = lodash; + + LodashWrapper.prototype = baseCreate(baseLodash.prototype); + LodashWrapper.prototype.constructor = LodashWrapper; + + /*------------------------------------------------------------------------*/ + + /** + * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation. + * + * @private + * @constructor + * @param {*} value The value to wrap. + */ + function LazyWrapper(value) { this.__wrapped__ = value; + this.__actions__ = []; + this.__dir__ = 1; + this.__filtered__ = false; + this.__iteratees__ = []; + this.__takeCount__ = MAX_ARRAY_LENGTH; + this.__views__ = []; + } + + /** + * Creates a clone of the lazy wrapper object. + * + * @private + * @name clone + * @memberOf LazyWrapper + * @returns {Object} Returns the cloned `LazyWrapper` object. + */ + function lazyClone() { + var result = new LazyWrapper(this.__wrapped__); + result.__actions__ = copyArray(this.__actions__); + result.__dir__ = this.__dir__; + result.__filtered__ = this.__filtered__; + result.__iteratees__ = copyArray(this.__iteratees__); + result.__takeCount__ = this.__takeCount__; + result.__views__ = copyArray(this.__views__); + return result; + } + + /** + * Reverses the direction of lazy iteration. + * + * @private + * @name reverse + * @memberOf LazyWrapper + * @returns {Object} Returns the new reversed `LazyWrapper` object. + */ + function lazyReverse() { + if (this.__filtered__) { + var result = new LazyWrapper(this); + result.__dir__ = -1; + result.__filtered__ = true; + } else { + result = this.clone(); + result.__dir__ *= -1; + } + return result; + } + + /** + * Extracts the unwrapped value from its lazy wrapper. + * + * @private + * @name value + * @memberOf LazyWrapper + * @returns {*} Returns the unwrapped value. + */ + function lazyValue() { + var array = this.__wrapped__.value(), + dir = this.__dir__, + isArr = isArray(array), + isRight = dir < 0, + arrLength = isArr ? array.length : 0, + view = getView(0, arrLength, this.__views__), + start = view.start, + end = view.end, + length = end - start, + index = isRight ? end : (start - 1), + iteratees = this.__iteratees__, + iterLength = iteratees.length, + resIndex = 0, + takeCount = nativeMin(length, this.__takeCount__); + + if (!isArr || (!isRight && arrLength == length && takeCount == length)) { + return baseWrapperValue(array, this.__actions__); + } + var result = []; + + outer: + while (length-- && resIndex < takeCount) { + index += dir; + + var iterIndex = -1, + value = array[index]; + + while (++iterIndex < iterLength) { + var data = iteratees[iterIndex], + iteratee = data.iteratee, + type = data.type, + computed = iteratee(value); + + if (type == LAZY_MAP_FLAG) { + value = computed; + } else if (!computed) { + if (type == LAZY_FILTER_FLAG) { + continue outer; + } else { + break outer; + } + } + } + result[resIndex++] = value; + } + return result; + } + + // Ensure `LazyWrapper` is an instance of `baseLodash`. + LazyWrapper.prototype = baseCreate(baseLodash.prototype); + LazyWrapper.prototype.constructor = LazyWrapper; + + /*------------------------------------------------------------------------*/ + + /** + * Creates a hash object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ + function Hash(entries) { + var index = -1, + length = entries == null ? 0 : entries.length; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } + } + + /** + * Removes all key-value entries from the hash. + * + * @private + * @name clear + * @memberOf Hash + */ + function hashClear() { + this.__data__ = nativeCreate ? nativeCreate(null) : {}; + this.size = 0; + } + + /** + * Removes `key` and its value from the hash. + * + * @private + * @name delete + * @memberOf Hash + * @param {Object} hash The hash to modify. + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ + function hashDelete(key) { + var result = this.has(key) && delete this.__data__[key]; + this.size -= result ? 1 : 0; + return result; + } + + /** + * Gets the hash value for `key`. + * + * @private + * @name get + * @memberOf Hash + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ + function hashGet(key) { + var data = this.__data__; + if (nativeCreate) { + var result = data[key]; + return result === HASH_UNDEFINED ? undefined : result; + } + return hasOwnProperty.call(data, key) ? data[key] : undefined; + } + + /** + * Checks if a hash value for `key` exists. + * + * @private + * @name has + * @memberOf Hash + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ + function hashHas(key) { + var data = this.__data__; + return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key); + } + + /** + * Sets the hash `key` to `value`. + * + * @private + * @name set + * @memberOf Hash + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the hash instance. + */ + function hashSet(key, value) { + var data = this.__data__; + this.size += this.has(key) ? 0 : 1; + data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value; + return this; + } + + // Add methods to `Hash`. + Hash.prototype.clear = hashClear; + Hash.prototype['delete'] = hashDelete; + Hash.prototype.get = hashGet; + Hash.prototype.has = hashHas; + Hash.prototype.set = hashSet; + + /*------------------------------------------------------------------------*/ + + /** + * Creates an list cache object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ + function ListCache(entries) { + var index = -1, + length = entries == null ? 0 : entries.length; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } + } + + /** + * Removes all key-value entries from the list cache. + * + * @private + * @name clear + * @memberOf ListCache + */ + function listCacheClear() { + this.__data__ = []; + this.size = 0; + } + + /** + * Removes `key` and its value from the list cache. + * + * @private + * @name delete + * @memberOf ListCache + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ + function listCacheDelete(key) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + return false; + } + var lastIndex = data.length - 1; + if (index == lastIndex) { + data.pop(); + } else { + splice.call(data, index, 1); + } + --this.size; + return true; + } + + /** + * Gets the list cache value for `key`. + * + * @private + * @name get + * @memberOf ListCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ + function listCacheGet(key) { + var data = this.__data__, + index = assocIndexOf(data, key); + + return index < 0 ? undefined : data[index][1]; + } + + /** + * Checks if a list cache value for `key` exists. + * + * @private + * @name has + * @memberOf ListCache + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ + function listCacheHas(key) { + return assocIndexOf(this.__data__, key) > -1; + } + + /** + * Sets the list cache `key` to `value`. + * + * @private + * @name set + * @memberOf ListCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the list cache instance. + */ + function listCacheSet(key, value) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + ++this.size; + data.push([key, value]); + } else { + data[index][1] = value; + } + return this; + } + + // Add methods to `ListCache`. + ListCache.prototype.clear = listCacheClear; + ListCache.prototype['delete'] = listCacheDelete; + ListCache.prototype.get = listCacheGet; + ListCache.prototype.has = listCacheHas; + ListCache.prototype.set = listCacheSet; + + /*------------------------------------------------------------------------*/ + + /** + * Creates a map cache object to store key-value pairs. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ + function MapCache(entries) { + var index = -1, + length = entries == null ? 0 : entries.length; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } + } + + /** + * Removes all key-value entries from the map. + * + * @private + * @name clear + * @memberOf MapCache + */ + function mapCacheClear() { + this.size = 0; + this.__data__ = { + 'hash': new Hash, + 'map': new (Map || ListCache), + 'string': new Hash + }; + } + + /** + * Removes `key` and its value from the map. + * + * @private + * @name delete + * @memberOf MapCache + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ + function mapCacheDelete(key) { + var result = getMapData(this, key)['delete'](key); + this.size -= result ? 1 : 0; + return result; + } + + /** + * Gets the map value for `key`. + * + * @private + * @name get + * @memberOf MapCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ + function mapCacheGet(key) { + return getMapData(this, key).get(key); + } + + /** + * Checks if a map value for `key` exists. + * + * @private + * @name has + * @memberOf MapCache + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ + function mapCacheHas(key) { + return getMapData(this, key).has(key); + } + + /** + * Sets the map `key` to `value`. + * + * @private + * @name set + * @memberOf MapCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the map cache instance. + */ + function mapCacheSet(key, value) { + var data = getMapData(this, key), + size = data.size; + + data.set(key, value); + this.size += data.size == size ? 0 : 1; + return this; + } + + // Add methods to `MapCache`. + MapCache.prototype.clear = mapCacheClear; + MapCache.prototype['delete'] = mapCacheDelete; + MapCache.prototype.get = mapCacheGet; + MapCache.prototype.has = mapCacheHas; + MapCache.prototype.set = mapCacheSet; + + /*------------------------------------------------------------------------*/ + + /** + * + * Creates an array cache object to store unique values. + * + * @private + * @constructor + * @param {Array} [values] The values to cache. + */ + function SetCache(values) { + var index = -1, + length = values == null ? 0 : values.length; + + this.__data__ = new MapCache; + while (++index < length) { + this.add(values[index]); + } + } + + /** + * Adds `value` to the array cache. + * + * @private + * @name add + * @memberOf SetCache + * @alias push + * @param {*} value The value to cache. + * @returns {Object} Returns the cache instance. + */ + function setCacheAdd(value) { + this.__data__.set(value, HASH_UNDEFINED); + return this; + } + + /** + * Checks if `value` is in the array cache. + * + * @private + * @name has + * @memberOf SetCache + * @param {*} value The value to search for. + * @returns {number} Returns `true` if `value` is found, else `false`. + */ + function setCacheHas(value) { + return this.__data__.has(value); + } + + // Add methods to `SetCache`. + SetCache.prototype.add = SetCache.prototype.push = setCacheAdd; + SetCache.prototype.has = setCacheHas; + + /*------------------------------------------------------------------------*/ + + /** + * Creates a stack cache object to store key-value pairs. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ + function Stack(entries) { + var data = this.__data__ = new ListCache(entries); + this.size = data.size; + } + + /** + * Removes all key-value entries from the stack. + * + * @private + * @name clear + * @memberOf Stack + */ + function stackClear() { + this.__data__ = new ListCache; + this.size = 0; + } + + /** + * Removes `key` and its value from the stack. + * + * @private + * @name delete + * @memberOf Stack + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ + function stackDelete(key) { + var data = this.__data__, + result = data['delete'](key); + + this.size = data.size; + return result; + } + + /** + * Gets the stack value for `key`. + * + * @private + * @name get + * @memberOf Stack + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ + function stackGet(key) { + return this.__data__.get(key); + } + + /** + * Checks if a stack value for `key` exists. + * + * @private + * @name has + * @memberOf Stack + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ + function stackHas(key) { + return this.__data__.has(key); + } + + /** + * Sets the stack `key` to `value`. + * + * @private + * @name set + * @memberOf Stack + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the stack cache instance. + */ + function stackSet(key, value) { + var data = this.__data__; + if (data instanceof ListCache) { + var pairs = data.__data__; + if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) { + pairs.push([key, value]); + this.size = ++data.size; + return this; + } + data = this.__data__ = new MapCache(pairs); + } + data.set(key, value); + this.size = data.size; + return this; + } + + // Add methods to `Stack`. + Stack.prototype.clear = stackClear; + Stack.prototype['delete'] = stackDelete; + Stack.prototype.get = stackGet; + Stack.prototype.has = stackHas; + Stack.prototype.set = stackSet; + + /*------------------------------------------------------------------------*/ + + /** + * Creates an array of the enumerable property names of the array-like `value`. + * + * @private + * @param {*} value The value to query. + * @param {boolean} inherited Specify returning inherited property names. + * @returns {Array} Returns the array of property names. + */ + function arrayLikeKeys(value, inherited) { + var isArr = isArray(value), + isArg = !isArr && isArguments(value), + isBuff = !isArr && !isArg && isBuffer(value), + isType = !isArr && !isArg && !isBuff && isTypedArray(value), + skipIndexes = isArr || isArg || isBuff || isType, + result = skipIndexes ? baseTimes(value.length, String) : [], + length = result.length; + + for (var key in value) { + if ((inherited || hasOwnProperty.call(value, key)) && + !(skipIndexes && ( + // Safari 9 has enumerable `arguments.length` in strict mode. + key == 'length' || + // Node.js 0.10 has enumerable non-index properties on buffers. + (isBuff && (key == 'offset' || key == 'parent')) || + // PhantomJS 2 has enumerable non-index properties on typed arrays. + (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) || + // Skip index properties. + isIndex(key, length) + ))) { + result.push(key); + } + } + return result; + } + + /** + * A specialized version of `_.sample` for arrays. + * + * @private + * @param {Array} array The array to sample. + * @returns {*} Returns the random element. + */ + function arraySample(array) { + var length = array.length; + return length ? array[baseRandom(0, length - 1)] : undefined; + } + + /** + * A specialized version of `_.sampleSize` for arrays. + * + * @private + * @param {Array} array The array to sample. + * @param {number} n The number of elements to sample. + * @returns {Array} Returns the random elements. + */ + function arraySampleSize(array, n) { + return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length)); + } + + /** + * A specialized version of `_.shuffle` for arrays. + * + * @private + * @param {Array} array The array to shuffle. + * @returns {Array} Returns the new shuffled array. + */ + function arrayShuffle(array) { + return shuffleSelf(copyArray(array)); + } + + /** + * This function is like `assignValue` except that it doesn't assign + * `undefined` values. + * + * @private + * @param {Object} object The object to modify. + * @param {string} key The key of the property to assign. + * @param {*} value The value to assign. + */ + function assignMergeValue(object, key, value) { + if ((value !== undefined && !eq(object[key], value)) || + (value === undefined && !(key in object))) { + baseAssignValue(object, key, value); + } + } + + /** + * Assigns `value` to `key` of `object` if the existing value is not equivalent + * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. + * + * @private + * @param {Object} object The object to modify. + * @param {string} key The key of the property to assign. + * @param {*} value The value to assign. + */ + function assignValue(object, key, value) { + var objValue = object[key]; + if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || + (value === undefined && !(key in object))) { + baseAssignValue(object, key, value); + } + } + + /** + * Gets the index at which the `key` is found in `array` of key-value pairs. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} key The key to search for. + * @returns {number} Returns the index of the matched value, else `-1`. + */ + function assocIndexOf(array, key) { + var length = array.length; + while (length--) { + if (eq(array[length][0], key)) { + return length; + } + } + return -1; + } + + /** + * Aggregates elements of `collection` on `accumulator` with keys transformed + * by `iteratee` and values set by `setter`. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} setter The function to set `accumulator` values. + * @param {Function} iteratee The iteratee to transform keys. + * @param {Object} accumulator The initial aggregated object. + * @returns {Function} Returns `accumulator`. + */ + function baseAggregator(collection, setter, iteratee, accumulator) { + baseEach(collection, function(value, key, collection) { + setter(accumulator, value, iteratee(value), collection); + }); + return accumulator; + } + + /** + * The base implementation of `_.assign` without support for multiple sources + * or `customizer` functions. + * + * @private + * @param {Object} object The destination object. + * @param {Object} source The source object. + * @returns {Object} Returns `object`. + */ + function baseAssign(object, source) { + return object && copyObject(source, keys(source), object); + } + + /** + * The base implementation of `_.assignIn` without support for multiple sources + * or `customizer` functions. + * + * @private + * @param {Object} object The destination object. + * @param {Object} source The source object. + * @returns {Object} Returns `object`. + */ + function baseAssignIn(object, source) { + return object && copyObject(source, keysIn(source), object); + } + + /** + * The base implementation of `assignValue` and `assignMergeValue` without + * value checks. + * + * @private + * @param {Object} object The object to modify. + * @param {string} key The key of the property to assign. + * @param {*} value The value to assign. + */ + function baseAssignValue(object, key, value) { + if (key == '__proto__' && defineProperty) { + defineProperty(object, key, { + 'configurable': true, + 'enumerable': true, + 'value': value, + 'writable': true + }); + } else { + object[key] = value; + } + } + + /** + * The base implementation of `_.at` without support for individual paths. + * + * @private + * @param {Object} object The object to iterate over. + * @param {string[]} paths The property paths to pick. + * @returns {Array} Returns the picked elements. + */ + function baseAt(object, paths) { + var index = -1, + length = paths.length, + result = Array(length), + skip = object == null; + + while (++index < length) { + result[index] = skip ? undefined : get(object, paths[index]); + } + return result; + } + + /** + * The base implementation of `_.clamp` which doesn't coerce arguments. + * + * @private + * @param {number} number The number to clamp. + * @param {number} [lower] The lower bound. + * @param {number} upper The upper bound. + * @returns {number} Returns the clamped number. + */ + function baseClamp(number, lower, upper) { + if (number === number) { + if (upper !== undefined) { + number = number <= upper ? number : upper; + } + if (lower !== undefined) { + number = number >= lower ? number : lower; + } + } + return number; + } + + /** + * The base implementation of `_.clone` and `_.cloneDeep` which tracks + * traversed objects. + * + * @private + * @param {*} value The value to clone. + * @param {boolean} bitmask The bitmask flags. + * 1 - Deep clone + * 2 - Flatten inherited properties + * 4 - Clone symbols + * @param {Function} [customizer] The function to customize cloning. + * @param {string} [key] The key of `value`. + * @param {Object} [object] The parent object of `value`. + * @param {Object} [stack] Tracks traversed objects and their clone counterparts. + * @returns {*} Returns the cloned value. + */ + function baseClone(value, bitmask, customizer, key, object, stack) { + var result, + isDeep = bitmask & CLONE_DEEP_FLAG, + isFlat = bitmask & CLONE_FLAT_FLAG, + isFull = bitmask & CLONE_SYMBOLS_FLAG; + + if (customizer) { + result = object ? customizer(value, key, object, stack) : customizer(value); + } + if (result !== undefined) { + return result; + } + if (!isObject(value)) { + return value; + } + var isArr = isArray(value); + if (isArr) { + result = initCloneArray(value); + if (!isDeep) { + return copyArray(value, result); + } + } else { + var tag = getTag(value), + isFunc = tag == funcTag || tag == genTag; + + if (isBuffer(value)) { + return cloneBuffer(value, isDeep); + } + if (tag == objectTag || tag == argsTag || (isFunc && !object)) { + result = (isFlat || isFunc) ? {} : initCloneObject(value); + if (!isDeep) { + return isFlat + ? copySymbolsIn(value, baseAssignIn(result, value)) + : copySymbols(value, baseAssign(result, value)); + } + } else { + if (!cloneableTags[tag]) { + return object ? value : {}; + } + result = initCloneByTag(value, tag, isDeep); + } + } + // Check for circular references and return its corresponding clone. + stack || (stack = new Stack); + var stacked = stack.get(value); + if (stacked) { + return stacked; + } + stack.set(value, result); + + if (isSet(value)) { + value.forEach(function(subValue) { + result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack)); + }); + } else if (isMap(value)) { + value.forEach(function(subValue, key) { + result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack)); + }); + } + + var keysFunc = isFull + ? (isFlat ? getAllKeysIn : getAllKeys) + : (isFlat ? keysIn : keys); + + var props = isArr ? undefined : keysFunc(value); + arrayEach(props || value, function(subValue, key) { + if (props) { + key = subValue; + subValue = value[key]; + } + // Recursively populate clone (susceptible to call stack limits). + assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack)); + }); + return result; + } + + /** + * The base implementation of `_.conforms` which doesn't clone `source`. + * + * @private + * @param {Object} source The object of property predicates to conform to. + * @returns {Function} Returns the new spec function. + */ + function baseConforms(source) { + var props = keys(source); + return function(object) { + return baseConformsTo(object, source, props); + }; + } + + /** + * The base implementation of `_.conformsTo` which accepts `props` to check. + * + * @private + * @param {Object} object The object to inspect. + * @param {Object} source The object of property predicates to conform to. + * @returns {boolean} Returns `true` if `object` conforms, else `false`. + */ + function baseConformsTo(object, source, props) { + var length = props.length; + if (object == null) { + return !length; + } + object = Object(object); + while (length--) { + var key = props[length], + predicate = source[key], + value = object[key]; + + if ((value === undefined && !(key in object)) || !predicate(value)) { + return false; + } + } + return true; + } + + /** + * The base implementation of `_.delay` and `_.defer` which accepts `args` + * to provide to `func`. + * + * @private + * @param {Function} func The function to delay. + * @param {number} wait The number of milliseconds to delay invocation. + * @param {Array} args The arguments to provide to `func`. + * @returns {number|Object} Returns the timer id or timeout object. + */ + function baseDelay(func, wait, args) { + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + return setTimeout(function() { func.apply(undefined, args); }, wait); + } + + /** + * The base implementation of methods like `_.difference` without support + * for excluding multiple arrays or iteratee shorthands. + * + * @private + * @param {Array} array The array to inspect. + * @param {Array} values The values to exclude. + * @param {Function} [iteratee] The iteratee invoked per element. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of filtered values. + */ + function baseDifference(array, values, iteratee, comparator) { + var index = -1, + includes = arrayIncludes, + isCommon = true, + length = array.length, + result = [], + valuesLength = values.length; + + if (!length) { + return result; + } + if (iteratee) { + values = arrayMap(values, baseUnary(iteratee)); + } + if (comparator) { + includes = arrayIncludesWith; + isCommon = false; + } + else if (values.length >= LARGE_ARRAY_SIZE) { + includes = cacheHas; + isCommon = false; + values = new SetCache(values); + } + outer: + while (++index < length) { + var value = array[index], + computed = iteratee == null ? value : iteratee(value); + + value = (comparator || value !== 0) ? value : 0; + if (isCommon && computed === computed) { + var valuesIndex = valuesLength; + while (valuesIndex--) { + if (values[valuesIndex] === computed) { + continue outer; + } + } + result.push(value); + } + else if (!includes(values, computed, comparator)) { + result.push(value); + } + } + return result; + } + + /** + * The base implementation of `_.forEach` without support for iteratee shorthands. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array|Object} Returns `collection`. + */ + var baseEach = createBaseEach(baseForOwn); + + /** + * The base implementation of `_.forEachRight` without support for iteratee shorthands. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array|Object} Returns `collection`. + */ + var baseEachRight = createBaseEach(baseForOwnRight, true); + + /** + * The base implementation of `_.every` without support for iteratee shorthands. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {boolean} Returns `true` if all elements pass the predicate check, + * else `false` + */ + function baseEvery(collection, predicate) { + var result = true; + baseEach(collection, function(value, index, collection) { + result = !!predicate(value, index, collection); + return result; + }); + return result; + } + + /** + * The base implementation of methods like `_.max` and `_.min` which accepts a + * `comparator` to determine the extremum value. + * + * @private + * @param {Array} array The array to iterate over. + * @param {Function} iteratee The iteratee invoked per iteration. + * @param {Function} comparator The comparator used to compare values. + * @returns {*} Returns the extremum value. + */ + function baseExtremum(array, iteratee, comparator) { + var index = -1, + length = array.length; + + while (++index < length) { + var value = array[index], + current = iteratee(value); + + if (current != null && (computed === undefined + ? (current === current && !isSymbol(current)) + : comparator(current, computed) + )) { + var computed = current, + result = value; + } + } + return result; + } + + /** + * The base implementation of `_.fill` without an iteratee call guard. + * + * @private + * @param {Array} array The array to fill. + * @param {*} value The value to fill `array` with. + * @param {number} [start=0] The start position. + * @param {number} [end=array.length] The end position. + * @returns {Array} Returns `array`. + */ + function baseFill(array, value, start, end) { + var length = array.length; + + start = toInteger(start); + if (start < 0) { + start = -start > length ? 0 : (length + start); + } + end = (end === undefined || end > length) ? length : toInteger(end); + if (end < 0) { + end += length; + } + end = start > end ? 0 : toLength(end); + while (start < end) { + array[start++] = value; + } + return array; + } + + /** + * The base implementation of `_.filter` without support for iteratee shorthands. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {Array} Returns the new filtered array. + */ + function baseFilter(collection, predicate) { + var result = []; + baseEach(collection, function(value, index, collection) { + if (predicate(value, index, collection)) { + result.push(value); + } + }); + return result; + } + + /** + * The base implementation of `_.flatten` with support for restricting flattening. + * + * @private + * @param {Array} array The array to flatten. + * @param {number} depth The maximum recursion depth. + * @param {boolean} [predicate=isFlattenable] The function invoked per iteration. + * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks. + * @param {Array} [result=[]] The initial result value. + * @returns {Array} Returns the new flattened array. + */ + function baseFlatten(array, depth, predicate, isStrict, result) { + var index = -1, + length = array.length; + + predicate || (predicate = isFlattenable); + result || (result = []); + + while (++index < length) { + var value = array[index]; + if (depth > 0 && predicate(value)) { + if (depth > 1) { + // Recursively flatten arrays (susceptible to call stack limits). + baseFlatten(value, depth - 1, predicate, isStrict, result); + } else { + arrayPush(result, value); + } + } else if (!isStrict) { + result[result.length] = value; + } + } + return result; + } + + /** + * The base implementation of `baseForOwn` which iterates over `object` + * properties returned by `keysFunc` and invokes `iteratee` for each property. + * Iteratee functions may exit iteration early by explicitly returning `false`. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {Function} keysFunc The function to get the keys of `object`. + * @returns {Object} Returns `object`. + */ + var baseFor = createBaseFor(); + + /** + * This function is like `baseFor` except that it iterates over properties + * in the opposite order. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {Function} keysFunc The function to get the keys of `object`. + * @returns {Object} Returns `object`. + */ + var baseForRight = createBaseFor(true); + + /** + * The base implementation of `_.forOwn` without support for iteratee shorthands. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Object} Returns `object`. + */ + function baseForOwn(object, iteratee) { + return object && baseFor(object, iteratee, keys); + } + + /** + * The base implementation of `_.forOwnRight` without support for iteratee shorthands. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Object} Returns `object`. + */ + function baseForOwnRight(object, iteratee) { + return object && baseForRight(object, iteratee, keys); + } + + /** + * The base implementation of `_.functions` which creates an array of + * `object` function property names filtered from `props`. + * + * @private + * @param {Object} object The object to inspect. + * @param {Array} props The property names to filter. + * @returns {Array} Returns the function names. + */ + function baseFunctions(object, props) { + return arrayFilter(props, function(key) { + return isFunction(object[key]); + }); + } + + /** + * The base implementation of `_.get` without support for default values. + * + * @private + * @param {Object} object The object to query. + * @param {Array|string} path The path of the property to get. + * @returns {*} Returns the resolved value. + */ + function baseGet(object, path) { + path = castPath(path, object); + + var index = 0, + length = path.length; + + while (object != null && index < length) { + object = object[toKey(path[index++])]; + } + return (index && index == length) ? object : undefined; + } + + /** + * The base implementation of `getAllKeys` and `getAllKeysIn` which uses + * `keysFunc` and `symbolsFunc` to get the enumerable property names and + * symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {Function} keysFunc The function to get the keys of `object`. + * @param {Function} symbolsFunc The function to get the symbols of `object`. + * @returns {Array} Returns the array of property names and symbols. + */ + function baseGetAllKeys(object, keysFunc, symbolsFunc) { + var result = keysFunc(object); + return isArray(object) ? result : arrayPush(result, symbolsFunc(object)); + } + + /** + * The base implementation of `getTag` without fallbacks for buggy environments. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the `toStringTag`. + */ + function baseGetTag(value) { + if (value == null) { + return value === undefined ? undefinedTag : nullTag; + } + return (symToStringTag && symToStringTag in Object(value)) + ? getRawTag(value) + : objectToString(value); + } + + /** + * The base implementation of `_.gt` which doesn't coerce arguments. + * + * @private + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if `value` is greater than `other`, + * else `false`. + */ + function baseGt(value, other) { + return value > other; + } + + /** + * The base implementation of `_.has` without support for deep paths. + * + * @private + * @param {Object} [object] The object to query. + * @param {Array|string} key The key to check. + * @returns {boolean} Returns `true` if `key` exists, else `false`. + */ + function baseHas(object, key) { + return object != null && hasOwnProperty.call(object, key); + } + + /** + * The base implementation of `_.hasIn` without support for deep paths. + * + * @private + * @param {Object} [object] The object to query. + * @param {Array|string} key The key to check. + * @returns {boolean} Returns `true` if `key` exists, else `false`. + */ + function baseHasIn(object, key) { + return object != null && key in Object(object); + } + + /** + * The base implementation of `_.inRange` which doesn't coerce arguments. + * + * @private + * @param {number} number The number to check. + * @param {number} start The start of the range. + * @param {number} end The end of the range. + * @returns {boolean} Returns `true` if `number` is in the range, else `false`. + */ + function baseInRange(number, start, end) { + return number >= nativeMin(start, end) && number < nativeMax(start, end); + } + + /** + * The base implementation of methods like `_.intersection`, without support + * for iteratee shorthands, that accepts an array of arrays to inspect. + * + * @private + * @param {Array} arrays The arrays to inspect. + * @param {Function} [iteratee] The iteratee invoked per element. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of shared values. + */ + function baseIntersection(arrays, iteratee, comparator) { + var includes = comparator ? arrayIncludesWith : arrayIncludes, + length = arrays[0].length, + othLength = arrays.length, + othIndex = othLength, + caches = Array(othLength), + maxLength = Infinity, + result = []; + + while (othIndex--) { + var array = arrays[othIndex]; + if (othIndex && iteratee) { + array = arrayMap(array, baseUnary(iteratee)); + } + maxLength = nativeMin(array.length, maxLength); + caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120)) + ? new SetCache(othIndex && array) + : undefined; + } + array = arrays[0]; + + var index = -1, + seen = caches[0]; + + outer: + while (++index < length && result.length < maxLength) { + var value = array[index], + computed = iteratee ? iteratee(value) : value; + + value = (comparator || value !== 0) ? value : 0; + if (!(seen + ? cacheHas(seen, computed) + : includes(result, computed, comparator) + )) { + othIndex = othLength; + while (--othIndex) { + var cache = caches[othIndex]; + if (!(cache + ? cacheHas(cache, computed) + : includes(arrays[othIndex], computed, comparator)) + ) { + continue outer; + } + } + if (seen) { + seen.push(computed); + } + result.push(value); + } + } + return result; + } + + /** + * The base implementation of `_.invert` and `_.invertBy` which inverts + * `object` with values transformed by `iteratee` and set by `setter`. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} setter The function to set `accumulator` values. + * @param {Function} iteratee The iteratee to transform values. + * @param {Object} accumulator The initial inverted object. + * @returns {Function} Returns `accumulator`. + */ + function baseInverter(object, setter, iteratee, accumulator) { + baseForOwn(object, function(value, key, object) { + setter(accumulator, iteratee(value), key, object); + }); + return accumulator; + } + + /** + * The base implementation of `_.invoke` without support for individual + * method arguments. + * + * @private + * @param {Object} object The object to query. + * @param {Array|string} path The path of the method to invoke. + * @param {Array} args The arguments to invoke the method with. + * @returns {*} Returns the result of the invoked method. + */ + function baseInvoke(object, path, args) { + path = castPath(path, object); + object = parent(object, path); + var func = object == null ? object : object[toKey(last(path))]; + return func == null ? undefined : apply(func, object, args); + } + + /** + * The base implementation of `_.isArguments`. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an `arguments` object, + */ + function baseIsArguments(value) { + return isObjectLike(value) && baseGetTag(value) == argsTag; + } + + /** + * The base implementation of `_.isArrayBuffer` without Node.js optimizations. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`. + */ + function baseIsArrayBuffer(value) { + return isObjectLike(value) && baseGetTag(value) == arrayBufferTag; + } + + /** + * The base implementation of `_.isDate` without Node.js optimizations. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a date object, else `false`. + */ + function baseIsDate(value) { + return isObjectLike(value) && baseGetTag(value) == dateTag; + } + + /** + * The base implementation of `_.isEqual` which supports partial comparisons + * and tracks traversed objects. + * + * @private + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @param {boolean} bitmask The bitmask flags. + * 1 - Unordered comparison + * 2 - Partial comparison + * @param {Function} [customizer] The function to customize comparisons. + * @param {Object} [stack] Tracks traversed `value` and `other` objects. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + */ + function baseIsEqual(value, other, bitmask, customizer, stack) { + if (value === other) { + return true; + } + if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) { + return value !== value && other !== other; + } + return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack); + } + + /** + * A specialized version of `baseIsEqual` for arrays and objects which performs + * deep comparisons and tracks traversed objects enabling objects with circular + * references to be compared. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} [stack] Tracks traversed `object` and `other` objects. + * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. + */ + function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) { + var objIsArr = isArray(object), + othIsArr = isArray(other), + objTag = objIsArr ? arrayTag : getTag(object), + othTag = othIsArr ? arrayTag : getTag(other); + + objTag = objTag == argsTag ? objectTag : objTag; + othTag = othTag == argsTag ? objectTag : othTag; + + var objIsObj = objTag == objectTag, + othIsObj = othTag == objectTag, + isSameTag = objTag == othTag; + + if (isSameTag && isBuffer(object)) { + if (!isBuffer(other)) { + return false; + } + objIsArr = true; + objIsObj = false; + } + if (isSameTag && !objIsObj) { + stack || (stack = new Stack); + return (objIsArr || isTypedArray(object)) + ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) + : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack); + } + if (!(bitmask & COMPARE_PARTIAL_FLAG)) { + var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'), + othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__'); + + if (objIsWrapped || othIsWrapped) { + var objUnwrapped = objIsWrapped ? object.value() : object, + othUnwrapped = othIsWrapped ? other.value() : other; + + stack || (stack = new Stack); + return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack); + } + } + if (!isSameTag) { + return false; + } + stack || (stack = new Stack); + return equalObjects(object, other, bitmask, customizer, equalFunc, stack); + } + + /** + * The base implementation of `_.isMap` without Node.js optimizations. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a map, else `false`. + */ + function baseIsMap(value) { + return isObjectLike(value) && getTag(value) == mapTag; + } + + /** + * The base implementation of `_.isMatch` without support for iteratee shorthands. + * + * @private + * @param {Object} object The object to inspect. + * @param {Object} source The object of property values to match. + * @param {Array} matchData The property names, values, and compare flags to match. + * @param {Function} [customizer] The function to customize comparisons. + * @returns {boolean} Returns `true` if `object` is a match, else `false`. + */ + function baseIsMatch(object, source, matchData, customizer) { + var index = matchData.length, + length = index, + noCustomizer = !customizer; + + if (object == null) { + return !length; + } + object = Object(object); + while (index--) { + var data = matchData[index]; + if ((noCustomizer && data[2]) + ? data[1] !== object[data[0]] + : !(data[0] in object) + ) { + return false; + } + } + while (++index < length) { + data = matchData[index]; + var key = data[0], + objValue = object[key], + srcValue = data[1]; + + if (noCustomizer && data[2]) { + if (objValue === undefined && !(key in object)) { + return false; + } + } else { + var stack = new Stack; + if (customizer) { + var result = customizer(objValue, srcValue, key, object, source, stack); + } + if (!(result === undefined + ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack) + : result + )) { + return false; + } + } + } + return true; + } + + /** + * The base implementation of `_.isNative` without bad shim checks. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a native function, + * else `false`. + */ + function baseIsNative(value) { + if (!isObject(value) || isMasked(value)) { + return false; + } + var pattern = isFunction(value) ? reIsNative : reIsHostCtor; + return pattern.test(toSource(value)); + } + + /** + * The base implementation of `_.isRegExp` without Node.js optimizations. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a regexp, else `false`. + */ + function baseIsRegExp(value) { + return isObjectLike(value) && baseGetTag(value) == regexpTag; + } + + /** + * The base implementation of `_.isSet` without Node.js optimizations. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a set, else `false`. + */ + function baseIsSet(value) { + return isObjectLike(value) && getTag(value) == setTag; + } + + /** + * The base implementation of `_.isTypedArray` without Node.js optimizations. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. + */ + function baseIsTypedArray(value) { + return isObjectLike(value) && + isLength(value.length) && !!typedArrayTags[baseGetTag(value)]; + } + + /** + * The base implementation of `_.iteratee`. + * + * @private + * @param {*} [value=_.identity] The value to convert to an iteratee. + * @returns {Function} Returns the iteratee. + */ + function baseIteratee(value) { + // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9. + // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details. + if (typeof value == 'function') { + return value; + } + if (value == null) { + return identity; + } + if (typeof value == 'object') { + return isArray(value) + ? baseMatchesProperty(value[0], value[1]) + : baseMatches(value); + } + return property(value); + } + + /** + * The base implementation of `_.keys` which doesn't treat sparse arrays as dense. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + */ + function baseKeys(object) { + if (!isPrototype(object)) { + return nativeKeys(object); + } + var result = []; + for (var key in Object(object)) { + if (hasOwnProperty.call(object, key) && key != 'constructor') { + result.push(key); + } + } + return result; + } + + /** + * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + */ + function baseKeysIn(object) { + if (!isObject(object)) { + return nativeKeysIn(object); + } + var isProto = isPrototype(object), + result = []; + + for (var key in object) { + if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) { + result.push(key); + } + } + return result; + } + + /** + * The base implementation of `_.lt` which doesn't coerce arguments. + * + * @private + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if `value` is less than `other`, + * else `false`. + */ + function baseLt(value, other) { + return value < other; + } + + /** + * The base implementation of `_.map` without support for iteratee shorthands. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the new mapped array. + */ + function baseMap(collection, iteratee) { + var index = -1, + result = isArrayLike(collection) ? Array(collection.length) : []; + + baseEach(collection, function(value, key, collection) { + result[++index] = iteratee(value, key, collection); + }); + return result; + } + + /** + * The base implementation of `_.matches` which doesn't clone `source`. + * + * @private + * @param {Object} source The object of property values to match. + * @returns {Function} Returns the new spec function. + */ + function baseMatches(source) { + var matchData = getMatchData(source); + if (matchData.length == 1 && matchData[0][2]) { + return matchesStrictComparable(matchData[0][0], matchData[0][1]); + } + return function(object) { + return object === source || baseIsMatch(object, source, matchData); + }; + } + + /** + * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`. + * + * @private + * @param {string} path The path of the property to get. + * @param {*} srcValue The value to match. + * @returns {Function} Returns the new spec function. + */ + function baseMatchesProperty(path, srcValue) { + if (isKey(path) && isStrictComparable(srcValue)) { + return matchesStrictComparable(toKey(path), srcValue); + } + return function(object) { + var objValue = get(object, path); + return (objValue === undefined && objValue === srcValue) + ? hasIn(object, path) + : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG); + }; + } + + /** + * The base implementation of `_.merge` without support for multiple sources. + * + * @private + * @param {Object} object The destination object. + * @param {Object} source The source object. + * @param {number} srcIndex The index of `source`. + * @param {Function} [customizer] The function to customize merged values. + * @param {Object} [stack] Tracks traversed source values and their merged + * counterparts. + */ + function baseMerge(object, source, srcIndex, customizer, stack) { + if (object === source) { + return; + } + baseFor(source, function(srcValue, key) { + stack || (stack = new Stack); + if (isObject(srcValue)) { + baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack); + } + else { + var newValue = customizer + ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack) + : undefined; + + if (newValue === undefined) { + newValue = srcValue; + } + assignMergeValue(object, key, newValue); + } + }, keysIn); + } + + /** + * A specialized version of `baseMerge` for arrays and objects which performs + * deep merges and tracks traversed objects enabling objects with circular + * references to be merged. + * + * @private + * @param {Object} object The destination object. + * @param {Object} source The source object. + * @param {string} key The key of the value to merge. + * @param {number} srcIndex The index of `source`. + * @param {Function} mergeFunc The function to merge values. + * @param {Function} [customizer] The function to customize assigned values. + * @param {Object} [stack] Tracks traversed source values and their merged + * counterparts. + */ + function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) { + var objValue = safeGet(object, key), + srcValue = safeGet(source, key), + stacked = stack.get(srcValue); + + if (stacked) { + assignMergeValue(object, key, stacked); + return; + } + var newValue = customizer + ? customizer(objValue, srcValue, (key + ''), object, source, stack) + : undefined; + + var isCommon = newValue === undefined; + + if (isCommon) { + var isArr = isArray(srcValue), + isBuff = !isArr && isBuffer(srcValue), + isTyped = !isArr && !isBuff && isTypedArray(srcValue); + + newValue = srcValue; + if (isArr || isBuff || isTyped) { + if (isArray(objValue)) { + newValue = objValue; + } + else if (isArrayLikeObject(objValue)) { + newValue = copyArray(objValue); + } + else if (isBuff) { + isCommon = false; + newValue = cloneBuffer(srcValue, true); + } + else if (isTyped) { + isCommon = false; + newValue = cloneTypedArray(srcValue, true); + } + else { + newValue = []; + } + } + else if (isPlainObject(srcValue) || isArguments(srcValue)) { + newValue = objValue; + if (isArguments(objValue)) { + newValue = toPlainObject(objValue); + } + else if (!isObject(objValue) || isFunction(objValue)) { + newValue = initCloneObject(srcValue); + } + } + else { + isCommon = false; + } + } + if (isCommon) { + // Recursively merge objects and arrays (susceptible to call stack limits). + stack.set(srcValue, newValue); + mergeFunc(newValue, srcValue, srcIndex, customizer, stack); + stack['delete'](srcValue); + } + assignMergeValue(object, key, newValue); + } + + /** + * The base implementation of `_.nth` which doesn't coerce arguments. + * + * @private + * @param {Array} array The array to query. + * @param {number} n The index of the element to return. + * @returns {*} Returns the nth element of `array`. + */ + function baseNth(array, n) { + var length = array.length; + if (!length) { + return; + } + n += n < 0 ? length : 0; + return isIndex(n, length) ? array[n] : undefined; + } + + /** + * The base implementation of `_.orderBy` without param guards. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by. + * @param {string[]} orders The sort orders of `iteratees`. + * @returns {Array} Returns the new sorted array. + */ + function baseOrderBy(collection, iteratees, orders) { + if (iteratees.length) { + iteratees = arrayMap(iteratees, function(iteratee) { + if (isArray(iteratee)) { + return function(value) { + return baseGet(value, iteratee.length === 1 ? iteratee[0] : iteratee); + } + } + return iteratee; + }); + } else { + iteratees = [identity]; + } + + var index = -1; + iteratees = arrayMap(iteratees, baseUnary(getIteratee())); + + var result = baseMap(collection, function(value, key, collection) { + var criteria = arrayMap(iteratees, function(iteratee) { + return iteratee(value); + }); + return { 'criteria': criteria, 'index': ++index, 'value': value }; + }); + + return baseSortBy(result, function(object, other) { + return compareMultiple(object, other, orders); + }); + } + + /** + * The base implementation of `_.pick` without support for individual + * property identifiers. + * + * @private + * @param {Object} object The source object. + * @param {string[]} paths The property paths to pick. + * @returns {Object} Returns the new object. + */ + function basePick(object, paths) { + return basePickBy(object, paths, function(value, path) { + return hasIn(object, path); + }); + } + + /** + * The base implementation of `_.pickBy` without support for iteratee shorthands. + * + * @private + * @param {Object} object The source object. + * @param {string[]} paths The property paths to pick. + * @param {Function} predicate The function invoked per property. + * @returns {Object} Returns the new object. + */ + function basePickBy(object, paths, predicate) { + var index = -1, + length = paths.length, + result = {}; + + while (++index < length) { + var path = paths[index], + value = baseGet(object, path); + + if (predicate(value, path)) { + baseSet(result, castPath(path, object), value); + } + } + return result; + } + + /** + * A specialized version of `baseProperty` which supports deep paths. + * + * @private + * @param {Array|string} path The path of the property to get. + * @returns {Function} Returns the new accessor function. + */ + function basePropertyDeep(path) { + return function(object) { + return baseGet(object, path); + }; + } + + /** + * The base implementation of `_.pullAllBy` without support for iteratee + * shorthands. + * + * @private + * @param {Array} array The array to modify. + * @param {Array} values The values to remove. + * @param {Function} [iteratee] The iteratee invoked per element. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns `array`. + */ + function basePullAll(array, values, iteratee, comparator) { + var indexOf = comparator ? baseIndexOfWith : baseIndexOf, + index = -1, + length = values.length, + seen = array; + + if (array === values) { + values = copyArray(values); + } + if (iteratee) { + seen = arrayMap(array, baseUnary(iteratee)); + } + while (++index < length) { + var fromIndex = 0, + value = values[index], + computed = iteratee ? iteratee(value) : value; + + while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) { + if (seen !== array) { + splice.call(seen, fromIndex, 1); + } + splice.call(array, fromIndex, 1); + } + } + return array; + } + + /** + * The base implementation of `_.pullAt` without support for individual + * indexes or capturing the removed elements. + * + * @private + * @param {Array} array The array to modify. + * @param {number[]} indexes The indexes of elements to remove. + * @returns {Array} Returns `array`. + */ + function basePullAt(array, indexes) { + var length = array ? indexes.length : 0, + lastIndex = length - 1; + + while (length--) { + var index = indexes[length]; + if (length == lastIndex || index !== previous) { + var previous = index; + if (isIndex(index)) { + splice.call(array, index, 1); + } else { + baseUnset(array, index); + } + } + } + return array; + } + + /** + * The base implementation of `_.random` without support for returning + * floating-point numbers. + * + * @private + * @param {number} lower The lower bound. + * @param {number} upper The upper bound. + * @returns {number} Returns the random number. + */ + function baseRandom(lower, upper) { + return lower + nativeFloor(nativeRandom() * (upper - lower + 1)); + } + + /** + * The base implementation of `_.range` and `_.rangeRight` which doesn't + * coerce arguments. + * + * @private + * @param {number} start The start of the range. + * @param {number} end The end of the range. + * @param {number} step The value to increment or decrement by. + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Array} Returns the range of numbers. + */ + function baseRange(start, end, step, fromRight) { + var index = -1, + length = nativeMax(nativeCeil((end - start) / (step || 1)), 0), + result = Array(length); + + while (length--) { + result[fromRight ? length : ++index] = start; + start += step; + } + return result; + } + + /** + * The base implementation of `_.repeat` which doesn't coerce arguments. + * + * @private + * @param {string} string The string to repeat. + * @param {number} n The number of times to repeat the string. + * @returns {string} Returns the repeated string. + */ + function baseRepeat(string, n) { + var result = ''; + if (!string || n < 1 || n > MAX_SAFE_INTEGER) { + return result; + } + // Leverage the exponentiation by squaring algorithm for a faster repeat. + // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details. + do { + if (n % 2) { + result += string; + } + n = nativeFloor(n / 2); + if (n) { + string += string; + } + } while (n); + + return result; + } + + /** + * The base implementation of `_.rest` which doesn't validate or coerce arguments. + * + * @private + * @param {Function} func The function to apply a rest parameter to. + * @param {number} [start=func.length-1] The start position of the rest parameter. + * @returns {Function} Returns the new function. + */ + function baseRest(func, start) { + return setToString(overRest(func, start, identity), func + ''); + } + + /** + * The base implementation of `_.sample`. + * + * @private + * @param {Array|Object} collection The collection to sample. + * @returns {*} Returns the random element. + */ + function baseSample(collection) { + return arraySample(values(collection)); + } + + /** + * The base implementation of `_.sampleSize` without param guards. + * + * @private + * @param {Array|Object} collection The collection to sample. + * @param {number} n The number of elements to sample. + * @returns {Array} Returns the random elements. + */ + function baseSampleSize(collection, n) { + var array = values(collection); + return shuffleSelf(array, baseClamp(n, 0, array.length)); + } + + /** + * The base implementation of `_.set`. + * + * @private + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to set. + * @param {*} value The value to set. + * @param {Function} [customizer] The function to customize path creation. + * @returns {Object} Returns `object`. + */ + function baseSet(object, path, value, customizer) { + if (!isObject(object)) { + return object; + } + path = castPath(path, object); + + var index = -1, + length = path.length, + lastIndex = length - 1, + nested = object; + + while (nested != null && ++index < length) { + var key = toKey(path[index]), + newValue = value; + + if (key === '__proto__' || key === 'constructor' || key === 'prototype') { + return object; + } + + if (index != lastIndex) { + var objValue = nested[key]; + newValue = customizer ? customizer(objValue, key, nested) : undefined; + if (newValue === undefined) { + newValue = isObject(objValue) + ? objValue + : (isIndex(path[index + 1]) ? [] : {}); + } + } + assignValue(nested, key, newValue); + nested = nested[key]; + } + return object; + } + + /** + * The base implementation of `setData` without support for hot loop shorting. + * + * @private + * @param {Function} func The function to associate metadata with. + * @param {*} data The metadata. + * @returns {Function} Returns `func`. + */ + var baseSetData = !metaMap ? identity : function(func, data) { + metaMap.set(func, data); + return func; + }; + + /** + * The base implementation of `setToString` without support for hot loop shorting. + * + * @private + * @param {Function} func The function to modify. + * @param {Function} string The `toString` result. + * @returns {Function} Returns `func`. + */ + var baseSetToString = !defineProperty ? identity : function(func, string) { + return defineProperty(func, 'toString', { + 'configurable': true, + 'enumerable': false, + 'value': constant(string), + 'writable': true + }); + }; + + /** + * The base implementation of `_.shuffle`. + * + * @private + * @param {Array|Object} collection The collection to shuffle. + * @returns {Array} Returns the new shuffled array. + */ + function baseShuffle(collection) { + return shuffleSelf(values(collection)); + } + + /** + * The base implementation of `_.slice` without an iteratee call guard. + * + * @private + * @param {Array} array The array to slice. + * @param {number} [start=0] The start position. + * @param {number} [end=array.length] The end position. + * @returns {Array} Returns the slice of `array`. + */ + function baseSlice(array, start, end) { + var index = -1, + length = array.length; + + if (start < 0) { + start = -start > length ? 0 : (length + start); + } + end = end > length ? length : end; + if (end < 0) { + end += length; + } + length = start > end ? 0 : ((end - start) >>> 0); + start >>>= 0; + + var result = Array(length); + while (++index < length) { + result[index] = array[index + start]; + } + return result; + } + + /** + * The base implementation of `_.some` without support for iteratee shorthands. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {boolean} Returns `true` if any element passes the predicate check, + * else `false`. + */ + function baseSome(collection, predicate) { + var result; + + baseEach(collection, function(value, index, collection) { + result = predicate(value, index, collection); + return !result; + }); + return !!result; + } + + /** + * The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which + * performs a binary search of `array` to determine the index at which `value` + * should be inserted into `array` in order to maintain its sort order. + * + * @private + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @param {boolean} [retHighest] Specify returning the highest qualified index. + * @returns {number} Returns the index at which `value` should be inserted + * into `array`. + */ + function baseSortedIndex(array, value, retHighest) { + var low = 0, + high = array == null ? low : array.length; + + if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) { + while (low < high) { + var mid = (low + high) >>> 1, + computed = array[mid]; + + if (computed !== null && !isSymbol(computed) && + (retHighest ? (computed <= value) : (computed < value))) { + low = mid + 1; + } else { + high = mid; + } + } + return high; + } + return baseSortedIndexBy(array, value, identity, retHighest); + } + + /** + * The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy` + * which invokes `iteratee` for `value` and each element of `array` to compute + * their sort ranking. The iteratee is invoked with one argument; (value). + * + * @private + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @param {Function} iteratee The iteratee invoked per element. + * @param {boolean} [retHighest] Specify returning the highest qualified index. + * @returns {number} Returns the index at which `value` should be inserted + * into `array`. + */ + function baseSortedIndexBy(array, value, iteratee, retHighest) { + var low = 0, + high = array == null ? 0 : array.length; + if (high === 0) { + return 0; + } + + value = iteratee(value); + var valIsNaN = value !== value, + valIsNull = value === null, + valIsSymbol = isSymbol(value), + valIsUndefined = value === undefined; + + while (low < high) { + var mid = nativeFloor((low + high) / 2), + computed = iteratee(array[mid]), + othIsDefined = computed !== undefined, + othIsNull = computed === null, + othIsReflexive = computed === computed, + othIsSymbol = isSymbol(computed); + + if (valIsNaN) { + var setLow = retHighest || othIsReflexive; + } else if (valIsUndefined) { + setLow = othIsReflexive && (retHighest || othIsDefined); + } else if (valIsNull) { + setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull); + } else if (valIsSymbol) { + setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol); + } else if (othIsNull || othIsSymbol) { + setLow = false; + } else { + setLow = retHighest ? (computed <= value) : (computed < value); + } + if (setLow) { + low = mid + 1; + } else { + high = mid; + } + } + return nativeMin(high, MAX_ARRAY_INDEX); + } + + /** + * The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without + * support for iteratee shorthands. + * + * @private + * @param {Array} array The array to inspect. + * @param {Function} [iteratee] The iteratee invoked per element. + * @returns {Array} Returns the new duplicate free array. + */ + function baseSortedUniq(array, iteratee) { + var index = -1, + length = array.length, + resIndex = 0, + result = []; + + while (++index < length) { + var value = array[index], + computed = iteratee ? iteratee(value) : value; + + if (!index || !eq(computed, seen)) { + var seen = computed; + result[resIndex++] = value === 0 ? 0 : value; + } + } + return result; + } + + /** + * The base implementation of `_.toNumber` which doesn't ensure correct + * conversions of binary, hexadecimal, or octal string values. + * + * @private + * @param {*} value The value to process. + * @returns {number} Returns the number. + */ + function baseToNumber(value) { + if (typeof value == 'number') { + return value; + } + if (isSymbol(value)) { + return NAN; + } + return +value; + } + + /** + * The base implementation of `_.toString` which doesn't convert nullish + * values to empty strings. + * + * @private + * @param {*} value The value to process. + * @returns {string} Returns the string. + */ + function baseToString(value) { + // Exit early for strings to avoid a performance hit in some environments. + if (typeof value == 'string') { + return value; + } + if (isArray(value)) { + // Recursively convert values (susceptible to call stack limits). + return arrayMap(value, baseToString) + ''; + } + if (isSymbol(value)) { + return symbolToString ? symbolToString.call(value) : ''; + } + var result = (value + ''); + return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; + } + + /** + * The base implementation of `_.uniqBy` without support for iteratee shorthands. + * + * @private + * @param {Array} array The array to inspect. + * @param {Function} [iteratee] The iteratee invoked per element. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new duplicate free array. + */ + function baseUniq(array, iteratee, comparator) { + var index = -1, + includes = arrayIncludes, + length = array.length, + isCommon = true, + result = [], + seen = result; + + if (comparator) { + isCommon = false; + includes = arrayIncludesWith; + } + else if (length >= LARGE_ARRAY_SIZE) { + var set = iteratee ? null : createSet(array); + if (set) { + return setToArray(set); + } + isCommon = false; + includes = cacheHas; + seen = new SetCache; + } + else { + seen = iteratee ? [] : result; + } + outer: + while (++index < length) { + var value = array[index], + computed = iteratee ? iteratee(value) : value; + + value = (comparator || value !== 0) ? value : 0; + if (isCommon && computed === computed) { + var seenIndex = seen.length; + while (seenIndex--) { + if (seen[seenIndex] === computed) { + continue outer; + } + } + if (iteratee) { + seen.push(computed); + } + result.push(value); + } + else if (!includes(seen, computed, comparator)) { + if (seen !== result) { + seen.push(computed); + } + result.push(value); + } + } + return result; + } + + /** + * The base implementation of `_.unset`. + * + * @private + * @param {Object} object The object to modify. + * @param {Array|string} path The property path to unset. + * @returns {boolean} Returns `true` if the property is deleted, else `false`. + */ + function baseUnset(object, path) { + path = castPath(path, object); + object = parent(object, path); + return object == null || delete object[toKey(last(path))]; + } + + /** + * The base implementation of `_.update`. + * + * @private + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to update. + * @param {Function} updater The function to produce the updated value. + * @param {Function} [customizer] The function to customize path creation. + * @returns {Object} Returns `object`. + */ + function baseUpdate(object, path, updater, customizer) { + return baseSet(object, path, updater(baseGet(object, path)), customizer); + } + + /** + * The base implementation of methods like `_.dropWhile` and `_.takeWhile` + * without support for iteratee shorthands. + * + * @private + * @param {Array} array The array to query. + * @param {Function} predicate The function invoked per iteration. + * @param {boolean} [isDrop] Specify dropping elements instead of taking them. + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Array} Returns the slice of `array`. + */ + function baseWhile(array, predicate, isDrop, fromRight) { + var length = array.length, + index = fromRight ? length : -1; + + while ((fromRight ? index-- : ++index < length) && + predicate(array[index], index, array)) {} + + return isDrop + ? baseSlice(array, (fromRight ? 0 : index), (fromRight ? index + 1 : length)) + : baseSlice(array, (fromRight ? index + 1 : 0), (fromRight ? length : index)); + } + + /** + * The base implementation of `wrapperValue` which returns the result of + * performing a sequence of actions on the unwrapped `value`, where each + * successive action is supplied the return value of the previous. + * + * @private + * @param {*} value The unwrapped value. + * @param {Array} actions Actions to perform to resolve the unwrapped value. + * @returns {*} Returns the resolved value. + */ + function baseWrapperValue(value, actions) { + var result = value; + if (result instanceof LazyWrapper) { + result = result.value(); + } + return arrayReduce(actions, function(result, action) { + return action.func.apply(action.thisArg, arrayPush([result], action.args)); + }, result); + } + + /** + * The base implementation of methods like `_.xor`, without support for + * iteratee shorthands, that accepts an array of arrays to inspect. + * + * @private + * @param {Array} arrays The arrays to inspect. + * @param {Function} [iteratee] The iteratee invoked per element. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of values. + */ + function baseXor(arrays, iteratee, comparator) { + var length = arrays.length; + if (length < 2) { + return length ? baseUniq(arrays[0]) : []; + } + var index = -1, + result = Array(length); + + while (++index < length) { + var array = arrays[index], + othIndex = -1; + + while (++othIndex < length) { + if (othIndex != index) { + result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator); + } + } + } + return baseUniq(baseFlatten(result, 1), iteratee, comparator); + } + + /** + * This base implementation of `_.zipObject` which assigns values using `assignFunc`. + * + * @private + * @param {Array} props The property identifiers. + * @param {Array} values The property values. + * @param {Function} assignFunc The function to assign values. + * @returns {Object} Returns the new object. + */ + function baseZipObject(props, values, assignFunc) { + var index = -1, + length = props.length, + valsLength = values.length, + result = {}; + + while (++index < length) { + var value = index < valsLength ? values[index] : undefined; + assignFunc(result, props[index], value); + } + return result; + } + + /** + * Casts `value` to an empty array if it's not an array like object. + * + * @private + * @param {*} value The value to inspect. + * @returns {Array|Object} Returns the cast array-like object. + */ + function castArrayLikeObject(value) { + return isArrayLikeObject(value) ? value : []; + } + + /** + * Casts `value` to `identity` if it's not a function. + * + * @private + * @param {*} value The value to inspect. + * @returns {Function} Returns cast function. + */ + function castFunction(value) { + return typeof value == 'function' ? value : identity; + } + + /** + * Casts `value` to a path array if it's not one. + * + * @private + * @param {*} value The value to inspect. + * @param {Object} [object] The object to query keys on. + * @returns {Array} Returns the cast property path array. + */ + function castPath(value, object) { + if (isArray(value)) { + return value; + } + return isKey(value, object) ? [value] : stringToPath(toString(value)); + } + + /** + * A `baseRest` alias which can be replaced with `identity` by module + * replacement plugins. + * + * @private + * @type {Function} + * @param {Function} func The function to apply a rest parameter to. + * @returns {Function} Returns the new function. + */ + var castRest = baseRest; + + /** + * Casts `array` to a slice if it's needed. + * + * @private + * @param {Array} array The array to inspect. + * @param {number} start The start position. + * @param {number} [end=array.length] The end position. + * @returns {Array} Returns the cast slice. + */ + function castSlice(array, start, end) { + var length = array.length; + end = end === undefined ? length : end; + return (!start && end >= length) ? array : baseSlice(array, start, end); + } + + /** + * A simple wrapper around the global [`clearTimeout`](https://mdn.io/clearTimeout). + * + * @private + * @param {number|Object} id The timer id or timeout object of the timer to clear. + */ + var clearTimeout = ctxClearTimeout || function(id) { + return root.clearTimeout(id); + }; + + /** + * Creates a clone of `buffer`. + * + * @private + * @param {Buffer} buffer The buffer to clone. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Buffer} Returns the cloned buffer. + */ + function cloneBuffer(buffer, isDeep) { + if (isDeep) { + return buffer.slice(); + } + var length = buffer.length, + result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length); + + buffer.copy(result); + return result; + } + + /** + * Creates a clone of `arrayBuffer`. + * + * @private + * @param {ArrayBuffer} arrayBuffer The array buffer to clone. + * @returns {ArrayBuffer} Returns the cloned array buffer. + */ + function cloneArrayBuffer(arrayBuffer) { + var result = new arrayBuffer.constructor(arrayBuffer.byteLength); + new Uint8Array(result).set(new Uint8Array(arrayBuffer)); + return result; + } + + /** + * Creates a clone of `dataView`. + * + * @private + * @param {Object} dataView The data view to clone. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Object} Returns the cloned data view. + */ + function cloneDataView(dataView, isDeep) { + var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer; + return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength); + } + + /** + * Creates a clone of `regexp`. + * + * @private + * @param {Object} regexp The regexp to clone. + * @returns {Object} Returns the cloned regexp. + */ + function cloneRegExp(regexp) { + var result = new regexp.constructor(regexp.source, reFlags.exec(regexp)); + result.lastIndex = regexp.lastIndex; + return result; + } + + /** + * Creates a clone of the `symbol` object. + * + * @private + * @param {Object} symbol The symbol object to clone. + * @returns {Object} Returns the cloned symbol object. + */ + function cloneSymbol(symbol) { + return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {}; + } + + /** + * Creates a clone of `typedArray`. + * + * @private + * @param {Object} typedArray The typed array to clone. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Object} Returns the cloned typed array. + */ + function cloneTypedArray(typedArray, isDeep) { + var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer; + return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length); + } + + /** + * Compares values to sort them in ascending order. + * + * @private + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {number} Returns the sort order indicator for `value`. + */ + function compareAscending(value, other) { + if (value !== other) { + var valIsDefined = value !== undefined, + valIsNull = value === null, + valIsReflexive = value === value, + valIsSymbol = isSymbol(value); + + var othIsDefined = other !== undefined, + othIsNull = other === null, + othIsReflexive = other === other, + othIsSymbol = isSymbol(other); + + if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) || + (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) || + (valIsNull && othIsDefined && othIsReflexive) || + (!valIsDefined && othIsReflexive) || + !valIsReflexive) { + return 1; + } + if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) || + (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) || + (othIsNull && valIsDefined && valIsReflexive) || + (!othIsDefined && valIsReflexive) || + !othIsReflexive) { + return -1; + } + } + return 0; + } + + /** + * Used by `_.orderBy` to compare multiple properties of a value to another + * and stable sort them. + * + * If `orders` is unspecified, all values are sorted in ascending order. Otherwise, + * specify an order of "desc" for descending or "asc" for ascending sort order + * of corresponding values. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {boolean[]|string[]} orders The order to sort by for each property. + * @returns {number} Returns the sort order indicator for `object`. + */ + function compareMultiple(object, other, orders) { + var index = -1, + objCriteria = object.criteria, + othCriteria = other.criteria, + length = objCriteria.length, + ordersLength = orders.length; + + while (++index < length) { + var result = compareAscending(objCriteria[index], othCriteria[index]); + if (result) { + if (index >= ordersLength) { + return result; + } + var order = orders[index]; + return result * (order == 'desc' ? -1 : 1); + } + } + // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications + // that causes it, under certain circumstances, to provide the same value for + // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247 + // for more details. + // + // This also ensures a stable sort in V8 and other engines. + // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details. + return object.index - other.index; + } + + /** + * Creates an array that is the composition of partially applied arguments, + * placeholders, and provided arguments into a single array of arguments. + * + * @private + * @param {Array} args The provided arguments. + * @param {Array} partials The arguments to prepend to those provided. + * @param {Array} holders The `partials` placeholder indexes. + * @params {boolean} [isCurried] Specify composing for a curried function. + * @returns {Array} Returns the new array of composed arguments. + */ + function composeArgs(args, partials, holders, isCurried) { + var argsIndex = -1, + argsLength = args.length, + holdersLength = holders.length, + leftIndex = -1, + leftLength = partials.length, + rangeLength = nativeMax(argsLength - holdersLength, 0), + result = Array(leftLength + rangeLength), + isUncurried = !isCurried; + + while (++leftIndex < leftLength) { + result[leftIndex] = partials[leftIndex]; + } + while (++argsIndex < holdersLength) { + if (isUncurried || argsIndex < argsLength) { + result[holders[argsIndex]] = args[argsIndex]; + } + } + while (rangeLength--) { + result[leftIndex++] = args[argsIndex++]; + } + return result; + } + + /** + * This function is like `composeArgs` except that the arguments composition + * is tailored for `_.partialRight`. + * + * @private + * @param {Array} args The provided arguments. + * @param {Array} partials The arguments to append to those provided. + * @param {Array} holders The `partials` placeholder indexes. + * @params {boolean} [isCurried] Specify composing for a curried function. + * @returns {Array} Returns the new array of composed arguments. + */ + function composeArgsRight(args, partials, holders, isCurried) { + var argsIndex = -1, + argsLength = args.length, + holdersIndex = -1, + holdersLength = holders.length, + rightIndex = -1, + rightLength = partials.length, + rangeLength = nativeMax(argsLength - holdersLength, 0), + result = Array(rangeLength + rightLength), + isUncurried = !isCurried; + + while (++argsIndex < rangeLength) { + result[argsIndex] = args[argsIndex]; + } + var offset = argsIndex; + while (++rightIndex < rightLength) { + result[offset + rightIndex] = partials[rightIndex]; + } + while (++holdersIndex < holdersLength) { + if (isUncurried || argsIndex < argsLength) { + result[offset + holders[holdersIndex]] = args[argsIndex++]; + } + } + return result; + } + + /** + * Copies the values of `source` to `array`. + * + * @private + * @param {Array} source The array to copy values from. + * @param {Array} [array=[]] The array to copy values to. + * @returns {Array} Returns `array`. + */ + function copyArray(source, array) { + var index = -1, + length = source.length; + + array || (array = Array(length)); + while (++index < length) { + array[index] = source[index]; + } + return array; + } + + /** + * Copies properties of `source` to `object`. + * + * @private + * @param {Object} source The object to copy properties from. + * @param {Array} props The property identifiers to copy. + * @param {Object} [object={}] The object to copy properties to. + * @param {Function} [customizer] The function to customize copied values. + * @returns {Object} Returns `object`. + */ + function copyObject(source, props, object, customizer) { + var isNew = !object; + object || (object = {}); + + var index = -1, + length = props.length; + + while (++index < length) { + var key = props[index]; + + var newValue = customizer + ? customizer(object[key], source[key], key, object, source) + : undefined; + + if (newValue === undefined) { + newValue = source[key]; + } + if (isNew) { + baseAssignValue(object, key, newValue); + } else { + assignValue(object, key, newValue); + } + } + return object; + } + + /** + * Copies own symbols of `source` to `object`. + * + * @private + * @param {Object} source The object to copy symbols from. + * @param {Object} [object={}] The object to copy symbols to. + * @returns {Object} Returns `object`. + */ + function copySymbols(source, object) { + return copyObject(source, getSymbols(source), object); + } + + /** + * Copies own and inherited symbols of `source` to `object`. + * + * @private + * @param {Object} source The object to copy symbols from. + * @param {Object} [object={}] The object to copy symbols to. + * @returns {Object} Returns `object`. + */ + function copySymbolsIn(source, object) { + return copyObject(source, getSymbolsIn(source), object); + } + + /** + * Creates a function like `_.groupBy`. + * + * @private + * @param {Function} setter The function to set accumulator values. + * @param {Function} [initializer] The accumulator object initializer. + * @returns {Function} Returns the new aggregator function. + */ + function createAggregator(setter, initializer) { + return function(collection, iteratee) { + var func = isArray(collection) ? arrayAggregator : baseAggregator, + accumulator = initializer ? initializer() : {}; + + return func(collection, setter, getIteratee(iteratee, 2), accumulator); + }; + } + + /** + * Creates a function like `_.assign`. + * + * @private + * @param {Function} assigner The function to assign values. + * @returns {Function} Returns the new assigner function. + */ + function createAssigner(assigner) { + return baseRest(function(object, sources) { + var index = -1, + length = sources.length, + customizer = length > 1 ? sources[length - 1] : undefined, + guard = length > 2 ? sources[2] : undefined; + + customizer = (assigner.length > 3 && typeof customizer == 'function') + ? (length--, customizer) + : undefined; + + if (guard && isIterateeCall(sources[0], sources[1], guard)) { + customizer = length < 3 ? undefined : customizer; + length = 1; + } + object = Object(object); + while (++index < length) { + var source = sources[index]; + if (source) { + assigner(object, source, index, customizer); + } + } + return object; + }); + } + + /** + * Creates a `baseEach` or `baseEachRight` function. + * + * @private + * @param {Function} eachFunc The function to iterate over a collection. + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Function} Returns the new base function. + */ + function createBaseEach(eachFunc, fromRight) { + return function(collection, iteratee) { + if (collection == null) { + return collection; + } + if (!isArrayLike(collection)) { + return eachFunc(collection, iteratee); + } + var length = collection.length, + index = fromRight ? length : -1, + iterable = Object(collection); + + while ((fromRight ? index-- : ++index < length)) { + if (iteratee(iterable[index], index, iterable) === false) { + break; + } + } + return collection; + }; + } + + /** + * Creates a base function for methods like `_.forIn` and `_.forOwn`. + * + * @private + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Function} Returns the new base function. + */ + function createBaseFor(fromRight) { + return function(object, iteratee, keysFunc) { + var index = -1, + iterable = Object(object), + props = keysFunc(object), + length = props.length; + + while (length--) { + var key = props[fromRight ? length : ++index]; + if (iteratee(iterable[key], key, iterable) === false) { + break; + } + } + return object; + }; + } + + /** + * Creates a function that wraps `func` to invoke it with the optional `this` + * binding of `thisArg`. + * + * @private + * @param {Function} func The function to wrap. + * @param {number} bitmask The bitmask flags. See `createWrap` for more details. + * @param {*} [thisArg] The `this` binding of `func`. + * @returns {Function} Returns the new wrapped function. + */ + function createBind(func, bitmask, thisArg) { + var isBind = bitmask & WRAP_BIND_FLAG, + Ctor = createCtor(func); + + function wrapper() { + var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func; + return fn.apply(isBind ? thisArg : this, arguments); + } + return wrapper; + } + + /** + * Creates a function like `_.lowerFirst`. + * + * @private + * @param {string} methodName The name of the `String` case method to use. + * @returns {Function} Returns the new case function. + */ + function createCaseFirst(methodName) { + return function(string) { + string = toString(string); + + var strSymbols = hasUnicode(string) + ? stringToArray(string) + : undefined; + + var chr = strSymbols + ? strSymbols[0] + : string.charAt(0); + + var trailing = strSymbols + ? castSlice(strSymbols, 1).join('') + : string.slice(1); + + return chr[methodName]() + trailing; + }; + } + + /** + * Creates a function like `_.camelCase`. + * + * @private + * @param {Function} callback The function to combine each word. + * @returns {Function} Returns the new compounder function. + */ + function createCompounder(callback) { + return function(string) { + return arrayReduce(words(deburr(string).replace(reApos, '')), callback, ''); + }; + } + + /** + * Creates a function that produces an instance of `Ctor` regardless of + * whether it was invoked as part of a `new` expression or by `call` or `apply`. + * + * @private + * @param {Function} Ctor The constructor to wrap. + * @returns {Function} Returns the new wrapped function. + */ + function createCtor(Ctor) { + return function() { + // Use a `switch` statement to work with class constructors. See + // http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist + // for more details. + var args = arguments; + switch (args.length) { + case 0: return new Ctor; + case 1: return new Ctor(args[0]); + case 2: return new Ctor(args[0], args[1]); + case 3: return new Ctor(args[0], args[1], args[2]); + case 4: return new Ctor(args[0], args[1], args[2], args[3]); + case 5: return new Ctor(args[0], args[1], args[2], args[3], args[4]); + case 6: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]); + case 7: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]); + } + var thisBinding = baseCreate(Ctor.prototype), + result = Ctor.apply(thisBinding, args); + + // Mimic the constructor's `return` behavior. + // See https://es5.github.io/#x13.2.2 for more details. + return isObject(result) ? result : thisBinding; + }; + } + + /** + * Creates a function that wraps `func` to enable currying. + * + * @private + * @param {Function} func The function to wrap. + * @param {number} bitmask The bitmask flags. See `createWrap` for more details. + * @param {number} arity The arity of `func`. + * @returns {Function} Returns the new wrapped function. + */ + function createCurry(func, bitmask, arity) { + var Ctor = createCtor(func); + + function wrapper() { + var length = arguments.length, + args = Array(length), + index = length, + placeholder = getHolder(wrapper); + + while (index--) { + args[index] = arguments[index]; + } + var holders = (length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder) + ? [] + : replaceHolders(args, placeholder); + + length -= holders.length; + if (length < arity) { + return createRecurry( + func, bitmask, createHybrid, wrapper.placeholder, undefined, + args, holders, undefined, undefined, arity - length); + } + var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func; + return apply(fn, this, args); + } + return wrapper; + } + + /** + * Creates a `_.find` or `_.findLast` function. + * + * @private + * @param {Function} findIndexFunc The function to find the collection index. + * @returns {Function} Returns the new find function. + */ + function createFind(findIndexFunc) { + return function(collection, predicate, fromIndex) { + var iterable = Object(collection); + if (!isArrayLike(collection)) { + var iteratee = getIteratee(predicate, 3); + collection = keys(collection); + predicate = function(key) { return iteratee(iterable[key], key, iterable); }; + } + var index = findIndexFunc(collection, predicate, fromIndex); + return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined; + }; + } + + /** + * Creates a `_.flow` or `_.flowRight` function. + * + * @private + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Function} Returns the new flow function. + */ + function createFlow(fromRight) { + return flatRest(function(funcs) { + var length = funcs.length, + index = length, + prereq = LodashWrapper.prototype.thru; + + if (fromRight) { + funcs.reverse(); + } + while (index--) { + var func = funcs[index]; + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + if (prereq && !wrapper && getFuncName(func) == 'wrapper') { + var wrapper = new LodashWrapper([], true); + } + } + index = wrapper ? index : length; + while (++index < length) { + func = funcs[index]; + + var funcName = getFuncName(func), + data = funcName == 'wrapper' ? getData(func) : undefined; + + if (data && isLaziable(data[0]) && + data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) && + !data[4].length && data[9] == 1 + ) { + wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]); + } else { + wrapper = (func.length == 1 && isLaziable(func)) + ? wrapper[funcName]() + : wrapper.thru(func); + } + } + return function() { + var args = arguments, + value = args[0]; + + if (wrapper && args.length == 1 && isArray(value)) { + return wrapper.plant(value).value(); + } + var index = 0, + result = length ? funcs[index].apply(this, args) : value; + + while (++index < length) { + result = funcs[index].call(this, result); + } + return result; + }; + }); + } + + /** + * Creates a function that wraps `func` to invoke it with optional `this` + * binding of `thisArg`, partial application, and currying. + * + * @private + * @param {Function|string} func The function or method name to wrap. + * @param {number} bitmask The bitmask flags. See `createWrap` for more details. + * @param {*} [thisArg] The `this` binding of `func`. + * @param {Array} [partials] The arguments to prepend to those provided to + * the new function. + * @param {Array} [holders] The `partials` placeholder indexes. + * @param {Array} [partialsRight] The arguments to append to those provided + * to the new function. + * @param {Array} [holdersRight] The `partialsRight` placeholder indexes. + * @param {Array} [argPos] The argument positions of the new function. + * @param {number} [ary] The arity cap of `func`. + * @param {number} [arity] The arity of `func`. + * @returns {Function} Returns the new wrapped function. + */ + function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) { + var isAry = bitmask & WRAP_ARY_FLAG, + isBind = bitmask & WRAP_BIND_FLAG, + isBindKey = bitmask & WRAP_BIND_KEY_FLAG, + isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG), + isFlip = bitmask & WRAP_FLIP_FLAG, + Ctor = isBindKey ? undefined : createCtor(func); + + function wrapper() { + var length = arguments.length, + args = Array(length), + index = length; + + while (index--) { + args[index] = arguments[index]; + } + if (isCurried) { + var placeholder = getHolder(wrapper), + holdersCount = countHolders(args, placeholder); + } + if (partials) { + args = composeArgs(args, partials, holders, isCurried); + } + if (partialsRight) { + args = composeArgsRight(args, partialsRight, holdersRight, isCurried); + } + length -= holdersCount; + if (isCurried && length < arity) { + var newHolders = replaceHolders(args, placeholder); + return createRecurry( + func, bitmask, createHybrid, wrapper.placeholder, thisArg, + args, newHolders, argPos, ary, arity - length + ); + } + var thisBinding = isBind ? thisArg : this, + fn = isBindKey ? thisBinding[func] : func; + + length = args.length; + if (argPos) { + args = reorder(args, argPos); + } else if (isFlip && length > 1) { + args.reverse(); + } + if (isAry && ary < length) { + args.length = ary; + } + if (this && this !== root && this instanceof wrapper) { + fn = Ctor || createCtor(fn); + } + return fn.apply(thisBinding, args); + } + return wrapper; + } + + /** + * Creates a function like `_.invertBy`. + * + * @private + * @param {Function} setter The function to set accumulator values. + * @param {Function} toIteratee The function to resolve iteratees. + * @returns {Function} Returns the new inverter function. + */ + function createInverter(setter, toIteratee) { + return function(object, iteratee) { + return baseInverter(object, setter, toIteratee(iteratee), {}); + }; + } + + /** + * Creates a function that performs a mathematical operation on two values. + * + * @private + * @param {Function} operator The function to perform the operation. + * @param {number} [defaultValue] The value used for `undefined` arguments. + * @returns {Function} Returns the new mathematical operation function. + */ + function createMathOperation(operator, defaultValue) { + return function(value, other) { + var result; + if (value === undefined && other === undefined) { + return defaultValue; + } + if (value !== undefined) { + result = value; + } + if (other !== undefined) { + if (result === undefined) { + return other; + } + if (typeof value == 'string' || typeof other == 'string') { + value = baseToString(value); + other = baseToString(other); + } else { + value = baseToNumber(value); + other = baseToNumber(other); + } + result = operator(value, other); + } + return result; + }; + } + + /** + * Creates a function like `_.over`. + * + * @private + * @param {Function} arrayFunc The function to iterate over iteratees. + * @returns {Function} Returns the new over function. + */ + function createOver(arrayFunc) { + return flatRest(function(iteratees) { + iteratees = arrayMap(iteratees, baseUnary(getIteratee())); + return baseRest(function(args) { + var thisArg = this; + return arrayFunc(iteratees, function(iteratee) { + return apply(iteratee, thisArg, args); + }); + }); + }); + } + + /** + * Creates the padding for `string` based on `length`. The `chars` string + * is truncated if the number of characters exceeds `length`. + * + * @private + * @param {number} length The padding length. + * @param {string} [chars=' '] The string used as padding. + * @returns {string} Returns the padding for `string`. + */ + function createPadding(length, chars) { + chars = chars === undefined ? ' ' : baseToString(chars); + + var charsLength = chars.length; + if (charsLength < 2) { + return charsLength ? baseRepeat(chars, length) : chars; + } + var result = baseRepeat(chars, nativeCeil(length / stringSize(chars))); + return hasUnicode(chars) + ? castSlice(stringToArray(result), 0, length).join('') + : result.slice(0, length); + } + + /** + * Creates a function that wraps `func` to invoke it with the `this` binding + * of `thisArg` and `partials` prepended to the arguments it receives. + * + * @private + * @param {Function} func The function to wrap. + * @param {number} bitmask The bitmask flags. See `createWrap` for more details. + * @param {*} thisArg The `this` binding of `func`. + * @param {Array} partials The arguments to prepend to those provided to + * the new function. + * @returns {Function} Returns the new wrapped function. + */ + function createPartial(func, bitmask, thisArg, partials) { + var isBind = bitmask & WRAP_BIND_FLAG, + Ctor = createCtor(func); + + function wrapper() { + var argsIndex = -1, + argsLength = arguments.length, + leftIndex = -1, + leftLength = partials.length, + args = Array(leftLength + argsLength), + fn = (this && this !== root && this instanceof wrapper) ? Ctor : func; + + while (++leftIndex < leftLength) { + args[leftIndex] = partials[leftIndex]; + } + while (argsLength--) { + args[leftIndex++] = arguments[++argsIndex]; + } + return apply(fn, isBind ? thisArg : this, args); + } + return wrapper; + } + + /** + * Creates a `_.range` or `_.rangeRight` function. + * + * @private + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Function} Returns the new range function. + */ + function createRange(fromRight) { + return function(start, end, step) { + if (step && typeof step != 'number' && isIterateeCall(start, end, step)) { + end = step = undefined; + } + // Ensure the sign of `-0` is preserved. + start = toFinite(start); + if (end === undefined) { + end = start; + start = 0; + } else { + end = toFinite(end); + } + step = step === undefined ? (start < end ? 1 : -1) : toFinite(step); + return baseRange(start, end, step, fromRight); + }; + } + + /** + * Creates a function that performs a relational operation on two values. + * + * @private + * @param {Function} operator The function to perform the operation. + * @returns {Function} Returns the new relational operation function. + */ + function createRelationalOperation(operator) { + return function(value, other) { + if (!(typeof value == 'string' && typeof other == 'string')) { + value = toNumber(value); + other = toNumber(other); + } + return operator(value, other); + }; + } + + /** + * Creates a function that wraps `func` to continue currying. + * + * @private + * @param {Function} func The function to wrap. + * @param {number} bitmask The bitmask flags. See `createWrap` for more details. + * @param {Function} wrapFunc The function to create the `func` wrapper. + * @param {*} placeholder The placeholder value. + * @param {*} [thisArg] The `this` binding of `func`. + * @param {Array} [partials] The arguments to prepend to those provided to + * the new function. + * @param {Array} [holders] The `partials` placeholder indexes. + * @param {Array} [argPos] The argument positions of the new function. + * @param {number} [ary] The arity cap of `func`. + * @param {number} [arity] The arity of `func`. + * @returns {Function} Returns the new wrapped function. + */ + function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) { + var isCurry = bitmask & WRAP_CURRY_FLAG, + newHolders = isCurry ? holders : undefined, + newHoldersRight = isCurry ? undefined : holders, + newPartials = isCurry ? partials : undefined, + newPartialsRight = isCurry ? undefined : partials; + + bitmask |= (isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG); + bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG); + + if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) { + bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG); + } + var newData = [ + func, bitmask, thisArg, newPartials, newHolders, newPartialsRight, + newHoldersRight, argPos, ary, arity + ]; + + var result = wrapFunc.apply(undefined, newData); + if (isLaziable(func)) { + setData(result, newData); + } + result.placeholder = placeholder; + return setWrapToString(result, func, bitmask); + } + + /** + * Creates a function like `_.round`. + * + * @private + * @param {string} methodName The name of the `Math` method to use when rounding. + * @returns {Function} Returns the new round function. + */ + function createRound(methodName) { + var func = Math[methodName]; + return function(number, precision) { + number = toNumber(number); + precision = precision == null ? 0 : nativeMin(toInteger(precision), 292); + if (precision && nativeIsFinite(number)) { + // Shift with exponential notation to avoid floating-point issues. + // See [MDN](https://mdn.io/round#Examples) for more details. + var pair = (toString(number) + 'e').split('e'), + value = func(pair[0] + 'e' + (+pair[1] + precision)); + + pair = (toString(value) + 'e').split('e'); + return +(pair[0] + 'e' + (+pair[1] - precision)); + } + return func(number); + }; + } + + /** + * Creates a set object of `values`. + * + * @private + * @param {Array} values The values to add to the set. + * @returns {Object} Returns the new set. + */ + var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) { + return new Set(values); + }; + + /** + * Creates a `_.toPairs` or `_.toPairsIn` function. + * + * @private + * @param {Function} keysFunc The function to get the keys of a given object. + * @returns {Function} Returns the new pairs function. + */ + function createToPairs(keysFunc) { + return function(object) { + var tag = getTag(object); + if (tag == mapTag) { + return mapToArray(object); + } + if (tag == setTag) { + return setToPairs(object); + } + return baseToPairs(object, keysFunc(object)); + }; + } + + /** + * Creates a function that either curries or invokes `func` with optional + * `this` binding and partially applied arguments. + * + * @private + * @param {Function|string} func The function or method name to wrap. + * @param {number} bitmask The bitmask flags. + * 1 - `_.bind` + * 2 - `_.bindKey` + * 4 - `_.curry` or `_.curryRight` of a bound function + * 8 - `_.curry` + * 16 - `_.curryRight` + * 32 - `_.partial` + * 64 - `_.partialRight` + * 128 - `_.rearg` + * 256 - `_.ary` + * 512 - `_.flip` + * @param {*} [thisArg] The `this` binding of `func`. + * @param {Array} [partials] The arguments to be partially applied. + * @param {Array} [holders] The `partials` placeholder indexes. + * @param {Array} [argPos] The argument positions of the new function. + * @param {number} [ary] The arity cap of `func`. + * @param {number} [arity] The arity of `func`. + * @returns {Function} Returns the new wrapped function. + */ + function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) { + var isBindKey = bitmask & WRAP_BIND_KEY_FLAG; + if (!isBindKey && typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + var length = partials ? partials.length : 0; + if (!length) { + bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG); + partials = holders = undefined; + } + ary = ary === undefined ? ary : nativeMax(toInteger(ary), 0); + arity = arity === undefined ? arity : toInteger(arity); + length -= holders ? holders.length : 0; + + if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) { + var partialsRight = partials, + holdersRight = holders; + + partials = holders = undefined; + } + var data = isBindKey ? undefined : getData(func); + + var newData = [ + func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, + argPos, ary, arity + ]; + + if (data) { + mergeData(newData, data); + } + func = newData[0]; + bitmask = newData[1]; + thisArg = newData[2]; + partials = newData[3]; + holders = newData[4]; + arity = newData[9] = newData[9] === undefined + ? (isBindKey ? 0 : func.length) + : nativeMax(newData[9] - length, 0); + + if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) { + bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG); + } + if (!bitmask || bitmask == WRAP_BIND_FLAG) { + var result = createBind(func, bitmask, thisArg); + } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) { + result = createCurry(func, bitmask, arity); + } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) { + result = createPartial(func, bitmask, thisArg, partials); + } else { + result = createHybrid.apply(undefined, newData); + } + var setter = data ? baseSetData : setData; + return setWrapToString(setter(result, newData), func, bitmask); + } + + /** + * Used by `_.defaults` to customize its `_.assignIn` use to assign properties + * of source objects to the destination object for all destination properties + * that resolve to `undefined`. + * + * @private + * @param {*} objValue The destination value. + * @param {*} srcValue The source value. + * @param {string} key The key of the property to assign. + * @param {Object} object The parent object of `objValue`. + * @returns {*} Returns the value to assign. + */ + function customDefaultsAssignIn(objValue, srcValue, key, object) { + if (objValue === undefined || + (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) { + return srcValue; + } + return objValue; + } + + /** + * Used by `_.defaultsDeep` to customize its `_.merge` use to merge source + * objects into destination objects that are passed thru. + * + * @private + * @param {*} objValue The destination value. + * @param {*} srcValue The source value. + * @param {string} key The key of the property to merge. + * @param {Object} object The parent object of `objValue`. + * @param {Object} source The parent object of `srcValue`. + * @param {Object} [stack] Tracks traversed source values and their merged + * counterparts. + * @returns {*} Returns the value to assign. + */ + function customDefaultsMerge(objValue, srcValue, key, object, source, stack) { + if (isObject(objValue) && isObject(srcValue)) { + // Recursively merge objects and arrays (susceptible to call stack limits). + stack.set(srcValue, objValue); + baseMerge(objValue, srcValue, undefined, customDefaultsMerge, stack); + stack['delete'](srcValue); + } + return objValue; + } + + /** + * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain + * objects. + * + * @private + * @param {*} value The value to inspect. + * @param {string} key The key of the property to inspect. + * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`. + */ + function customOmitClone(value) { + return isPlainObject(value) ? undefined : value; + } + + /** + * A specialized version of `baseIsEqualDeep` for arrays with support for + * partial deep comparisons. + * + * @private + * @param {Array} array The array to compare. + * @param {Array} other The other array to compare. + * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} stack Tracks traversed `array` and `other` objects. + * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`. + */ + function equalArrays(array, other, bitmask, customizer, equalFunc, stack) { + var isPartial = bitmask & COMPARE_PARTIAL_FLAG, + arrLength = array.length, + othLength = other.length; + + if (arrLength != othLength && !(isPartial && othLength > arrLength)) { + return false; + } + // Check that cyclic values are equal. + var arrStacked = stack.get(array); + var othStacked = stack.get(other); + if (arrStacked && othStacked) { + return arrStacked == other && othStacked == array; + } + var index = -1, + result = true, + seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined; + + stack.set(array, other); + stack.set(other, array); + + // Ignore non-index properties. + while (++index < arrLength) { + var arrValue = array[index], + othValue = other[index]; + + if (customizer) { + var compared = isPartial + ? customizer(othValue, arrValue, index, other, array, stack) + : customizer(arrValue, othValue, index, array, other, stack); + } + if (compared !== undefined) { + if (compared) { + continue; + } + result = false; + break; + } + // Recursively compare arrays (susceptible to call stack limits). + if (seen) { + if (!arraySome(other, function(othValue, othIndex) { + if (!cacheHas(seen, othIndex) && + (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) { + return seen.push(othIndex); + } + })) { + result = false; + break; + } + } else if (!( + arrValue === othValue || + equalFunc(arrValue, othValue, bitmask, customizer, stack) + )) { + result = false; + break; + } + } + stack['delete'](array); + stack['delete'](other); + return result; + } + + /** + * A specialized version of `baseIsEqualDeep` for comparing objects of + * the same `toStringTag`. + * + * **Note:** This function only supports comparing values with tags of + * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {string} tag The `toStringTag` of the objects to compare. + * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} stack Tracks traversed `object` and `other` objects. + * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. + */ + function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) { + switch (tag) { + case dataViewTag: + if ((object.byteLength != other.byteLength) || + (object.byteOffset != other.byteOffset)) { + return false; + } + object = object.buffer; + other = other.buffer; + + case arrayBufferTag: + if ((object.byteLength != other.byteLength) || + !equalFunc(new Uint8Array(object), new Uint8Array(other))) { + return false; + } + return true; + + case boolTag: + case dateTag: + case numberTag: + // Coerce booleans to `1` or `0` and dates to milliseconds. + // Invalid dates are coerced to `NaN`. + return eq(+object, +other); + + case errorTag: + return object.name == other.name && object.message == other.message; + + case regexpTag: + case stringTag: + // Coerce regexes to strings and treat strings, primitives and objects, + // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring + // for more details. + return object == (other + ''); + + case mapTag: + var convert = mapToArray; + + case setTag: + var isPartial = bitmask & COMPARE_PARTIAL_FLAG; + convert || (convert = setToArray); + + if (object.size != other.size && !isPartial) { + return false; + } + // Assume cyclic values are equal. + var stacked = stack.get(object); + if (stacked) { + return stacked == other; + } + bitmask |= COMPARE_UNORDERED_FLAG; + + // Recursively compare objects (susceptible to call stack limits). + stack.set(object, other); + var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack); + stack['delete'](object); + return result; + + case symbolTag: + if (symbolValueOf) { + return symbolValueOf.call(object) == symbolValueOf.call(other); + } + } + return false; + } + + /** + * A specialized version of `baseIsEqualDeep` for objects with support for + * partial deep comparisons. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} stack Tracks traversed `object` and `other` objects. + * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. + */ + function equalObjects(object, other, bitmask, customizer, equalFunc, stack) { + var isPartial = bitmask & COMPARE_PARTIAL_FLAG, + objProps = getAllKeys(object), + objLength = objProps.length, + othProps = getAllKeys(other), + othLength = othProps.length; + + if (objLength != othLength && !isPartial) { + return false; + } + var index = objLength; + while (index--) { + var key = objProps[index]; + if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) { + return false; + } + } + // Check that cyclic values are equal. + var objStacked = stack.get(object); + var othStacked = stack.get(other); + if (objStacked && othStacked) { + return objStacked == other && othStacked == object; + } + var result = true; + stack.set(object, other); + stack.set(other, object); + + var skipCtor = isPartial; + while (++index < objLength) { + key = objProps[index]; + var objValue = object[key], + othValue = other[key]; + + if (customizer) { + var compared = isPartial + ? customizer(othValue, objValue, key, other, object, stack) + : customizer(objValue, othValue, key, object, other, stack); + } + // Recursively compare objects (susceptible to call stack limits). + if (!(compared === undefined + ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack)) + : compared + )) { + result = false; + break; + } + skipCtor || (skipCtor = key == 'constructor'); + } + if (result && !skipCtor) { + var objCtor = object.constructor, + othCtor = other.constructor; + + // Non `Object` object instances with different constructors are not equal. + if (objCtor != othCtor && + ('constructor' in object && 'constructor' in other) && + !(typeof objCtor == 'function' && objCtor instanceof objCtor && + typeof othCtor == 'function' && othCtor instanceof othCtor)) { + result = false; + } + } + stack['delete'](object); + stack['delete'](other); + return result; + } + + /** + * A specialized version of `baseRest` which flattens the rest array. + * + * @private + * @param {Function} func The function to apply a rest parameter to. + * @returns {Function} Returns the new function. + */ + function flatRest(func) { + return setToString(overRest(func, undefined, flatten), func + ''); + } + + /** + * Creates an array of own enumerable property names and symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names and symbols. + */ + function getAllKeys(object) { + return baseGetAllKeys(object, keys, getSymbols); + } + + /** + * Creates an array of own and inherited enumerable property names and + * symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names and symbols. + */ + function getAllKeysIn(object) { + return baseGetAllKeys(object, keysIn, getSymbolsIn); + } + + /** + * Gets metadata for `func`. + * + * @private + * @param {Function} func The function to query. + * @returns {*} Returns the metadata for `func`. + */ + var getData = !metaMap ? noop : function(func) { + return metaMap.get(func); + }; + + /** + * Gets the name of `func`. + * + * @private + * @param {Function} func The function to query. + * @returns {string} Returns the function name. + */ + function getFuncName(func) { + var result = (func.name + ''), + array = realNames[result], + length = hasOwnProperty.call(realNames, result) ? array.length : 0; + + while (length--) { + var data = array[length], + otherFunc = data.func; + if (otherFunc == null || otherFunc == func) { + return data.name; + } + } + return result; + } + + /** + * Gets the argument placeholder value for `func`. + * + * @private + * @param {Function} func The function to inspect. + * @returns {*} Returns the placeholder value. + */ + function getHolder(func) { + var object = hasOwnProperty.call(lodash, 'placeholder') ? lodash : func; + return object.placeholder; + } + + /** + * Gets the appropriate "iteratee" function. If `_.iteratee` is customized, + * this function returns the custom method, otherwise it returns `baseIteratee`. + * If arguments are provided, the chosen function is invoked with them and + * its result is returned. + * + * @private + * @param {*} [value] The value to convert to an iteratee. + * @param {number} [arity] The arity of the created iteratee. + * @returns {Function} Returns the chosen function or its result. + */ + function getIteratee() { + var result = lodash.iteratee || iteratee; + result = result === iteratee ? baseIteratee : result; + return arguments.length ? result(arguments[0], arguments[1]) : result; + } + + /** + * Gets the data for `map`. + * + * @private + * @param {Object} map The map to query. + * @param {string} key The reference key. + * @returns {*} Returns the map data. + */ + function getMapData(map, key) { + var data = map.__data__; + return isKeyable(key) + ? data[typeof key == 'string' ? 'string' : 'hash'] + : data.map; + } + + /** + * Gets the property names, values, and compare flags of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the match data of `object`. + */ + function getMatchData(object) { + var result = keys(object), + length = result.length; + + while (length--) { + var key = result[length], + value = object[key]; + + result[length] = [key, value, isStrictComparable(value)]; + } + return result; + } + + /** + * Gets the native function at `key` of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {string} key The key of the method to get. + * @returns {*} Returns the function if it's native, else `undefined`. + */ + function getNative(object, key) { + var value = getValue(object, key); + return baseIsNative(value) ? value : undefined; + } + + /** + * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the raw `toStringTag`. + */ + function getRawTag(value) { + var isOwn = hasOwnProperty.call(value, symToStringTag), + tag = value[symToStringTag]; + + try { + value[symToStringTag] = undefined; + var unmasked = true; + } catch (e) {} + + var result = nativeObjectToString.call(value); + if (unmasked) { + if (isOwn) { + value[symToStringTag] = tag; + } else { + delete value[symToStringTag]; + } + } + return result; + } + + /** + * Creates an array of the own enumerable symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of symbols. + */ + var getSymbols = !nativeGetSymbols ? stubArray : function(object) { + if (object == null) { + return []; + } + object = Object(object); + return arrayFilter(nativeGetSymbols(object), function(symbol) { + return propertyIsEnumerable.call(object, symbol); + }); + }; + + /** + * Creates an array of the own and inherited enumerable symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of symbols. + */ + var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) { + var result = []; + while (object) { + arrayPush(result, getSymbols(object)); + object = getPrototype(object); + } + return result; + }; + + /** + * Gets the `toStringTag` of `value`. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the `toStringTag`. + */ + var getTag = baseGetTag; + + // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6. + if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) || + (Map && getTag(new Map) != mapTag) || + (Promise && getTag(Promise.resolve()) != promiseTag) || + (Set && getTag(new Set) != setTag) || + (WeakMap && getTag(new WeakMap) != weakMapTag)) { + getTag = function(value) { + var result = baseGetTag(value), + Ctor = result == objectTag ? value.constructor : undefined, + ctorString = Ctor ? toSource(Ctor) : ''; + + if (ctorString) { + switch (ctorString) { + case dataViewCtorString: return dataViewTag; + case mapCtorString: return mapTag; + case promiseCtorString: return promiseTag; + case setCtorString: return setTag; + case weakMapCtorString: return weakMapTag; + } + } + return result; + }; + } + + /** + * Gets the view, applying any `transforms` to the `start` and `end` positions. + * + * @private + * @param {number} start The start of the view. + * @param {number} end The end of the view. + * @param {Array} transforms The transformations to apply to the view. + * @returns {Object} Returns an object containing the `start` and `end` + * positions of the view. + */ + function getView(start, end, transforms) { + var index = -1, + length = transforms.length; + + while (++index < length) { + var data = transforms[index], + size = data.size; + + switch (data.type) { + case 'drop': start += size; break; + case 'dropRight': end -= size; break; + case 'take': end = nativeMin(end, start + size); break; + case 'takeRight': start = nativeMax(start, end - size); break; + } + } + return { 'start': start, 'end': end }; + } + + /** + * Extracts wrapper details from the `source` body comment. + * + * @private + * @param {string} source The source to inspect. + * @returns {Array} Returns the wrapper details. + */ + function getWrapDetails(source) { + var match = source.match(reWrapDetails); + return match ? match[1].split(reSplitDetails) : []; + } + + /** + * Checks if `path` exists on `object`. + * + * @private + * @param {Object} object The object to query. + * @param {Array|string} path The path to check. + * @param {Function} hasFunc The function to check properties. + * @returns {boolean} Returns `true` if `path` exists, else `false`. + */ + function hasPath(object, path, hasFunc) { + path = castPath(path, object); + + var index = -1, + length = path.length, + result = false; + + while (++index < length) { + var key = toKey(path[index]); + if (!(result = object != null && hasFunc(object, key))) { + break; + } + object = object[key]; + } + if (result || ++index != length) { + return result; + } + length = object == null ? 0 : object.length; + return !!length && isLength(length) && isIndex(key, length) && + (isArray(object) || isArguments(object)); + } + + /** + * Initializes an array clone. + * + * @private + * @param {Array} array The array to clone. + * @returns {Array} Returns the initialized clone. + */ + function initCloneArray(array) { + var length = array.length, + result = new array.constructor(length); + + // Add properties assigned by `RegExp#exec`. + if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) { + result.index = array.index; + result.input = array.input; + } + return result; + } + + /** + * Initializes an object clone. + * + * @private + * @param {Object} object The object to clone. + * @returns {Object} Returns the initialized clone. + */ + function initCloneObject(object) { + return (typeof object.constructor == 'function' && !isPrototype(object)) + ? baseCreate(getPrototype(object)) + : {}; + } + + /** + * Initializes an object clone based on its `toStringTag`. + * + * **Note:** This function only supports cloning values with tags of + * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`. + * + * @private + * @param {Object} object The object to clone. + * @param {string} tag The `toStringTag` of the object to clone. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Object} Returns the initialized clone. + */ + function initCloneByTag(object, tag, isDeep) { + var Ctor = object.constructor; + switch (tag) { + case arrayBufferTag: + return cloneArrayBuffer(object); + + case boolTag: + case dateTag: + return new Ctor(+object); + + case dataViewTag: + return cloneDataView(object, isDeep); + + case float32Tag: case float64Tag: + case int8Tag: case int16Tag: case int32Tag: + case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag: + return cloneTypedArray(object, isDeep); + + case mapTag: + return new Ctor; + + case numberTag: + case stringTag: + return new Ctor(object); + + case regexpTag: + return cloneRegExp(object); + + case setTag: + return new Ctor; + + case symbolTag: + return cloneSymbol(object); + } + } + + /** + * Inserts wrapper `details` in a comment at the top of the `source` body. + * + * @private + * @param {string} source The source to modify. + * @returns {Array} details The details to insert. + * @returns {string} Returns the modified source. + */ + function insertWrapDetails(source, details) { + var length = details.length; + if (!length) { + return source; + } + var lastIndex = length - 1; + details[lastIndex] = (length > 1 ? '& ' : '') + details[lastIndex]; + details = details.join(length > 2 ? ', ' : ' '); + return source.replace(reWrapComment, '{\n/* [wrapped with ' + details + '] */\n'); + } + + /** + * Checks if `value` is a flattenable `arguments` object or array. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is flattenable, else `false`. + */ + function isFlattenable(value) { + return isArray(value) || isArguments(value) || + !!(spreadableSymbol && value && value[spreadableSymbol]); + } + + /** + * Checks if `value` is a valid array-like index. + * + * @private + * @param {*} value The value to check. + * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. + * @returns {boolean} Returns `true` if `value` is a valid index, else `false`. + */ + function isIndex(value, length) { + var type = typeof value; + length = length == null ? MAX_SAFE_INTEGER : length; + + return !!length && + (type == 'number' || + (type != 'symbol' && reIsUint.test(value))) && + (value > -1 && value % 1 == 0 && value < length); + } + + /** + * Checks if the given arguments are from an iteratee call. + * + * @private + * @param {*} value The potential iteratee value argument. + * @param {*} index The potential iteratee index or key argument. + * @param {*} object The potential iteratee object argument. + * @returns {boolean} Returns `true` if the arguments are from an iteratee call, + * else `false`. + */ + function isIterateeCall(value, index, object) { + if (!isObject(object)) { + return false; + } + var type = typeof index; + if (type == 'number' + ? (isArrayLike(object) && isIndex(index, object.length)) + : (type == 'string' && index in object) + ) { + return eq(object[index], value); + } + return false; + } + + /** + * Checks if `value` is a property name and not a property path. + * + * @private + * @param {*} value The value to check. + * @param {Object} [object] The object to query keys on. + * @returns {boolean} Returns `true` if `value` is a property name, else `false`. + */ + function isKey(value, object) { + if (isArray(value)) { + return false; + } + var type = typeof value; + if (type == 'number' || type == 'symbol' || type == 'boolean' || + value == null || isSymbol(value)) { + return true; + } + return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || + (object != null && value in Object(object)); + } + + /** + * Checks if `value` is suitable for use as unique object key. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is suitable, else `false`. + */ + function isKeyable(value) { + var type = typeof value; + return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean') + ? (value !== '__proto__') + : (value === null); + } + + /** + * Checks if `func` has a lazy counterpart. + * + * @private + * @param {Function} func The function to check. + * @returns {boolean} Returns `true` if `func` has a lazy counterpart, + * else `false`. + */ + function isLaziable(func) { + var funcName = getFuncName(func), + other = lodash[funcName]; + + if (typeof other != 'function' || !(funcName in LazyWrapper.prototype)) { + return false; + } + if (func === other) { + return true; + } + var data = getData(other); + return !!data && func === data[0]; + } + + /** + * Checks if `func` has its source masked. + * + * @private + * @param {Function} func The function to check. + * @returns {boolean} Returns `true` if `func` is masked, else `false`. + */ + function isMasked(func) { + return !!maskSrcKey && (maskSrcKey in func); + } + + /** + * Checks if `func` is capable of being masked. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `func` is maskable, else `false`. + */ + var isMaskable = coreJsData ? isFunction : stubFalse; + + /** + * Checks if `value` is likely a prototype object. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a prototype, else `false`. + */ + function isPrototype(value) { + var Ctor = value && value.constructor, + proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto; + + return value === proto; + } + + /** + * Checks if `value` is suitable for strict equality comparisons, i.e. `===`. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` if suitable for strict + * equality comparisons, else `false`. + */ + function isStrictComparable(value) { + return value === value && !isObject(value); + } + + /** + * A specialized version of `matchesProperty` for source values suitable + * for strict equality comparisons, i.e. `===`. + * + * @private + * @param {string} key The key of the property to get. + * @param {*} srcValue The value to match. + * @returns {Function} Returns the new spec function. + */ + function matchesStrictComparable(key, srcValue) { + return function(object) { + if (object == null) { + return false; + } + return object[key] === srcValue && + (srcValue !== undefined || (key in Object(object))); + }; + } + + /** + * A specialized version of `_.memoize` which clears the memoized function's + * cache when it exceeds `MAX_MEMOIZE_SIZE`. + * + * @private + * @param {Function} func The function to have its output memoized. + * @returns {Function} Returns the new memoized function. + */ + function memoizeCapped(func) { + var result = memoize(func, function(key) { + if (cache.size === MAX_MEMOIZE_SIZE) { + cache.clear(); + } + return key; + }); + + var cache = result.cache; + return result; + } + + /** + * Merges the function metadata of `source` into `data`. + * + * Merging metadata reduces the number of wrappers used to invoke a function. + * This is possible because methods like `_.bind`, `_.curry`, and `_.partial` + * may be applied regardless of execution order. Methods like `_.ary` and + * `_.rearg` modify function arguments, making the order in which they are + * executed important, preventing the merging of metadata. However, we make + * an exception for a safe combined case where curried functions have `_.ary` + * and or `_.rearg` applied. + * + * @private + * @param {Array} data The destination metadata. + * @param {Array} source The source metadata. + * @returns {Array} Returns `data`. + */ + function mergeData(data, source) { + var bitmask = data[1], + srcBitmask = source[1], + newBitmask = bitmask | srcBitmask, + isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG); + + var isCombo = + ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_CURRY_FLAG)) || + ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_REARG_FLAG) && (data[7].length <= source[8])) || + ((srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == WRAP_CURRY_FLAG)); + + // Exit early if metadata can't be merged. + if (!(isCommon || isCombo)) { + return data; + } + // Use source `thisArg` if available. + if (srcBitmask & WRAP_BIND_FLAG) { + data[2] = source[2]; + // Set when currying a bound function. + newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG; + } + // Compose partial arguments. + var value = source[3]; + if (value) { + var partials = data[3]; + data[3] = partials ? composeArgs(partials, value, source[4]) : value; + data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4]; + } + // Compose partial right arguments. + value = source[5]; + if (value) { + partials = data[5]; + data[5] = partials ? composeArgsRight(partials, value, source[6]) : value; + data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6]; + } + // Use source `argPos` if available. + value = source[7]; + if (value) { + data[7] = value; + } + // Use source `ary` if it's smaller. + if (srcBitmask & WRAP_ARY_FLAG) { + data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]); + } + // Use source `arity` if one is not provided. + if (data[9] == null) { + data[9] = source[9]; + } + // Use source `func` and merge bitmasks. + data[0] = source[0]; + data[1] = newBitmask; + + return data; + } + + /** + * This function is like + * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) + * except that it includes inherited enumerable properties. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + */ + function nativeKeysIn(object) { + var result = []; + if (object != null) { + for (var key in Object(object)) { + result.push(key); + } + } + return result; + } + + /** + * Converts `value` to a string using `Object.prototype.toString`. + * + * @private + * @param {*} value The value to convert. + * @returns {string} Returns the converted string. + */ + function objectToString(value) { + return nativeObjectToString.call(value); + } + + /** + * A specialized version of `baseRest` which transforms the rest array. + * + * @private + * @param {Function} func The function to apply a rest parameter to. + * @param {number} [start=func.length-1] The start position of the rest parameter. + * @param {Function} transform The rest array transform. + * @returns {Function} Returns the new function. + */ + function overRest(func, start, transform) { + start = nativeMax(start === undefined ? (func.length - 1) : start, 0); + return function() { + var args = arguments, + index = -1, + length = nativeMax(args.length - start, 0), + array = Array(length); + + while (++index < length) { + array[index] = args[start + index]; + } + index = -1; + var otherArgs = Array(start + 1); + while (++index < start) { + otherArgs[index] = args[index]; + } + otherArgs[start] = transform(array); + return apply(func, this, otherArgs); + }; + } + + /** + * Gets the parent value at `path` of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {Array} path The path to get the parent value of. + * @returns {*} Returns the parent value. + */ + function parent(object, path) { + return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1)); + } + + /** + * Reorder `array` according to the specified indexes where the element at + * the first index is assigned as the first element, the element at + * the second index is assigned as the second element, and so on. + * + * @private + * @param {Array} array The array to reorder. + * @param {Array} indexes The arranged array indexes. + * @returns {Array} Returns `array`. + */ + function reorder(array, indexes) { + var arrLength = array.length, + length = nativeMin(indexes.length, arrLength), + oldArray = copyArray(array); + + while (length--) { + var index = indexes[length]; + array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined; + } + return array; + } + + /** + * Gets the value at `key`, unless `key` is "__proto__" or "constructor". + * + * @private + * @param {Object} object The object to query. + * @param {string} key The key of the property to get. + * @returns {*} Returns the property value. + */ + function safeGet(object, key) { + if (key === 'constructor' && typeof object[key] === 'function') { + return; + } + + if (key == '__proto__') { + return; + } + + return object[key]; + } + + /** + * Sets metadata for `func`. + * + * **Note:** If this function becomes hot, i.e. is invoked a lot in a short + * period of time, it will trip its breaker and transition to an identity + * function to avoid garbage collection pauses in V8. See + * [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070) + * for more details. + * + * @private + * @param {Function} func The function to associate metadata with. + * @param {*} data The metadata. + * @returns {Function} Returns `func`. + */ + var setData = shortOut(baseSetData); + + /** + * A simple wrapper around the global [`setTimeout`](https://mdn.io/setTimeout). + * + * @private + * @param {Function} func The function to delay. + * @param {number} wait The number of milliseconds to delay invocation. + * @returns {number|Object} Returns the timer id or timeout object. + */ + var setTimeout = ctxSetTimeout || function(func, wait) { + return root.setTimeout(func, wait); + }; + + /** + * Sets the `toString` method of `func` to return `string`. + * + * @private + * @param {Function} func The function to modify. + * @param {Function} string The `toString` result. + * @returns {Function} Returns `func`. + */ + var setToString = shortOut(baseSetToString); + + /** + * Sets the `toString` method of `wrapper` to mimic the source of `reference` + * with wrapper details in a comment at the top of the source body. + * + * @private + * @param {Function} wrapper The function to modify. + * @param {Function} reference The reference function. + * @param {number} bitmask The bitmask flags. See `createWrap` for more details. + * @returns {Function} Returns `wrapper`. + */ + function setWrapToString(wrapper, reference, bitmask) { + var source = (reference + ''); + return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask))); + } + + /** + * Creates a function that'll short out and invoke `identity` instead + * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN` + * milliseconds. + * + * @private + * @param {Function} func The function to restrict. + * @returns {Function} Returns the new shortable function. + */ + function shortOut(func) { + var count = 0, + lastCalled = 0; + + return function() { + var stamp = nativeNow(), + remaining = HOT_SPAN - (stamp - lastCalled); + + lastCalled = stamp; + if (remaining > 0) { + if (++count >= HOT_COUNT) { + return arguments[0]; + } + } else { + count = 0; + } + return func.apply(undefined, arguments); + }; + } + + /** + * A specialized version of `_.shuffle` which mutates and sets the size of `array`. + * + * @private + * @param {Array} array The array to shuffle. + * @param {number} [size=array.length] The size of `array`. + * @returns {Array} Returns `array`. + */ + function shuffleSelf(array, size) { + var index = -1, + length = array.length, + lastIndex = length - 1; + + size = size === undefined ? length : size; + while (++index < size) { + var rand = baseRandom(index, lastIndex), + value = array[rand]; + + array[rand] = array[index]; + array[index] = value; + } + array.length = size; + return array; + } + + /** + * Converts `string` to a property path array. + * + * @private + * @param {string} string The string to convert. + * @returns {Array} Returns the property path array. + */ + var stringToPath = memoizeCapped(function(string) { + var result = []; + if (string.charCodeAt(0) === 46 /* . */) { + result.push(''); + } + string.replace(rePropName, function(match, number, quote, subString) { + result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match)); + }); + return result; + }); + + /** + * Converts `value` to a string key if it's not a string or symbol. + * + * @private + * @param {*} value The value to inspect. + * @returns {string|symbol} Returns the key. + */ + function toKey(value) { + if (typeof value == 'string' || isSymbol(value)) { + return value; + } + var result = (value + ''); + return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; + } + + /** + * Converts `func` to its source code. + * + * @private + * @param {Function} func The function to convert. + * @returns {string} Returns the source code. + */ + function toSource(func) { + if (func != null) { + try { + return funcToString.call(func); + } catch (e) {} + try { + return (func + ''); + } catch (e) {} + } + return ''; + } + + /** + * Updates wrapper `details` based on `bitmask` flags. + * + * @private + * @returns {Array} details The details to modify. + * @param {number} bitmask The bitmask flags. See `createWrap` for more details. + * @returns {Array} Returns `details`. + */ + function updateWrapDetails(details, bitmask) { + arrayEach(wrapFlags, function(pair) { + var value = '_.' + pair[0]; + if ((bitmask & pair[1]) && !arrayIncludes(details, value)) { + details.push(value); + } + }); + return details.sort(); + } + + /** + * Creates a clone of `wrapper`. + * + * @private + * @param {Object} wrapper The wrapper to clone. + * @returns {Object} Returns the cloned wrapper. + */ + function wrapperClone(wrapper) { + if (wrapper instanceof LazyWrapper) { + return wrapper.clone(); + } + var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__); + result.__actions__ = copyArray(wrapper.__actions__); + result.__index__ = wrapper.__index__; + result.__values__ = wrapper.__values__; + return result; + } + + /*------------------------------------------------------------------------*/ + + /** + * Creates an array of elements split into groups the length of `size`. + * If `array` can't be split evenly, the final chunk will be the remaining + * elements. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to process. + * @param {number} [size=1] The length of each chunk + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the new array of chunks. + * @example + * + * _.chunk(['a', 'b', 'c', 'd'], 2); + * // => [['a', 'b'], ['c', 'd']] + * + * _.chunk(['a', 'b', 'c', 'd'], 3); + * // => [['a', 'b', 'c'], ['d']] + */ + function chunk(array, size, guard) { + if ((guard ? isIterateeCall(array, size, guard) : size === undefined)) { + size = 1; + } else { + size = nativeMax(toInteger(size), 0); + } + var length = array == null ? 0 : array.length; + if (!length || size < 1) { + return []; + } + var index = 0, + resIndex = 0, + result = Array(nativeCeil(length / size)); + + while (index < length) { + result[resIndex++] = baseSlice(array, index, (index += size)); + } + return result; + } + + /** + * Creates an array with all falsey values removed. The values `false`, `null`, + * `0`, `""`, `undefined`, and `NaN` are falsey. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to compact. + * @returns {Array} Returns the new array of filtered values. + * @example + * + * _.compact([0, 1, false, 2, '', 3]); + * // => [1, 2, 3] + */ + function compact(array) { + var index = -1, + length = array == null ? 0 : array.length, + resIndex = 0, + result = []; + + while (++index < length) { + var value = array[index]; + if (value) { + result[resIndex++] = value; + } + } + return result; + } + + /** + * Creates a new array concatenating `array` with any additional arrays + * and/or values. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to concatenate. + * @param {...*} [values] The values to concatenate. + * @returns {Array} Returns the new concatenated array. + * @example + * + * var array = [1]; + * var other = _.concat(array, 2, [3], [[4]]); + * + * console.log(other); + * // => [1, 2, 3, [4]] + * + * console.log(array); + * // => [1] + */ + function concat() { + var length = arguments.length; + if (!length) { + return []; + } + var args = Array(length - 1), + array = arguments[0], + index = length; + + while (index--) { + args[index - 1] = arguments[index]; + } + return arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1)); + } + + /** + * Creates an array of `array` values not included in the other given arrays + * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. The order and references of result values are + * determined by the first array. + * + * **Note:** Unlike `_.pullAll`, this method returns a new array. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {...Array} [values] The values to exclude. + * @returns {Array} Returns the new array of filtered values. + * @see _.without, _.xor + * @example + * + * _.difference([2, 1], [2, 3]); + * // => [1] + */ + var difference = baseRest(function(array, values) { + return isArrayLikeObject(array) + ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true)) + : []; + }); + + /** + * This method is like `_.difference` except that it accepts `iteratee` which + * is invoked for each element of `array` and `values` to generate the criterion + * by which they're compared. The order and references of result values are + * determined by the first array. The iteratee is invoked with one argument: + * (value). + * + * **Note:** Unlike `_.pullAllBy`, this method returns a new array. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {...Array} [values] The values to exclude. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns the new array of filtered values. + * @example + * + * _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor); + * // => [1.2] + * + * // The `_.property` iteratee shorthand. + * _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x'); + * // => [{ 'x': 2 }] + */ + var differenceBy = baseRest(function(array, values) { + var iteratee = last(values); + if (isArrayLikeObject(iteratee)) { + iteratee = undefined; + } + return isArrayLikeObject(array) + ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), getIteratee(iteratee, 2)) + : []; + }); + + /** + * This method is like `_.difference` except that it accepts `comparator` + * which is invoked to compare elements of `array` to `values`. The order and + * references of result values are determined by the first array. The comparator + * is invoked with two arguments: (arrVal, othVal). + * + * **Note:** Unlike `_.pullAllWith`, this method returns a new array. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {...Array} [values] The values to exclude. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of filtered values. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * + * _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual); + * // => [{ 'x': 2, 'y': 1 }] + */ + var differenceWith = baseRest(function(array, values) { + var comparator = last(values); + if (isArrayLikeObject(comparator)) { + comparator = undefined; + } + return isArrayLikeObject(array) + ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), undefined, comparator) + : []; + }); + + /** + * Creates a slice of `array` with `n` elements dropped from the beginning. + * + * @static + * @memberOf _ + * @since 0.5.0 + * @category Array + * @param {Array} array The array to query. + * @param {number} [n=1] The number of elements to drop. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.drop([1, 2, 3]); + * // => [2, 3] + * + * _.drop([1, 2, 3], 2); + * // => [3] + * + * _.drop([1, 2, 3], 5); + * // => [] + * + * _.drop([1, 2, 3], 0); + * // => [1, 2, 3] + */ + function drop(array, n, guard) { + var length = array == null ? 0 : array.length; + if (!length) { + return []; + } + n = (guard || n === undefined) ? 1 : toInteger(n); + return baseSlice(array, n < 0 ? 0 : n, length); + } + + /** + * Creates a slice of `array` with `n` elements dropped from the end. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {number} [n=1] The number of elements to drop. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.dropRight([1, 2, 3]); + * // => [1, 2] + * + * _.dropRight([1, 2, 3], 2); + * // => [1] + * + * _.dropRight([1, 2, 3], 5); + * // => [] + * + * _.dropRight([1, 2, 3], 0); + * // => [1, 2, 3] + */ + function dropRight(array, n, guard) { + var length = array == null ? 0 : array.length; + if (!length) { + return []; + } + n = (guard || n === undefined) ? 1 : toInteger(n); + n = length - n; + return baseSlice(array, 0, n < 0 ? 0 : n); + } + + /** + * Creates a slice of `array` excluding elements dropped from the end. + * Elements are dropped until `predicate` returns falsey. The predicate is + * invoked with three arguments: (value, index, array). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the slice of `array`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': true }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': false } + * ]; + * + * _.dropRightWhile(users, function(o) { return !o.active; }); + * // => objects for ['barney'] + * + * // The `_.matches` iteratee shorthand. + * _.dropRightWhile(users, { 'user': 'pebbles', 'active': false }); + * // => objects for ['barney', 'fred'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.dropRightWhile(users, ['active', false]); + * // => objects for ['barney'] + * + * // The `_.property` iteratee shorthand. + * _.dropRightWhile(users, 'active'); + * // => objects for ['barney', 'fred', 'pebbles'] + */ + function dropRightWhile(array, predicate) { + return (array && array.length) + ? baseWhile(array, getIteratee(predicate, 3), true, true) + : []; + } + + /** + * Creates a slice of `array` excluding elements dropped from the beginning. + * Elements are dropped until `predicate` returns falsey. The predicate is + * invoked with three arguments: (value, index, array). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the slice of `array`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': false }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': true } + * ]; + * + * _.dropWhile(users, function(o) { return !o.active; }); + * // => objects for ['pebbles'] + * + * // The `_.matches` iteratee shorthand. + * _.dropWhile(users, { 'user': 'barney', 'active': false }); + * // => objects for ['fred', 'pebbles'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.dropWhile(users, ['active', false]); + * // => objects for ['pebbles'] + * + * // The `_.property` iteratee shorthand. + * _.dropWhile(users, 'active'); + * // => objects for ['barney', 'fred', 'pebbles'] + */ + function dropWhile(array, predicate) { + return (array && array.length) + ? baseWhile(array, getIteratee(predicate, 3), true) + : []; + } + + /** + * Fills elements of `array` with `value` from `start` up to, but not + * including, `end`. + * + * **Note:** This method mutates `array`. + * + * @static + * @memberOf _ + * @since 3.2.0 + * @category Array + * @param {Array} array The array to fill. + * @param {*} value The value to fill `array` with. + * @param {number} [start=0] The start position. + * @param {number} [end=array.length] The end position. + * @returns {Array} Returns `array`. + * @example + * + * var array = [1, 2, 3]; + * + * _.fill(array, 'a'); + * console.log(array); + * // => ['a', 'a', 'a'] + * + * _.fill(Array(3), 2); + * // => [2, 2, 2] + * + * _.fill([4, 6, 8, 10], '*', 1, 3); + * // => [4, '*', '*', 10] + */ + function fill(array, value, start, end) { + var length = array == null ? 0 : array.length; + if (!length) { + return []; + } + if (start && typeof start != 'number' && isIterateeCall(array, value, start)) { + start = 0; + end = length; + } + return baseFill(array, value, start, end); + } + + /** + * This method is like `_.find` except that it returns the index of the first + * element `predicate` returns truthy for instead of the element itself. + * + * @static + * @memberOf _ + * @since 1.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param {number} [fromIndex=0] The index to search from. + * @returns {number} Returns the index of the found element, else `-1`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': false }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': true } + * ]; + * + * _.findIndex(users, function(o) { return o.user == 'barney'; }); + * // => 0 + * + * // The `_.matches` iteratee shorthand. + * _.findIndex(users, { 'user': 'fred', 'active': false }); + * // => 1 + * + * // The `_.matchesProperty` iteratee shorthand. + * _.findIndex(users, ['active', false]); + * // => 0 + * + * // The `_.property` iteratee shorthand. + * _.findIndex(users, 'active'); + * // => 2 + */ + function findIndex(array, predicate, fromIndex) { + var length = array == null ? 0 : array.length; + if (!length) { + return -1; + } + var index = fromIndex == null ? 0 : toInteger(fromIndex); + if (index < 0) { + index = nativeMax(length + index, 0); + } + return baseFindIndex(array, getIteratee(predicate, 3), index); + } + + /** + * This method is like `_.findIndex` except that it iterates over elements + * of `collection` from right to left. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param {number} [fromIndex=array.length-1] The index to search from. + * @returns {number} Returns the index of the found element, else `-1`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': true }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': false } + * ]; + * + * _.findLastIndex(users, function(o) { return o.user == 'pebbles'; }); + * // => 2 + * + * // The `_.matches` iteratee shorthand. + * _.findLastIndex(users, { 'user': 'barney', 'active': true }); + * // => 0 + * + * // The `_.matchesProperty` iteratee shorthand. + * _.findLastIndex(users, ['active', false]); + * // => 2 + * + * // The `_.property` iteratee shorthand. + * _.findLastIndex(users, 'active'); + * // => 0 + */ + function findLastIndex(array, predicate, fromIndex) { + var length = array == null ? 0 : array.length; + if (!length) { + return -1; + } + var index = length - 1; + if (fromIndex !== undefined) { + index = toInteger(fromIndex); + index = fromIndex < 0 + ? nativeMax(length + index, 0) + : nativeMin(index, length - 1); + } + return baseFindIndex(array, getIteratee(predicate, 3), index, true); + } + + /** + * Flattens `array` a single level deep. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to flatten. + * @returns {Array} Returns the new flattened array. + * @example + * + * _.flatten([1, [2, [3, [4]], 5]]); + * // => [1, 2, [3, [4]], 5] + */ + function flatten(array) { + var length = array == null ? 0 : array.length; + return length ? baseFlatten(array, 1) : []; + } + + /** + * Recursively flattens `array`. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to flatten. + * @returns {Array} Returns the new flattened array. + * @example + * + * _.flattenDeep([1, [2, [3, [4]], 5]]); + * // => [1, 2, 3, 4, 5] + */ + function flattenDeep(array) { + var length = array == null ? 0 : array.length; + return length ? baseFlatten(array, INFINITY) : []; + } + + /** + * Recursively flatten `array` up to `depth` times. + * + * @static + * @memberOf _ + * @since 4.4.0 + * @category Array + * @param {Array} array The array to flatten. + * @param {number} [depth=1] The maximum recursion depth. + * @returns {Array} Returns the new flattened array. + * @example + * + * var array = [1, [2, [3, [4]], 5]]; + * + * _.flattenDepth(array, 1); + * // => [1, 2, [3, [4]], 5] + * + * _.flattenDepth(array, 2); + * // => [1, 2, 3, [4], 5] + */ + function flattenDepth(array, depth) { + var length = array == null ? 0 : array.length; + if (!length) { + return []; + } + depth = depth === undefined ? 1 : toInteger(depth); + return baseFlatten(array, depth); + } + + /** + * The inverse of `_.toPairs`; this method returns an object composed + * from key-value `pairs`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} pairs The key-value pairs. + * @returns {Object} Returns the new object. + * @example + * + * _.fromPairs([['a', 1], ['b', 2]]); + * // => { 'a': 1, 'b': 2 } + */ + function fromPairs(pairs) { + var index = -1, + length = pairs == null ? 0 : pairs.length, + result = {}; + + while (++index < length) { + var pair = pairs[index]; + result[pair[0]] = pair[1]; + } + return result; + } + + /** + * Gets the first element of `array`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @alias first + * @category Array + * @param {Array} array The array to query. + * @returns {*} Returns the first element of `array`. + * @example + * + * _.head([1, 2, 3]); + * // => 1 + * + * _.head([]); + * // => undefined + */ + function head(array) { + return (array && array.length) ? array[0] : undefined; + } + + /** + * Gets the index at which the first occurrence of `value` is found in `array` + * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. If `fromIndex` is negative, it's used as the + * offset from the end of `array`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @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, else `-1`. + * @example + * + * _.indexOf([1, 2, 1, 2], 2); + * // => 1 + * + * // Search from the `fromIndex`. + * _.indexOf([1, 2, 1, 2], 2, 2); + * // => 3 + */ + function indexOf(array, value, fromIndex) { + var length = array == null ? 0 : array.length; + if (!length) { + return -1; + } + var index = fromIndex == null ? 0 : toInteger(fromIndex); + if (index < 0) { + index = nativeMax(length + index, 0); + } + return baseIndexOf(array, value, index); + } + + /** + * Gets all but the last element of `array`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to query. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.initial([1, 2, 3]); + * // => [1, 2] + */ + function initial(array) { + var length = array == null ? 0 : array.length; + return length ? baseSlice(array, 0, -1) : []; + } + + /** + * Creates an array of unique values that are included in all given arrays + * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. The order and references of result values are + * determined by the first array. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @returns {Array} Returns the new array of intersecting values. + * @example + * + * _.intersection([2, 1], [2, 3]); + * // => [2] + */ + var intersection = baseRest(function(arrays) { + var mapped = arrayMap(arrays, castArrayLikeObject); + return (mapped.length && mapped[0] === arrays[0]) + ? baseIntersection(mapped) + : []; + }); + + /** + * This method is like `_.intersection` except that it accepts `iteratee` + * which is invoked for each element of each `arrays` to generate the criterion + * by which they're compared. The order and references of result values are + * determined by the first array. The iteratee is invoked with one argument: + * (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns the new array of intersecting values. + * @example + * + * _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor); + * // => [2.1] + * + * // The `_.property` iteratee shorthand. + * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 1 }] + */ + var intersectionBy = baseRest(function(arrays) { + var iteratee = last(arrays), + mapped = arrayMap(arrays, castArrayLikeObject); + + if (iteratee === last(mapped)) { + iteratee = undefined; + } else { + mapped.pop(); + } + return (mapped.length && mapped[0] === arrays[0]) + ? baseIntersection(mapped, getIteratee(iteratee, 2)) + : []; + }); + + /** + * This method is like `_.intersection` except that it accepts `comparator` + * which is invoked to compare elements of `arrays`. The order and references + * of result values are determined by the first array. The comparator is + * invoked with two arguments: (arrVal, othVal). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of intersecting values. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * + * _.intersectionWith(objects, others, _.isEqual); + * // => [{ 'x': 1, 'y': 2 }] + */ + var intersectionWith = baseRest(function(arrays) { + var comparator = last(arrays), + mapped = arrayMap(arrays, castArrayLikeObject); + + comparator = typeof comparator == 'function' ? comparator : undefined; + if (comparator) { + mapped.pop(); + } + return (mapped.length && mapped[0] === arrays[0]) + ? baseIntersection(mapped, undefined, comparator) + : []; + }); + + /** + * Converts all elements in `array` into a string separated by `separator`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to convert. + * @param {string} [separator=','] The element separator. + * @returns {string} Returns the joined string. + * @example + * + * _.join(['a', 'b', 'c'], '~'); + * // => 'a~b~c' + */ + function join(array, separator) { + return array == null ? '' : nativeJoin.call(array, separator); + } + + /** + * Gets the last element of `array`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to query. + * @returns {*} Returns the last element of `array`. + * @example + * + * _.last([1, 2, 3]); + * // => 3 + */ + function last(array) { + var length = array == null ? 0 : array.length; + return length ? array[length - 1] : undefined; + } + + /** + * This method is like `_.indexOf` except that it iterates over elements of + * `array` from right to left. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @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, else `-1`. + * @example + * + * _.lastIndexOf([1, 2, 1, 2], 2); + * // => 3 + * + * // Search from the `fromIndex`. + * _.lastIndexOf([1, 2, 1, 2], 2, 2); + * // => 1 + */ + function lastIndexOf(array, value, fromIndex) { + var length = array == null ? 0 : array.length; + if (!length) { + return -1; + } + var index = length; + if (fromIndex !== undefined) { + index = toInteger(fromIndex); + index = index < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1); + } + return value === value + ? strictLastIndexOf(array, value, index) + : baseFindIndex(array, baseIsNaN, index, true); + } + + /** + * Gets the element at index `n` of `array`. If `n` is negative, the nth + * element from the end is returned. + * + * @static + * @memberOf _ + * @since 4.11.0 + * @category Array + * @param {Array} array The array to query. + * @param {number} [n=0] The index of the element to return. + * @returns {*} Returns the nth element of `array`. + * @example + * + * var array = ['a', 'b', 'c', 'd']; + * + * _.nth(array, 1); + * // => 'b' + * + * _.nth(array, -2); + * // => 'c'; + */ + function nth(array, n) { + return (array && array.length) ? baseNth(array, toInteger(n)) : undefined; + } + + /** + * Removes all given values from `array` using + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. + * + * **Note:** Unlike `_.without`, this method mutates `array`. Use `_.remove` + * to remove elements from an array by predicate. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Array + * @param {Array} array The array to modify. + * @param {...*} [values] The values to remove. + * @returns {Array} Returns `array`. + * @example + * + * var array = ['a', 'b', 'c', 'a', 'b', 'c']; + * + * _.pull(array, 'a', 'c'); + * console.log(array); + * // => ['b', 'b'] + */ + var pull = baseRest(pullAll); + + /** + * This method is like `_.pull` except that it accepts an array of values to remove. + * + * **Note:** Unlike `_.difference`, this method mutates `array`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to modify. + * @param {Array} values The values to remove. + * @returns {Array} Returns `array`. + * @example + * + * var array = ['a', 'b', 'c', 'a', 'b', 'c']; + * + * _.pullAll(array, ['a', 'c']); + * console.log(array); + * // => ['b', 'b'] + */ + function pullAll(array, values) { + return (array && array.length && values && values.length) + ? basePullAll(array, values) + : array; + } + + /** + * This method is like `_.pullAll` except that it accepts `iteratee` which is + * invoked for each element of `array` and `values` to generate the criterion + * by which they're compared. The iteratee is invoked with one argument: (value). + * + * **Note:** Unlike `_.differenceBy`, this method mutates `array`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to modify. + * @param {Array} values The values to remove. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns `array`. + * @example + * + * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }]; + * + * _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x'); + * console.log(array); + * // => [{ 'x': 2 }] + */ + function pullAllBy(array, values, iteratee) { + return (array && array.length && values && values.length) + ? basePullAll(array, values, getIteratee(iteratee, 2)) + : array; + } + + /** + * This method is like `_.pullAll` except that it accepts `comparator` which + * is invoked to compare elements of `array` to `values`. The comparator is + * invoked with two arguments: (arrVal, othVal). + * + * **Note:** Unlike `_.differenceWith`, this method mutates `array`. + * + * @static + * @memberOf _ + * @since 4.6.0 + * @category Array + * @param {Array} array The array to modify. + * @param {Array} values The values to remove. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns `array`. + * @example + * + * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }]; + * + * _.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual); + * console.log(array); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }] + */ + function pullAllWith(array, values, comparator) { + return (array && array.length && values && values.length) + ? basePullAll(array, values, undefined, comparator) + : array; + } + + /** + * Removes elements from `array` corresponding to `indexes` and returns an + * array of removed elements. + * + * **Note:** Unlike `_.at`, this method mutates `array`. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to modify. + * @param {...(number|number[])} [indexes] The indexes of elements to remove. + * @returns {Array} Returns the new array of removed elements. + * @example + * + * var array = ['a', 'b', 'c', 'd']; + * var pulled = _.pullAt(array, [1, 3]); + * + * console.log(array); + * // => ['a', 'c'] + * + * console.log(pulled); + * // => ['b', 'd'] + */ + var pullAt = flatRest(function(array, indexes) { + var length = array == null ? 0 : array.length, + result = baseAt(array, indexes); + + basePullAt(array, arrayMap(indexes, function(index) { + return isIndex(index, length) ? +index : index; + }).sort(compareAscending)); + + return result; + }); + + /** + * Removes all elements from `array` that `predicate` returns truthy for + * and returns an array of the removed elements. The predicate is invoked + * with three arguments: (value, index, array). + * + * **Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull` + * to pull elements from an array by value. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Array + * @param {Array} array The array to modify. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new array of removed elements. + * @example + * + * var array = [1, 2, 3, 4]; + * var evens = _.remove(array, function(n) { + * return n % 2 == 0; + * }); + * + * console.log(array); + * // => [1, 3] + * + * console.log(evens); + * // => [2, 4] + */ + function remove(array, predicate) { + var result = []; + if (!(array && array.length)) { + return result; + } + var index = -1, + indexes = [], + length = array.length; + + predicate = getIteratee(predicate, 3); + while (++index < length) { + var value = array[index]; + if (predicate(value, index, array)) { + result.push(value); + indexes.push(index); + } + } + basePullAt(array, indexes); + return result; + } + + /** + * Reverses `array` so that the first element becomes the last, the second + * element becomes the second to last, and so on. + * + * **Note:** This method mutates `array` and is based on + * [`Array#reverse`](https://mdn.io/Array/reverse). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to modify. + * @returns {Array} Returns `array`. + * @example + * + * var array = [1, 2, 3]; + * + * _.reverse(array); + * // => [3, 2, 1] + * + * console.log(array); + * // => [3, 2, 1] + */ + function reverse(array) { + return array == null ? array : nativeReverse.call(array); + } + + /** + * Creates a slice of `array` from `start` up to, but not including, `end`. + * + * **Note:** This method is used instead of + * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are + * returned. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to slice. + * @param {number} [start=0] The start position. + * @param {number} [end=array.length] The end position. + * @returns {Array} Returns the slice of `array`. + */ + function slice(array, start, end) { + var length = array == null ? 0 : array.length; + if (!length) { + return []; + } + if (end && typeof end != 'number' && isIterateeCall(array, start, end)) { + start = 0; + end = length; + } + else { + start = start == null ? 0 : toInteger(start); + end = end === undefined ? length : toInteger(end); + } + return baseSlice(array, start, end); + } + + /** + * Uses a binary search to determine the lowest index at which `value` + * should be inserted into `array` in order to maintain its sort order. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @returns {number} Returns the index at which `value` should be inserted + * into `array`. + * @example + * + * _.sortedIndex([30, 50], 40); + * // => 1 + */ + function sortedIndex(array, value) { + return baseSortedIndex(array, value); + } + + /** + * This method is like `_.sortedIndex` except that it accepts `iteratee` + * which is invoked for `value` and each element of `array` to compute their + * sort ranking. The iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {number} Returns the index at which `value` should be inserted + * into `array`. + * @example + * + * var objects = [{ 'x': 4 }, { 'x': 5 }]; + * + * _.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; }); + * // => 0 + * + * // The `_.property` iteratee shorthand. + * _.sortedIndexBy(objects, { 'x': 4 }, 'x'); + * // => 0 + */ + function sortedIndexBy(array, value, iteratee) { + return baseSortedIndexBy(array, value, getIteratee(iteratee, 2)); + } + + /** + * This method is like `_.indexOf` except that it performs a binary + * search on a sorted `array`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @returns {number} Returns the index of the matched value, else `-1`. + * @example + * + * _.sortedIndexOf([4, 5, 5, 5, 6], 5); + * // => 1 + */ + function sortedIndexOf(array, value) { + var length = array == null ? 0 : array.length; + if (length) { + var index = baseSortedIndex(array, value); + if (index < length && eq(array[index], value)) { + return index; + } + } + return -1; + } + + /** + * This method is like `_.sortedIndex` except that it returns the highest + * index at which `value` should be inserted into `array` in order to + * maintain its sort order. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @returns {number} Returns the index at which `value` should be inserted + * into `array`. + * @example + * + * _.sortedLastIndex([4, 5, 5, 5, 6], 5); + * // => 4 + */ + function sortedLastIndex(array, value) { + return baseSortedIndex(array, value, true); + } + + /** + * This method is like `_.sortedLastIndex` except that it accepts `iteratee` + * which is invoked for `value` and each element of `array` to compute their + * sort ranking. The iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {number} Returns the index at which `value` should be inserted + * into `array`. + * @example + * + * var objects = [{ 'x': 4 }, { 'x': 5 }]; + * + * _.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; }); + * // => 1 + * + * // The `_.property` iteratee shorthand. + * _.sortedLastIndexBy(objects, { 'x': 4 }, 'x'); + * // => 1 + */ + function sortedLastIndexBy(array, value, iteratee) { + return baseSortedIndexBy(array, value, getIteratee(iteratee, 2), true); + } + + /** + * This method is like `_.lastIndexOf` except that it performs a binary + * search on a sorted `array`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @returns {number} Returns the index of the matched value, else `-1`. + * @example + * + * _.sortedLastIndexOf([4, 5, 5, 5, 6], 5); + * // => 3 + */ + function sortedLastIndexOf(array, value) { + var length = array == null ? 0 : array.length; + if (length) { + var index = baseSortedIndex(array, value, true) - 1; + if (eq(array[index], value)) { + return index; + } + } + return -1; + } + + /** + * This method is like `_.uniq` except that it's designed and optimized + * for sorted arrays. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * _.sortedUniq([1, 1, 2]); + * // => [1, 2] + */ + function sortedUniq(array) { + return (array && array.length) + ? baseSortedUniq(array) + : []; + } + + /** + * This method is like `_.uniqBy` except that it's designed and optimized + * for sorted arrays. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {Function} [iteratee] The iteratee invoked per element. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor); + * // => [1.1, 2.3] + */ + function sortedUniqBy(array, iteratee) { + return (array && array.length) + ? baseSortedUniq(array, getIteratee(iteratee, 2)) + : []; + } + + /** + * Gets all but the first element of `array`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to query. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.tail([1, 2, 3]); + * // => [2, 3] + */ + function tail(array) { + var length = array == null ? 0 : array.length; + return length ? baseSlice(array, 1, length) : []; + } + + /** + * Creates a slice of `array` with `n` elements taken from the beginning. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to query. + * @param {number} [n=1] The number of elements to take. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.take([1, 2, 3]); + * // => [1] + * + * _.take([1, 2, 3], 2); + * // => [1, 2] + * + * _.take([1, 2, 3], 5); + * // => [1, 2, 3] + * + * _.take([1, 2, 3], 0); + * // => [] + */ + function take(array, n, guard) { + if (!(array && array.length)) { + return []; + } + n = (guard || n === undefined) ? 1 : toInteger(n); + return baseSlice(array, 0, n < 0 ? 0 : n); + } + + /** + * Creates a slice of `array` with `n` elements taken from the end. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {number} [n=1] The number of elements to take. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.takeRight([1, 2, 3]); + * // => [3] + * + * _.takeRight([1, 2, 3], 2); + * // => [2, 3] + * + * _.takeRight([1, 2, 3], 5); + * // => [1, 2, 3] + * + * _.takeRight([1, 2, 3], 0); + * // => [] + */ + function takeRight(array, n, guard) { + var length = array == null ? 0 : array.length; + if (!length) { + return []; + } + n = (guard || n === undefined) ? 1 : toInteger(n); + n = length - n; + return baseSlice(array, n < 0 ? 0 : n, length); + } + + /** + * Creates a slice of `array` with elements taken from the end. Elements are + * taken until `predicate` returns falsey. The predicate is invoked with + * three arguments: (value, index, array). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the slice of `array`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': true }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': false } + * ]; + * + * _.takeRightWhile(users, function(o) { return !o.active; }); + * // => objects for ['fred', 'pebbles'] + * + * // The `_.matches` iteratee shorthand. + * _.takeRightWhile(users, { 'user': 'pebbles', 'active': false }); + * // => objects for ['pebbles'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.takeRightWhile(users, ['active', false]); + * // => objects for ['fred', 'pebbles'] + * + * // The `_.property` iteratee shorthand. + * _.takeRightWhile(users, 'active'); + * // => [] + */ + function takeRightWhile(array, predicate) { + return (array && array.length) + ? baseWhile(array, getIteratee(predicate, 3), false, true) + : []; + } + + /** + * Creates a slice of `array` with elements taken from the beginning. Elements + * are taken until `predicate` returns falsey. The predicate is invoked with + * three arguments: (value, index, array). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the slice of `array`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': false }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': true } + * ]; + * + * _.takeWhile(users, function(o) { return !o.active; }); + * // => objects for ['barney', 'fred'] + * + * // The `_.matches` iteratee shorthand. + * _.takeWhile(users, { 'user': 'barney', 'active': false }); + * // => objects for ['barney'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.takeWhile(users, ['active', false]); + * // => objects for ['barney', 'fred'] + * + * // The `_.property` iteratee shorthand. + * _.takeWhile(users, 'active'); + * // => [] + */ + function takeWhile(array, predicate) { + return (array && array.length) + ? baseWhile(array, getIteratee(predicate, 3)) + : []; + } + + /** + * Creates an array of unique values, in order, from all given arrays using + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @returns {Array} Returns the new array of combined values. + * @example + * + * _.union([2], [1, 2]); + * // => [2, 1] + */ + var union = baseRest(function(arrays) { + return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true)); + }); + + /** + * This method is like `_.union` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by + * which uniqueness is computed. Result values are chosen from the first + * array in which the value occurs. The iteratee is invoked with one argument: + * (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns the new array of combined values. + * @example + * + * _.unionBy([2.1], [1.2, 2.3], Math.floor); + * // => [2.1, 1.2] + * + * // The `_.property` iteratee shorthand. + * _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 1 }, { 'x': 2 }] + */ + var unionBy = baseRest(function(arrays) { + var iteratee = last(arrays); + if (isArrayLikeObject(iteratee)) { + iteratee = undefined; + } + return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), getIteratee(iteratee, 2)); + }); + + /** + * This method is like `_.union` except that it accepts `comparator` which + * is invoked to compare elements of `arrays`. Result values are chosen from + * the first array in which the value occurs. The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of combined values. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * + * _.unionWith(objects, others, _.isEqual); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }] + */ + var unionWith = baseRest(function(arrays) { + var comparator = last(arrays); + comparator = typeof comparator == 'function' ? comparator : undefined; + return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined, comparator); + }); + + /** + * Creates a duplicate-free version of an array, using + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons, in which only the first occurrence of each element + * is kept. The order of result values is determined by the order they occur + * in the array. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * _.uniq([2, 1, 2]); + * // => [2, 1] + */ + function uniq(array) { + return (array && array.length) ? baseUniq(array) : []; + } + + /** + * This method is like `_.uniq` except that it accepts `iteratee` which is + * invoked for each element in `array` to generate the criterion by which + * uniqueness is computed. The order of result values is determined by the + * order they occur in the array. The iteratee is invoked with one argument: + * (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * _.uniqBy([2.1, 1.2, 2.3], Math.floor); + * // => [2.1, 1.2] + * + * // The `_.property` iteratee shorthand. + * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 1 }, { 'x': 2 }] + */ + function uniqBy(array, iteratee) { + return (array && array.length) ? baseUniq(array, getIteratee(iteratee, 2)) : []; + } + + /** + * This method is like `_.uniq` except that it accepts `comparator` which + * is invoked to compare elements of `array`. The order of result values is + * determined by the order they occur in the array.The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * + * _.uniqWith(objects, _.isEqual); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }] + */ + function uniqWith(array, comparator) { + comparator = typeof comparator == 'function' ? comparator : undefined; + return (array && array.length) ? baseUniq(array, undefined, comparator) : []; + } + + /** + * This method is like `_.zip` except that it accepts an array of grouped + * elements and creates an array regrouping the elements to their pre-zip + * configuration. + * + * @static + * @memberOf _ + * @since 1.2.0 + * @category Array + * @param {Array} array The array of grouped elements to process. + * @returns {Array} Returns the new array of regrouped elements. + * @example + * + * var zipped = _.zip(['a', 'b'], [1, 2], [true, false]); + * // => [['a', 1, true], ['b', 2, false]] + * + * _.unzip(zipped); + * // => [['a', 'b'], [1, 2], [true, false]] + */ + function unzip(array) { + if (!(array && array.length)) { + return []; + } + var length = 0; + array = arrayFilter(array, function(group) { + if (isArrayLikeObject(group)) { + length = nativeMax(group.length, length); + return true; + } + }); + return baseTimes(length, function(index) { + return arrayMap(array, baseProperty(index)); + }); + } + + /** + * This method is like `_.unzip` except that it accepts `iteratee` to specify + * how regrouped values should be combined. The iteratee is invoked with the + * elements of each group: (...group). + * + * @static + * @memberOf _ + * @since 3.8.0 + * @category Array + * @param {Array} array The array of grouped elements to process. + * @param {Function} [iteratee=_.identity] The function to combine + * regrouped values. + * @returns {Array} Returns the new array of regrouped elements. + * @example + * + * var zipped = _.zip([1, 2], [10, 20], [100, 200]); + * // => [[1, 10, 100], [2, 20, 200]] + * + * _.unzipWith(zipped, _.add); + * // => [3, 30, 300] + */ + function unzipWith(array, iteratee) { + if (!(array && array.length)) { + return []; + } + var result = unzip(array); + if (iteratee == null) { + return result; + } + return arrayMap(result, function(group) { + return apply(iteratee, undefined, group); + }); + } + + /** + * Creates an array excluding all given values using + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. + * + * **Note:** Unlike `_.pull`, this method returns a new array. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {...*} [values] The values to exclude. + * @returns {Array} Returns the new array of filtered values. + * @see _.difference, _.xor + * @example + * + * _.without([2, 1, 2, 3], 1, 2); + * // => [3] + */ + var without = baseRest(function(array, values) { + return isArrayLikeObject(array) + ? baseDifference(array, values) + : []; + }); + + /** + * Creates an array of unique values that is the + * [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference) + * of the given arrays. The order of result values is determined by the order + * they occur in the arrays. + * + * @static + * @memberOf _ + * @since 2.4.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @returns {Array} Returns the new array of filtered values. + * @see _.difference, _.without + * @example + * + * _.xor([2, 1], [2, 3]); + * // => [1, 3] + */ + var xor = baseRest(function(arrays) { + return baseXor(arrayFilter(arrays, isArrayLikeObject)); + }); + + /** + * This method is like `_.xor` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by + * which by which they're compared. The order of result values is determined + * by the order they occur in the arrays. The iteratee is invoked with one + * argument: (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns the new array of filtered values. + * @example + * + * _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor); + * // => [1.2, 3.4] + * + * // The `_.property` iteratee shorthand. + * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 2 }] + */ + var xorBy = baseRest(function(arrays) { + var iteratee = last(arrays); + if (isArrayLikeObject(iteratee)) { + iteratee = undefined; + } + return baseXor(arrayFilter(arrays, isArrayLikeObject), getIteratee(iteratee, 2)); + }); + + /** + * This method is like `_.xor` except that it accepts `comparator` which is + * invoked to compare elements of `arrays`. The order of result values is + * determined by the order they occur in the arrays. The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of filtered values. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * + * _.xorWith(objects, others, _.isEqual); + * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }] + */ + var xorWith = baseRest(function(arrays) { + var comparator = last(arrays); + comparator = typeof comparator == 'function' ? comparator : undefined; + return baseXor(arrayFilter(arrays, isArrayLikeObject), undefined, comparator); + }); + + /** + * 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 _ + * @since 0.1.0 + * @category Array + * @param {...Array} [arrays] The arrays to process. + * @returns {Array} Returns the new array of grouped elements. + * @example + * + * _.zip(['a', 'b'], [1, 2], [true, false]); + * // => [['a', 1, true], ['b', 2, false]] + */ + var zip = baseRest(unzip); + + /** + * This method is like `_.fromPairs` except that it accepts two arrays, + * one of property identifiers and one of corresponding values. + * + * @static + * @memberOf _ + * @since 0.4.0 + * @category Array + * @param {Array} [props=[]] The property identifiers. + * @param {Array} [values=[]] The property values. + * @returns {Object} Returns the new object. + * @example + * + * _.zipObject(['a', 'b'], [1, 2]); + * // => { 'a': 1, 'b': 2 } + */ + function zipObject(props, values) { + return baseZipObject(props || [], values || [], assignValue); + } + + /** + * This method is like `_.zipObject` except that it supports property paths. + * + * @static + * @memberOf _ + * @since 4.1.0 + * @category Array + * @param {Array} [props=[]] The property identifiers. + * @param {Array} [values=[]] The property values. + * @returns {Object} Returns the new object. + * @example + * + * _.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]); + * // => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } } + */ + function zipObjectDeep(props, values) { + return baseZipObject(props || [], values || [], baseSet); + } + + /** + * This method is like `_.zip` except that it accepts `iteratee` to specify + * how grouped values should be combined. The iteratee is invoked with the + * elements of each group: (...group). + * + * @static + * @memberOf _ + * @since 3.8.0 + * @category Array + * @param {...Array} [arrays] The arrays to process. + * @param {Function} [iteratee=_.identity] The function to combine + * grouped values. + * @returns {Array} Returns the new array of grouped elements. + * @example + * + * _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) { + * return a + b + c; + * }); + * // => [111, 222] + */ + var zipWith = baseRest(function(arrays) { + var length = arrays.length, + iteratee = length > 1 ? arrays[length - 1] : undefined; + + iteratee = typeof iteratee == 'function' ? (arrays.pop(), iteratee) : undefined; + return unzipWith(arrays, iteratee); + }); + + /*------------------------------------------------------------------------*/ + + /** + * Creates a `lodash` wrapper instance that wraps `value` with explicit method + * chain sequences enabled. The result of such sequences must be unwrapped + * with `_#value`. + * + * @static + * @memberOf _ + * @since 1.3.0 + * @category Seq + * @param {*} value The value to wrap. + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36 }, + * { 'user': 'fred', 'age': 40 }, + * { 'user': 'pebbles', 'age': 1 } + * ]; + * + * var youngest = _ + * .chain(users) + * .sortBy('age') + * .map(function(o) { + * return o.user + ' is ' + o.age; + * }) + * .head() + * .value(); + * // => 'pebbles is 1' + */ + function chain(value) { + var result = lodash(value); + result.__chain__ = true; + return result; + } + + /** + * This method invokes `interceptor` and returns `value`. The interceptor + * is invoked with one argument; (value). The purpose of this method is to + * "tap into" a method chain sequence in order to modify intermediate results. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Seq + * @param {*} value The value to provide to `interceptor`. + * @param {Function} interceptor The function to invoke. + * @returns {*} Returns `value`. + * @example + * + * _([1, 2, 3]) + * .tap(function(array) { + * // Mutate input array. + * array.pop(); + * }) + * .reverse() + * .value(); + * // => [2, 1] + */ + function tap(value, interceptor) { + interceptor(value); + return value; + } + + /** + * This method is like `_.tap` except that it returns the result of `interceptor`. + * The purpose of this method is to "pass thru" values replacing intermediate + * results in a method chain sequence. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Seq + * @param {*} value The value to provide to `interceptor`. + * @param {Function} interceptor The function to invoke. + * @returns {*} Returns the result of `interceptor`. + * @example + * + * _(' abc ') + * .chain() + * .trim() + * .thru(function(value) { + * return [value]; + * }) + * .value(); + * // => ['abc'] + */ + function thru(value, interceptor) { + return interceptor(value); + } + + /** + * This method is the wrapper version of `_.at`. + * + * @name at + * @memberOf _ + * @since 1.0.0 + * @category Seq + * @param {...(string|string[])} [paths] The property paths to pick. + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] }; + * + * _(object).at(['a[0].b.c', 'a[1]']).value(); + * // => [3, 4] + */ + var wrapperAt = flatRest(function(paths) { + var length = paths.length, + start = length ? paths[0] : 0, + value = this.__wrapped__, + interceptor = function(object) { return baseAt(object, paths); }; + + if (length > 1 || this.__actions__.length || + !(value instanceof LazyWrapper) || !isIndex(start)) { + return this.thru(interceptor); + } + value = value.slice(start, +start + (length ? 1 : 0)); + value.__actions__.push({ + 'func': thru, + 'args': [interceptor], + 'thisArg': undefined + }); + return new LodashWrapper(value, this.__chain__).thru(function(array) { + if (length && !array.length) { + array.push(undefined); + } + return array; + }); + }); + + /** + * Creates a `lodash` wrapper instance with explicit method chain sequences enabled. + * + * @name chain + * @memberOf _ + * @since 0.1.0 + * @category Seq + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36 }, + * { 'user': 'fred', 'age': 40 } + * ]; + * + * // A sequence without explicit chaining. + * _(users).head(); + * // => { 'user': 'barney', 'age': 36 } + * + * // A sequence with explicit chaining. + * _(users) + * .chain() + * .head() + * .pick('user') + * .value(); + * // => { 'user': 'barney' } + */ + function wrapperChain() { + return chain(this); + } + + /** + * Executes the chain sequence and returns the wrapped result. + * + * @name commit + * @memberOf _ + * @since 3.2.0 + * @category Seq + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * var array = [1, 2]; + * var wrapped = _(array).push(3); + * + * console.log(array); + * // => [1, 2] + * + * wrapped = wrapped.commit(); + * console.log(array); + * // => [1, 2, 3] + * + * wrapped.last(); + * // => 3 + * + * console.log(array); + * // => [1, 2, 3] + */ + function wrapperCommit() { + return new LodashWrapper(this.value(), this.__chain__); + } + + /** + * Gets the next value on a wrapped object following the + * [iterator protocol](https://mdn.io/iteration_protocols#iterator). + * + * @name next + * @memberOf _ + * @since 4.0.0 + * @category Seq + * @returns {Object} Returns the next iterator value. + * @example + * + * var wrapped = _([1, 2]); + * + * wrapped.next(); + * // => { 'done': false, 'value': 1 } + * + * wrapped.next(); + * // => { 'done': false, 'value': 2 } + * + * wrapped.next(); + * // => { 'done': true, 'value': undefined } + */ + function wrapperNext() { + if (this.__values__ === undefined) { + this.__values__ = toArray(this.value()); + } + var done = this.__index__ >= this.__values__.length, + value = done ? undefined : this.__values__[this.__index__++]; + + return { 'done': done, 'value': value }; + } + + /** + * Enables the wrapper to be iterable. + * + * @name Symbol.iterator + * @memberOf _ + * @since 4.0.0 + * @category Seq + * @returns {Object} Returns the wrapper object. + * @example + * + * var wrapped = _([1, 2]); + * + * wrapped[Symbol.iterator]() === wrapped; + * // => true + * + * Array.from(wrapped); + * // => [1, 2] + */ + function wrapperToIterator() { + return this; + } + + /** + * Creates a clone of the chain sequence planting `value` as the wrapped value. + * + * @name plant + * @memberOf _ + * @since 3.2.0 + * @category Seq + * @param {*} value The value to plant. + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * function square(n) { + * return n * n; + * } + * + * var wrapped = _([1, 2]).map(square); + * var other = wrapped.plant([3, 4]); + * + * other.value(); + * // => [9, 16] + * + * wrapped.value(); + * // => [1, 4] + */ + function wrapperPlant(value) { + var result, + parent = this; + + while (parent instanceof baseLodash) { + var clone = wrapperClone(parent); + clone.__index__ = 0; + clone.__values__ = undefined; + if (result) { + previous.__wrapped__ = clone; + } else { + result = clone; + } + var previous = clone; + parent = parent.__wrapped__; + } + previous.__wrapped__ = value; + return result; + } + + /** + * This method is the wrapper version of `_.reverse`. + * + * **Note:** This method mutates the wrapped array. + * + * @name reverse + * @memberOf _ + * @since 0.1.0 + * @category Seq + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * var array = [1, 2, 3]; + * + * _(array).reverse().value() + * // => [3, 2, 1] + * + * console.log(array); + * // => [3, 2, 1] + */ + function wrapperReverse() { + var value = this.__wrapped__; + if (value instanceof LazyWrapper) { + var wrapped = value; + if (this.__actions__.length) { + wrapped = new LazyWrapper(this); + } + wrapped = wrapped.reverse(); + wrapped.__actions__.push({ + 'func': thru, + 'args': [reverse], + 'thisArg': undefined + }); + return new LodashWrapper(wrapped, this.__chain__); + } + return this.thru(reverse); + } + + /** + * Executes the chain sequence to resolve the unwrapped value. + * + * @name value + * @memberOf _ + * @since 0.1.0 + * @alias toJSON, valueOf + * @category Seq + * @returns {*} Returns the resolved unwrapped value. + * @example + * + * _([1, 2, 3]).value(); + * // => [1, 2, 3] + */ + function wrapperValue() { + return baseWrapperValue(this.__wrapped__, this.__actions__); + } + + /*------------------------------------------------------------------------*/ + + /** + * Creates an object composed of keys generated from the results of running + * each element of `collection` thru `iteratee`. The corresponding value of + * each key is the number of times the key was returned by `iteratee`. The + * iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 0.5.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The iteratee to transform keys. + * @returns {Object} Returns the composed aggregate object. + * @example + * + * _.countBy([6.1, 4.2, 6.3], Math.floor); + * // => { '4': 1, '6': 2 } + * + * // The `_.property` iteratee shorthand. + * _.countBy(['one', 'two', 'three'], 'length'); + * // => { '3': 2, '5': 1 } + */ + var countBy = createAggregator(function(result, value, key) { + if (hasOwnProperty.call(result, key)) { + ++result[key]; + } else { + baseAssignValue(result, key, 1); + } + }); + + /** + * Checks if `predicate` returns truthy for **all** elements of `collection`. + * Iteration is stopped once `predicate` returns falsey. The predicate is + * invoked with three arguments: (value, index|key, collection). + * + * **Note:** This method returns `true` for + * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because + * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of + * elements of empty collections. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {boolean} Returns `true` if all elements pass the predicate check, + * else `false`. + * @example + * + * _.every([true, 1, null, 'yes'], Boolean); + * // => false + * + * var users = [ + * { 'user': 'barney', 'age': 36, 'active': false }, + * { 'user': 'fred', 'age': 40, 'active': false } + * ]; + * + * // The `_.matches` iteratee shorthand. + * _.every(users, { 'user': 'barney', 'active': false }); + * // => false + * + * // The `_.matchesProperty` iteratee shorthand. + * _.every(users, ['active', false]); + * // => true + * + * // The `_.property` iteratee shorthand. + * _.every(users, 'active'); + * // => false + */ + function every(collection, predicate, guard) { + var func = isArray(collection) ? arrayEvery : baseEvery; + if (guard && isIterateeCall(collection, predicate, guard)) { + predicate = undefined; + } + return func(collection, getIteratee(predicate, 3)); + } + + /** + * Iterates over elements of `collection`, returning an array of all elements + * `predicate` returns truthy for. The predicate is invoked with three + * arguments: (value, index|key, collection). + * + * **Note:** Unlike `_.remove`, this method returns a new array. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new filtered array. + * @see _.reject + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36, 'active': true }, + * { 'user': 'fred', 'age': 40, 'active': false } + * ]; + * + * _.filter(users, function(o) { return !o.active; }); + * // => objects for ['fred'] + * + * // The `_.matches` iteratee shorthand. + * _.filter(users, { 'age': 36, 'active': true }); + * // => objects for ['barney'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.filter(users, ['active', false]); + * // => objects for ['fred'] + * + * // The `_.property` iteratee shorthand. + * _.filter(users, 'active'); + * // => objects for ['barney'] + * + * // Combining several predicates using `_.overEvery` or `_.overSome`. + * _.filter(users, _.overSome([{ 'age': 36 }, ['age', 40]])); + * // => objects for ['fred', 'barney'] + */ + function filter(collection, predicate) { + var func = isArray(collection) ? arrayFilter : baseFilter; + return func(collection, getIteratee(predicate, 3)); + } + + /** + * Iterates over elements of `collection`, returning the first element + * `predicate` returns truthy for. The predicate is invoked with three + * arguments: (value, index|key, collection). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param {number} [fromIndex=0] The index to search from. + * @returns {*} Returns the matched element, else `undefined`. + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36, 'active': true }, + * { 'user': 'fred', 'age': 40, 'active': false }, + * { 'user': 'pebbles', 'age': 1, 'active': true } + * ]; + * + * _.find(users, function(o) { return o.age < 40; }); + * // => object for 'barney' + * + * // The `_.matches` iteratee shorthand. + * _.find(users, { 'age': 1, 'active': true }); + * // => object for 'pebbles' + * + * // The `_.matchesProperty` iteratee shorthand. + * _.find(users, ['active', false]); + * // => object for 'fred' + * + * // The `_.property` iteratee shorthand. + * _.find(users, 'active'); + * // => object for 'barney' + */ + var find = createFind(findIndex); + + /** + * This method is like `_.find` except that it iterates over elements of + * `collection` from right to left. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Collection + * @param {Array|Object} collection The collection to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param {number} [fromIndex=collection.length-1] The index to search from. + * @returns {*} Returns the matched element, else `undefined`. + * @example + * + * _.findLast([1, 2, 3, 4], function(n) { + * return n % 2 == 1; + * }); + * // => 3 + */ + var findLast = createFind(findLastIndex); + + /** + * Creates a flattened array of values by running each element in `collection` + * thru `iteratee` and flattening the mapped results. The iteratee is invoked + * with three arguments: (value, index|key, collection). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new flattened array. + * @example + * + * function duplicate(n) { + * return [n, n]; + * } + * + * _.flatMap([1, 2], duplicate); + * // => [1, 1, 2, 2] + */ + function flatMap(collection, iteratee) { + return baseFlatten(map(collection, iteratee), 1); + } + + /** + * This method is like `_.flatMap` except that it recursively flattens the + * mapped results. + * + * @static + * @memberOf _ + * @since 4.7.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new flattened array. + * @example + * + * function duplicate(n) { + * return [[[n, n]]]; + * } + * + * _.flatMapDeep([1, 2], duplicate); + * // => [1, 1, 2, 2] + */ + function flatMapDeep(collection, iteratee) { + return baseFlatten(map(collection, iteratee), INFINITY); + } + + /** + * This method is like `_.flatMap` except that it recursively flattens the + * mapped results up to `depth` times. + * + * @static + * @memberOf _ + * @since 4.7.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @param {number} [depth=1] The maximum recursion depth. + * @returns {Array} Returns the new flattened array. + * @example + * + * function duplicate(n) { + * return [[[n, n]]]; + * } + * + * _.flatMapDepth([1, 2], duplicate, 2); + * // => [[1, 1], [2, 2]] + */ + function flatMapDepth(collection, iteratee, depth) { + depth = depth === undefined ? 1 : toInteger(depth); + return baseFlatten(map(collection, iteratee), depth); + } + + /** + * Iterates over elements of `collection` and invokes `iteratee` for each element. + * The iteratee is invoked with three arguments: (value, index|key, collection). + * Iteratee functions may exit iteration early by explicitly returning `false`. + * + * **Note:** As with other "Collections" methods, objects with a "length" + * property are iterated like arrays. To avoid this behavior use `_.forIn` + * or `_.forOwn` for object iteration. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @alias each + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Array|Object} Returns `collection`. + * @see _.forEachRight + * @example + * + * _.forEach([1, 2], function(value) { + * console.log(value); + * }); + * // => Logs `1` then `2`. + * + * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) { + * console.log(key); + * }); + * // => Logs 'a' then 'b' (iteration order is not guaranteed). + */ + function forEach(collection, iteratee) { + var func = isArray(collection) ? arrayEach : baseEach; + return func(collection, getIteratee(iteratee, 3)); + } + + /** + * This method is like `_.forEach` except that it iterates over elements of + * `collection` from right to left. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @alias eachRight + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Array|Object} Returns `collection`. + * @see _.forEach + * @example + * + * _.forEachRight([1, 2], function(value) { + * console.log(value); + * }); + * // => Logs `2` then `1`. + */ + function forEachRight(collection, iteratee) { + var func = isArray(collection) ? arrayEachRight : baseEachRight; + return func(collection, getIteratee(iteratee, 3)); + } + + /** + * Creates an object composed of keys generated from the results of running + * each element of `collection` thru `iteratee`. The order of grouped values + * is determined by the order they occur in `collection`. The corresponding + * value of each key is an array of elements responsible for generating the + * key. The iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The iteratee to transform keys. + * @returns {Object} Returns the composed aggregate object. + * @example + * + * _.groupBy([6.1, 4.2, 6.3], Math.floor); + * // => { '4': [4.2], '6': [6.1, 6.3] } + * + * // The `_.property` iteratee shorthand. + * _.groupBy(['one', 'two', 'three'], 'length'); + * // => { '3': ['one', 'two'], '5': ['three'] } + */ + var groupBy = createAggregator(function(result, value, key) { + if (hasOwnProperty.call(result, key)) { + result[key].push(value); + } else { + baseAssignValue(result, key, [value]); + } + }); + + /** + * Checks if `value` is in `collection`. If `collection` is a string, it's + * checked for a substring of `value`, otherwise + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * is used for equality comparisons. If `fromIndex` is negative, it's used as + * the offset from the end of `collection`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object|string} collection The collection to inspect. + * @param {*} value The value to search for. + * @param {number} [fromIndex=0] The index to search from. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`. + * @returns {boolean} Returns `true` if `value` is found, else `false`. + * @example + * + * _.includes([1, 2, 3], 1); + * // => true + * + * _.includes([1, 2, 3], 1, 2); + * // => false + * + * _.includes({ 'a': 1, 'b': 2 }, 1); + * // => true + * + * _.includes('abcd', 'bc'); + * // => true + */ + function includes(collection, value, fromIndex, guard) { + collection = isArrayLike(collection) ? collection : values(collection); + fromIndex = (fromIndex && !guard) ? toInteger(fromIndex) : 0; + + var length = collection.length; + if (fromIndex < 0) { + fromIndex = nativeMax(length + fromIndex, 0); + } + return isString(collection) + ? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1) + : (!!length && baseIndexOf(collection, value, fromIndex) > -1); + } + + /** + * Invokes the method at `path` of each element in `collection`, returning + * an array of the results of each invoked method. Any additional arguments + * are provided to each invoked method. If `path` is a function, it's invoked + * for, and `this` bound to, each element in `collection`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Array|Function|string} path The path of the method to invoke or + * the function invoked per iteration. + * @param {...*} [args] The arguments to invoke each method with. + * @returns {Array} Returns the array of results. + * @example + * + * _.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort'); + * // => [[1, 5, 7], [1, 2, 3]] + * + * _.invokeMap([123, 456], String.prototype.split, ''); + * // => [['1', '2', '3'], ['4', '5', '6']] + */ + var invokeMap = baseRest(function(collection, path, args) { + var index = -1, + isFunc = typeof path == 'function', + result = isArrayLike(collection) ? Array(collection.length) : []; + + baseEach(collection, function(value) { + result[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args); + }); + return result; + }); + + /** + * Creates an object composed of keys generated from the results of running + * each element of `collection` thru `iteratee`. The corresponding value of + * each key is the last element responsible for generating the key. The + * iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The iteratee to transform keys. + * @returns {Object} Returns the composed aggregate object. + * @example + * + * var array = [ + * { 'dir': 'left', 'code': 97 }, + * { 'dir': 'right', 'code': 100 } + * ]; + * + * _.keyBy(array, function(o) { + * return String.fromCharCode(o.code); + * }); + * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } } + * + * _.keyBy(array, 'dir'); + * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } } + */ + var keyBy = createAggregator(function(result, value, key) { + baseAssignValue(result, key, value); + }); + + /** + * Creates an array of values by running each element in `collection` thru + * `iteratee`. The iteratee is invoked with three arguments: + * (value, index|key, collection). + * + * Many lodash methods are guarded to work as iteratees for methods like + * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`. + * + * The guarded methods are: + * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`, + * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`, + * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`, + * `template`, `trim`, `trimEnd`, `trimStart`, and `words` + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new mapped array. + * @example + * + * function square(n) { + * return n * n; + * } + * + * _.map([4, 8], square); + * // => [16, 64] + * + * _.map({ 'a': 4, 'b': 8 }, square); + * // => [16, 64] (iteration order is not guaranteed) + * + * var users = [ + * { 'user': 'barney' }, + * { 'user': 'fred' } + * ]; + * + * // The `_.property` iteratee shorthand. + * _.map(users, 'user'); + * // => ['barney', 'fred'] + */ + function map(collection, iteratee) { + var func = isArray(collection) ? arrayMap : baseMap; + return func(collection, getIteratee(iteratee, 3)); + } + + /** + * This method is like `_.sortBy` except that it allows specifying the sort + * orders of the iteratees to sort by. If `orders` is unspecified, all values + * are sorted in ascending order. Otherwise, specify an order of "desc" for + * descending or "asc" for ascending sort order of corresponding values. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]] + * The iteratees to sort by. + * @param {string[]} [orders] The sort orders of `iteratees`. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`. + * @returns {Array} Returns the new sorted array. + * @example + * + * var users = [ + * { 'user': 'fred', 'age': 48 }, + * { 'user': 'barney', 'age': 34 }, + * { 'user': 'fred', 'age': 40 }, + * { 'user': 'barney', 'age': 36 } + * ]; + * + * // Sort by `user` in ascending order and by `age` in descending order. + * _.orderBy(users, ['user', 'age'], ['asc', 'desc']); + * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]] + */ + function orderBy(collection, iteratees, orders, guard) { + if (collection == null) { + return []; + } + if (!isArray(iteratees)) { + iteratees = iteratees == null ? [] : [iteratees]; + } + orders = guard ? undefined : orders; + if (!isArray(orders)) { + orders = orders == null ? [] : [orders]; + } + return baseOrderBy(collection, iteratees, orders); + } + + /** + * Creates an array of elements split into two groups, the first of which + * contains elements `predicate` returns truthy for, the second of which + * contains elements `predicate` returns falsey for. The predicate is + * invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the array of grouped elements. + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36, 'active': false }, + * { 'user': 'fred', 'age': 40, 'active': true }, + * { 'user': 'pebbles', 'age': 1, 'active': false } + * ]; + * + * _.partition(users, function(o) { return o.active; }); + * // => objects for [['fred'], ['barney', 'pebbles']] + * + * // The `_.matches` iteratee shorthand. + * _.partition(users, { 'age': 1, 'active': false }); + * // => objects for [['pebbles'], ['barney', 'fred']] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.partition(users, ['active', false]); + * // => objects for [['barney', 'pebbles'], ['fred']] + * + * // The `_.property` iteratee shorthand. + * _.partition(users, 'active'); + * // => objects for [['fred'], ['barney', 'pebbles']] + */ + var partition = createAggregator(function(result, value, key) { + result[key ? 0 : 1].push(value); + }, function() { return [[], []]; }); + + /** + * Reduces `collection` to a value which is the accumulated result of running + * each element in `collection` thru `iteratee`, where each successive + * invocation is supplied the return value of the previous. If `accumulator` + * is not given, the first element of `collection` is used as the initial + * value. The iteratee is invoked with four arguments: + * (accumulator, value, index|key, collection). + * + * Many lodash methods are guarded to work as iteratees for methods like + * `_.reduce`, `_.reduceRight`, and `_.transform`. + * + * The guarded methods are: + * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`, + * and `sortBy` + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @param {*} [accumulator] The initial value. + * @returns {*} Returns the accumulated value. + * @see _.reduceRight + * @example + * + * _.reduce([1, 2], function(sum, n) { + * return sum + n; + * }, 0); + * // => 3 + * + * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) { + * (result[value] || (result[value] = [])).push(key); + * return result; + * }, {}); + * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed) + */ + function reduce(collection, iteratee, accumulator) { + var func = isArray(collection) ? arrayReduce : baseReduce, + initAccum = arguments.length < 3; + + return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEach); + } + + /** + * This method is like `_.reduce` except that it iterates over elements of + * `collection` from right to left. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @param {*} [accumulator] The initial value. + * @returns {*} Returns the accumulated value. + * @see _.reduce + * @example + * + * var array = [[0, 1], [2, 3], [4, 5]]; + * + * _.reduceRight(array, function(flattened, other) { + * return flattened.concat(other); + * }, []); + * // => [4, 5, 2, 3, 0, 1] + */ + function reduceRight(collection, iteratee, accumulator) { + var func = isArray(collection) ? arrayReduceRight : baseReduce, + initAccum = arguments.length < 3; + + return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEachRight); + } + + /** + * The opposite of `_.filter`; this method returns the elements of `collection` + * that `predicate` does **not** return truthy for. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new filtered array. + * @see _.filter + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36, 'active': false }, + * { 'user': 'fred', 'age': 40, 'active': true } + * ]; + * + * _.reject(users, function(o) { return !o.active; }); + * // => objects for ['fred'] + * + * // The `_.matches` iteratee shorthand. + * _.reject(users, { 'age': 40, 'active': true }); + * // => objects for ['barney'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.reject(users, ['active', false]); + * // => objects for ['fred'] + * + * // The `_.property` iteratee shorthand. + * _.reject(users, 'active'); + * // => objects for ['barney'] + */ + function reject(collection, predicate) { + var func = isArray(collection) ? arrayFilter : baseFilter; + return func(collection, negate(getIteratee(predicate, 3))); + } + + /** + * Gets a random element from `collection`. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Collection + * @param {Array|Object} collection The collection to sample. + * @returns {*} Returns the random element. + * @example + * + * _.sample([1, 2, 3, 4]); + * // => 2 + */ + function sample(collection) { + var func = isArray(collection) ? arraySample : baseSample; + return func(collection); + } + + /** + * Gets `n` random elements at unique keys from `collection` up to the + * size of `collection`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Collection + * @param {Array|Object} collection The collection to sample. + * @param {number} [n=1] The number of elements to sample. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the random elements. + * @example + * + * _.sampleSize([1, 2, 3], 2); + * // => [3, 1] + * + * _.sampleSize([1, 2, 3], 4); + * // => [2, 3, 1] + */ + function sampleSize(collection, n, guard) { + if ((guard ? isIterateeCall(collection, n, guard) : n === undefined)) { + n = 1; + } else { + n = toInteger(n); + } + var func = isArray(collection) ? arraySampleSize : baseSampleSize; + return func(collection, n); + } + + /** + * Creates an array of shuffled values, using a version of the + * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to shuffle. + * @returns {Array} Returns the new shuffled array. + * @example + * + * _.shuffle([1, 2, 3, 4]); + * // => [4, 1, 3, 2] + */ + function shuffle(collection) { + var func = isArray(collection) ? arrayShuffle : baseShuffle; + return func(collection); + } + + /** + * Gets the size of `collection` by returning its length for array-like + * values or the number of own enumerable string keyed properties for objects. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object|string} collection The collection to inspect. + * @returns {number} Returns the collection size. + * @example + * + * _.size([1, 2, 3]); + * // => 3 + * + * _.size({ 'a': 1, 'b': 2 }); + * // => 2 + * + * _.size('pebbles'); + * // => 7 + */ + function size(collection) { + if (collection == null) { + return 0; + } + if (isArrayLike(collection)) { + return isString(collection) ? stringSize(collection) : collection.length; + } + var tag = getTag(collection); + if (tag == mapTag || tag == setTag) { + return collection.size; + } + return baseKeys(collection).length; + } + + /** + * Checks if `predicate` returns truthy for **any** element of `collection`. + * Iteration is stopped once `predicate` returns truthy. The predicate is + * invoked with three arguments: (value, index|key, collection). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {boolean} Returns `true` if any element passes the predicate check, + * else `false`. + * @example + * + * _.some([null, 0, 'yes', false], Boolean); + * // => true + * + * var users = [ + * { 'user': 'barney', 'active': true }, + * { 'user': 'fred', 'active': false } + * ]; + * + * // The `_.matches` iteratee shorthand. + * _.some(users, { 'user': 'barney', 'active': false }); + * // => false + * + * // The `_.matchesProperty` iteratee shorthand. + * _.some(users, ['active', false]); + * // => true + * + * // The `_.property` iteratee shorthand. + * _.some(users, 'active'); + * // => true + */ + function some(collection, predicate, guard) { + var func = isArray(collection) ? arraySome : baseSome; + if (guard && isIterateeCall(collection, predicate, guard)) { + predicate = undefined; + } + return func(collection, getIteratee(predicate, 3)); + } + + /** + * Creates an array of elements, sorted in ascending order by the results of + * running each element in a collection thru each iteratee. This method + * performs a stable sort, that is, it preserves the original sort order of + * equal elements. The iteratees are invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {...(Function|Function[])} [iteratees=[_.identity]] + * The iteratees to sort by. + * @returns {Array} Returns the new sorted array. + * @example + * + * var users = [ + * { 'user': 'fred', 'age': 48 }, + * { 'user': 'barney', 'age': 36 }, + * { 'user': 'fred', 'age': 30 }, + * { 'user': 'barney', 'age': 34 } + * ]; + * + * _.sortBy(users, [function(o) { return o.user; }]); + * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 30]] + * + * _.sortBy(users, ['user', 'age']); + * // => objects for [['barney', 34], ['barney', 36], ['fred', 30], ['fred', 48]] + */ + var sortBy = baseRest(function(collection, iteratees) { + if (collection == null) { + return []; + } + var length = iteratees.length; + if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) { + iteratees = []; + } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) { + iteratees = [iteratees[0]]; + } + return baseOrderBy(collection, baseFlatten(iteratees, 1), []); + }); + + /*------------------------------------------------------------------------*/ + + /** + * Gets the timestamp of the number of milliseconds that have elapsed since + * the Unix epoch (1 January 1970 00:00:00 UTC). + * + * @static + * @memberOf _ + * @since 2.4.0 + * @category Date + * @returns {number} Returns the timestamp. + * @example + * + * _.defer(function(stamp) { + * console.log(_.now() - stamp); + * }, _.now()); + * // => Logs the number of milliseconds it took for the deferred invocation. + */ + var now = ctxNow || function() { + return root.Date.now(); + }; + + /*------------------------------------------------------------------------*/ + + /** + * The opposite of `_.before`; this method creates a function that invokes + * `func` once it's called `n` or more times. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {number} n The number of calls before `func` is invoked. + * @param {Function} func The function to restrict. + * @returns {Function} Returns the new restricted function. + * @example + * + * var saves = ['profile', 'settings']; + * + * var done = _.after(saves.length, function() { + * console.log('done saving!'); + * }); + * + * _.forEach(saves, function(type) { + * asyncSave({ 'type': type, 'complete': done }); + * }); + * // => Logs 'done saving!' after the two async saves have completed. + */ + function after(n, func) { + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + n = toInteger(n); + return function() { + if (--n < 1) { + return func.apply(this, arguments); + } + }; + } + + /** + * Creates a function that invokes `func`, with up to `n` arguments, + * ignoring any additional arguments. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Function + * @param {Function} func The function to cap arguments for. + * @param {number} [n=func.length] The arity cap. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Function} Returns the new capped function. + * @example + * + * _.map(['6', '8', '10'], _.ary(parseInt, 1)); + * // => [6, 8, 10] + */ + function ary(func, n, guard) { + n = guard ? undefined : n; + n = (func && n == null) ? func.length : n; + return createWrap(func, WRAP_ARY_FLAG, undefined, undefined, undefined, undefined, n); + } + + /** + * Creates a function that invokes `func`, with the `this` binding and arguments + * of the created function, while it's called less than `n` times. Subsequent + * calls to the created function return the result of the last `func` invocation. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Function + * @param {number} n The number of calls at which `func` is no longer invoked. + * @param {Function} func The function to restrict. + * @returns {Function} Returns the new restricted function. + * @example + * + * jQuery(element).on('click', _.before(5, addContactToList)); + * // => Allows adding up to 4 contacts to the list. + */ + function before(n, func) { + var result; + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + n = toInteger(n); + return function() { + if (--n > 0) { + result = func.apply(this, arguments); + } + if (n <= 1) { + func = undefined; + } + return result; + }; + } + + /** + * Creates a function that invokes `func` with the `this` binding of `thisArg` + * and `partials` prepended to the arguments it receives. + * + * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds, + * may be used as a placeholder for partially applied arguments. + * + * **Note:** Unlike native `Function#bind`, this method doesn't set the "length" + * property of bound functions. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to bind. + * @param {*} thisArg The `this` binding of `func`. + * @param {...*} [partials] The arguments to be partially applied. + * @returns {Function} Returns the new bound function. + * @example + * + * function greet(greeting, punctuation) { + * return greeting + ' ' + this.user + punctuation; + * } + * + * var object = { 'user': 'fred' }; + * + * var bound = _.bind(greet, object, 'hi'); + * bound('!'); + * // => 'hi fred!' + * + * // Bound with placeholders. + * var bound = _.bind(greet, object, _, '!'); + * bound('hi'); + * // => 'hi fred!' + */ + var bind = baseRest(function(func, thisArg, partials) { + var bitmask = WRAP_BIND_FLAG; + if (partials.length) { + var holders = replaceHolders(partials, getHolder(bind)); + bitmask |= WRAP_PARTIAL_FLAG; + } + return createWrap(func, bitmask, thisArg, partials, holders); + }); + + /** + * Creates a function that invokes the method at `object[key]` with `partials` + * prepended to the arguments it receives. + * + * This method differs from `_.bind` by allowing bound functions to reference + * methods that may be redefined or don't yet exist. See + * [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern) + * for more details. + * + * The `_.bindKey.placeholder` value, which defaults to `_` in monolithic + * builds, may be used as a placeholder for partially applied arguments. + * + * @static + * @memberOf _ + * @since 0.10.0 + * @category Function + * @param {Object} object The object to invoke the method on. + * @param {string} key The key of the method. + * @param {...*} [partials] The arguments to be partially applied. + * @returns {Function} Returns the new bound function. + * @example + * + * var object = { + * 'user': 'fred', + * 'greet': function(greeting, punctuation) { + * return greeting + ' ' + this.user + punctuation; + * } + * }; + * + * var bound = _.bindKey(object, 'greet', 'hi'); + * bound('!'); + * // => 'hi fred!' + * + * object.greet = function(greeting, punctuation) { + * return greeting + 'ya ' + this.user + punctuation; + * }; + * + * bound('!'); + * // => 'hiya fred!' + * + * // Bound with placeholders. + * var bound = _.bindKey(object, 'greet', _, '!'); + * bound('hi'); + * // => 'hiya fred!' + */ + var bindKey = baseRest(function(object, key, partials) { + var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG; + if (partials.length) { + var holders = replaceHolders(partials, getHolder(bindKey)); + bitmask |= WRAP_PARTIAL_FLAG; + } + return createWrap(key, bitmask, object, partials, holders); + }); + + /** + * Creates a function that accepts arguments of `func` and either invokes + * `func` returning its result, if at least `arity` number of arguments have + * been provided, or returns a function that accepts the remaining `func` + * arguments, and so on. The arity of `func` may be specified if `func.length` + * is not sufficient. + * + * The `_.curry.placeholder` value, which defaults to `_` in monolithic builds, + * may be used as a placeholder for provided arguments. + * + * **Note:** This method doesn't set the "length" property of curried functions. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Function + * @param {Function} func The function to curry. + * @param {number} [arity=func.length] The arity of `func`. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Function} Returns the new curried function. + * @example + * + * var abc = function(a, b, c) { + * return [a, b, c]; + * }; + * + * var curried = _.curry(abc); + * + * curried(1)(2)(3); + * // => [1, 2, 3] + * + * curried(1, 2)(3); + * // => [1, 2, 3] + * + * curried(1, 2, 3); + * // => [1, 2, 3] + * + * // Curried with placeholders. + * curried(1)(_, 3)(2); + * // => [1, 2, 3] + */ + function curry(func, arity, guard) { + arity = guard ? undefined : arity; + var result = createWrap(func, WRAP_CURRY_FLAG, undefined, undefined, undefined, undefined, undefined, arity); + result.placeholder = curry.placeholder; + return result; + } + + /** + * This method is like `_.curry` except that arguments are applied to `func` + * in the manner of `_.partialRight` instead of `_.partial`. + * + * The `_.curryRight.placeholder` value, which defaults to `_` in monolithic + * builds, may be used as a placeholder for provided arguments. + * + * **Note:** This method doesn't set the "length" property of curried functions. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Function + * @param {Function} func The function to curry. + * @param {number} [arity=func.length] The arity of `func`. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Function} Returns the new curried function. + * @example + * + * var abc = function(a, b, c) { + * return [a, b, c]; + * }; + * + * var curried = _.curryRight(abc); + * + * curried(3)(2)(1); + * // => [1, 2, 3] + * + * curried(2, 3)(1); + * // => [1, 2, 3] + * + * curried(1, 2, 3); + * // => [1, 2, 3] + * + * // Curried with placeholders. + * curried(3)(1, _)(2); + * // => [1, 2, 3] + */ + function curryRight(func, arity, guard) { + arity = guard ? undefined : arity; + var result = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined, undefined, undefined, undefined, undefined, arity); + result.placeholder = curryRight.placeholder; + return result; + } + + /** + * Creates a debounced function that delays invoking `func` until after `wait` + * milliseconds have elapsed since the last time the debounced function was + * invoked. The debounced function comes with a `cancel` method to cancel + * delayed `func` invocations and a `flush` method to immediately invoke them. + * Provide `options` to indicate whether `func` should be invoked on the + * leading and/or trailing edge of the `wait` timeout. The `func` is invoked + * with the last arguments provided to the debounced function. Subsequent + * calls to the debounced function return the result of the last `func` + * invocation. + * + * **Note:** If `leading` and `trailing` options are `true`, `func` is + * invoked on the trailing edge of the timeout only if the debounced function + * is invoked more than once during the `wait` timeout. + * + * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred + * until to the next tick, similar to `setTimeout` with a timeout of `0`. + * + * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) + * for details over the differences between `_.debounce` and `_.throttle`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to debounce. + * @param {number} [wait=0] The number of milliseconds to delay. + * @param {Object} [options={}] The options object. + * @param {boolean} [options.leading=false] + * Specify invoking on the leading edge of the timeout. + * @param {number} [options.maxWait] + * The maximum time `func` is allowed to be delayed before it's invoked. + * @param {boolean} [options.trailing=true] + * Specify invoking on the trailing edge of the timeout. + * @returns {Function} Returns the new debounced function. + * @example + * + * // Avoid costly calculations while the window size is in flux. + * jQuery(window).on('resize', _.debounce(calculateLayout, 150)); + * + * // Invoke `sendMail` when clicked, debouncing subsequent calls. + * jQuery(element).on('click', _.debounce(sendMail, 300, { + * 'leading': true, + * 'trailing': false + * })); + * + * // Ensure `batchLog` is invoked once after 1 second of debounced calls. + * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 }); + * var source = new EventSource('/stream'); + * jQuery(source).on('message', debounced); + * + * // Cancel the trailing debounced invocation. + * jQuery(window).on('popstate', debounced.cancel); + */ + function debounce(func, wait, options) { + var lastArgs, + lastThis, + maxWait, + result, + timerId, + lastCallTime, + lastInvokeTime = 0, + leading = false, + maxing = false, + trailing = true; + + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + wait = toNumber(wait) || 0; + if (isObject(options)) { + leading = !!options.leading; + maxing = 'maxWait' in options; + maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait; + trailing = 'trailing' in options ? !!options.trailing : trailing; + } + + function invokeFunc(time) { + var args = lastArgs, + thisArg = lastThis; + + lastArgs = lastThis = undefined; + lastInvokeTime = time; + result = func.apply(thisArg, args); + return result; + } + + function leadingEdge(time) { + // Reset any `maxWait` timer. + lastInvokeTime = time; + // Start the timer for the trailing edge. + timerId = setTimeout(timerExpired, wait); + // Invoke the leading edge. + return leading ? invokeFunc(time) : result; + } + + function remainingWait(time) { + var timeSinceLastCall = time - lastCallTime, + timeSinceLastInvoke = time - lastInvokeTime, + timeWaiting = wait - timeSinceLastCall; + + return maxing + ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) + : timeWaiting; + } + + function shouldInvoke(time) { + var timeSinceLastCall = time - lastCallTime, + timeSinceLastInvoke = time - lastInvokeTime; + + // Either this is the first call, activity has stopped and we're at the + // trailing edge, the system time has gone backwards and we're treating + // it as the trailing edge, or we've hit the `maxWait` limit. + return (lastCallTime === undefined || (timeSinceLastCall >= wait) || + (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait)); + } + + function timerExpired() { + var time = now(); + if (shouldInvoke(time)) { + return trailingEdge(time); + } + // Restart the timer. + timerId = setTimeout(timerExpired, remainingWait(time)); + } + + function trailingEdge(time) { + timerId = undefined; + + // Only invoke if we have `lastArgs` which means `func` has been + // debounced at least once. + if (trailing && lastArgs) { + return invokeFunc(time); + } + lastArgs = lastThis = undefined; + return result; + } + + function cancel() { + if (timerId !== undefined) { + clearTimeout(timerId); + } + lastInvokeTime = 0; + lastArgs = lastCallTime = lastThis = timerId = undefined; + } + + function flush() { + return timerId === undefined ? result : trailingEdge(now()); + } + + function debounced() { + var time = now(), + isInvoking = shouldInvoke(time); + + lastArgs = arguments; + lastThis = this; + lastCallTime = time; + + if (isInvoking) { + if (timerId === undefined) { + return leadingEdge(lastCallTime); + } + if (maxing) { + // Handle invocations in a tight loop. + clearTimeout(timerId); + timerId = setTimeout(timerExpired, wait); + return invokeFunc(lastCallTime); + } + } + if (timerId === undefined) { + timerId = setTimeout(timerExpired, wait); + } + return result; + } + debounced.cancel = cancel; + debounced.flush = flush; + return debounced; + } + + /** + * Defers invoking the `func` until the current call stack has cleared. Any + * additional arguments are provided to `func` when it's invoked. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to defer. + * @param {...*} [args] The arguments to invoke `func` with. + * @returns {number} Returns the timer id. + * @example + * + * _.defer(function(text) { + * console.log(text); + * }, 'deferred'); + * // => Logs 'deferred' after one millisecond. + */ + var defer = baseRest(function(func, args) { + return baseDelay(func, 1, args); + }); + + /** + * Invokes `func` after `wait` milliseconds. Any additional arguments are + * provided to `func` when it's invoked. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to delay. + * @param {number} wait The number of milliseconds to delay invocation. + * @param {...*} [args] The arguments to invoke `func` with. + * @returns {number} Returns the timer id. + * @example + * + * _.delay(function(text) { + * console.log(text); + * }, 1000, 'later'); + * // => Logs 'later' after one second. + */ + var delay = baseRest(function(func, wait, args) { + return baseDelay(func, toNumber(wait) || 0, args); + }); + + /** + * Creates a function that invokes `func` with arguments reversed. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Function + * @param {Function} func The function to flip arguments for. + * @returns {Function} Returns the new flipped function. + * @example + * + * var flipped = _.flip(function() { + * return _.toArray(arguments); + * }); + * + * flipped('a', 'b', 'c', 'd'); + * // => ['d', 'c', 'b', 'a'] + */ + function flip(func) { + return createWrap(func, WRAP_FLIP_FLAG); + } + + /** + * Creates a function that memoizes the result of `func`. If `resolver` is + * provided, it determines 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 map cache key. The `func` + * is invoked with the `this` binding of the memoized function. + * + * **Note:** The cache is exposed as the `cache` property on the memoized + * function. Its creation may be customized by replacing the `_.memoize.Cache` + * constructor with one whose instances implement the + * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object) + * method interface of `clear`, `delete`, `get`, `has`, and `set`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to have its output memoized. + * @param {Function} [resolver] The function to resolve the cache key. + * @returns {Function} Returns the new memoized function. + * @example + * + * var object = { 'a': 1, 'b': 2 }; + * var other = { 'c': 3, 'd': 4 }; + * + * var values = _.memoize(_.values); + * values(object); + * // => [1, 2] + * + * values(other); + * // => [3, 4] + * + * object.a = 2; + * values(object); + * // => [1, 2] + * + * // Modify the result cache. + * values.cache.set(object, ['a', 'b']); + * values(object); + * // => ['a', 'b'] + * + * // Replace `_.memoize.Cache`. + * _.memoize.Cache = WeakMap; + */ + function memoize(func, resolver) { + if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) { + throw new TypeError(FUNC_ERROR_TEXT); + } + var memoized = function() { + var args = arguments, + key = resolver ? resolver.apply(this, args) : args[0], + cache = memoized.cache; + + if (cache.has(key)) { + return cache.get(key); + } + var result = func.apply(this, args); + memoized.cache = cache.set(key, result) || cache; + return result; + }; + memoized.cache = new (memoize.Cache || MapCache); + return memoized; + } + + // Expose `MapCache`. + memoize.Cache = MapCache; + + /** + * Creates a function that negates the result of the predicate `func`. The + * `func` predicate is invoked with the `this` binding and arguments of the + * created function. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Function + * @param {Function} predicate The predicate to negate. + * @returns {Function} Returns the new negated function. + * @example + * + * function isEven(n) { + * return n % 2 == 0; + * } + * + * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven)); + * // => [1, 3, 5] + */ + function negate(predicate) { + if (typeof predicate != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + return function() { + var args = arguments; + switch (args.length) { + case 0: return !predicate.call(this); + case 1: return !predicate.call(this, args[0]); + case 2: return !predicate.call(this, args[0], args[1]); + case 3: return !predicate.call(this, args[0], args[1], args[2]); + } + return !predicate.apply(this, args); + }; + } + + /** + * Creates a function that is restricted to invoking `func` once. Repeat calls + * to the function return the value of the first invocation. The `func` is + * invoked with the `this` binding and arguments of the created function. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to restrict. + * @returns {Function} Returns the new restricted function. + * @example + * + * var initialize = _.once(createApplication); + * initialize(); + * initialize(); + * // => `createApplication` is invoked once + */ + function once(func) { + return before(2, func); } - // ensure `new lodashWrapper` is an instance of `lodash` - lodashWrapper.prototype = lodash.prototype; /** - * An object used to flag environments features. + * Creates a function that invokes `func` with its arguments transformed. * * @static + * @since 4.0.0 * @memberOf _ - * @type Object + * @category Function + * @param {Function} func The function to wrap. + * @param {...(Function|Function[])} [transforms=[_.identity]] + * The argument transforms. + * @returns {Function} Returns the new function. + * @example + * + * function doubled(n) { + * return n * 2; + * } + * + * function square(n) { + * return n * n; + * } + * + * var func = _.overArgs(function(x, y) { + * return [x, y]; + * }, [square, doubled]); + * + * func(9, 3); + * // => [81, 6] + * + * func(10, 5); + * // => [100, 10] */ - var support = lodash.support = {}; + var overArgs = castRest(function(func, transforms) { + transforms = (transforms.length == 1 && isArray(transforms[0])) + ? arrayMap(transforms[0], baseUnary(getIteratee())) + : arrayMap(baseFlatten(transforms, 1), baseUnary(getIteratee())); - (function() { - var ctor = function() { this.x = 1; }, - object = { '0': 1, 'length': 1 }, - props = []; + var funcsLength = transforms.length; + return baseRest(function(args) { + var index = -1, + length = nativeMin(args.length, funcsLength); - ctor.prototype = { 'valueOf': 1, 'y': 1 }; - for (var key in new ctor) { props.push(key); } - for (key in arguments) { } + while (++index < length) { + args[index] = transforms[index].call(this, args[index]); + } + return apply(func, this, args); + }); + }); - /** - * Detect if an `arguments` object's [[Class]] is resolvable (all but Firefox < 4, IE < 9). - * - * @memberOf _.support - * @type boolean - */ - support.argsClass = toString.call(arguments) == argsClass; + /** + * Creates a function that invokes `func` with `partials` prepended to the + * arguments it receives. This method is like `_.bind` except it does **not** + * alter the `this` binding. + * + * The `_.partial.placeholder` value, which defaults to `_` in monolithic + * builds, may be used as a placeholder for partially applied arguments. + * + * **Note:** This method doesn't set the "length" property of partially + * applied functions. + * + * @static + * @memberOf _ + * @since 0.2.0 + * @category Function + * @param {Function} func The function to partially apply arguments to. + * @param {...*} [partials] The arguments to be partially applied. + * @returns {Function} Returns the new partially applied function. + * @example + * + * function greet(greeting, name) { + * return greeting + ' ' + name; + * } + * + * var sayHelloTo = _.partial(greet, 'hello'); + * sayHelloTo('fred'); + * // => 'hello fred' + * + * // Partially applied with placeholders. + * var greetFred = _.partial(greet, _, 'fred'); + * greetFred('hi'); + * // => 'hi fred' + */ + var partial = baseRest(function(func, partials) { + var holders = replaceHolders(partials, getHolder(partial)); + return createWrap(func, WRAP_PARTIAL_FLAG, undefined, partials, holders); + }); - /** - * Detect if `arguments` objects are `Object` objects (all but Narwhal and Opera < 10.5). - * - * @memberOf _.support - * @type boolean - */ - support.argsObject = arguments.constructor == Object && !(arguments instanceof Array); + /** + * This method is like `_.partial` except that partially applied arguments + * are appended to the arguments it receives. + * + * The `_.partialRight.placeholder` value, which defaults to `_` in monolithic + * builds, may be used as a placeholder for partially applied arguments. + * + * **Note:** This method doesn't set the "length" property of partially + * applied functions. + * + * @static + * @memberOf _ + * @since 1.0.0 + * @category Function + * @param {Function} func The function to partially apply arguments to. + * @param {...*} [partials] The arguments to be partially applied. + * @returns {Function} Returns the new partially applied function. + * @example + * + * function greet(greeting, name) { + * return greeting + ' ' + name; + * } + * + * var greetFred = _.partialRight(greet, 'fred'); + * greetFred('hi'); + * // => 'hi fred' + * + * // Partially applied with placeholders. + * var sayHelloTo = _.partialRight(greet, 'hello', _); + * sayHelloTo('fred'); + * // => 'hello fred' + */ + var partialRight = baseRest(function(func, partials) { + var holders = replaceHolders(partials, getHolder(partialRight)); + return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, undefined, partials, holders); + }); - /** - * Detect if `name` or `message` properties of `Error.prototype` are - * enumerable by default. (IE < 9, Safari < 5.1) - * - * @memberOf _.support - * @type boolean - */ - support.enumErrorProps = propertyIsEnumerable.call(errorProto, 'message') || propertyIsEnumerable.call(errorProto, 'name'); + /** + * Creates a function that invokes `func` with arguments arranged according + * to the specified `indexes` where the argument value at the first index is + * provided as the first argument, the argument value at the second index is + * provided as the second argument, and so on. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Function + * @param {Function} func The function to rearrange arguments for. + * @param {...(number|number[])} indexes The arranged argument indexes. + * @returns {Function} Returns the new function. + * @example + * + * var rearged = _.rearg(function(a, b, c) { + * return [a, b, c]; + * }, [2, 0, 1]); + * + * rearged('b', 'c', 'a') + * // => ['a', 'b', 'c'] + */ + var rearg = flatRest(function(func, indexes) { + return createWrap(func, WRAP_REARG_FLAG, undefined, undefined, undefined, indexes); + }); - /** - * Detect if `prototype` properties are enumerable by default. - * - * Firefox < 3.6, Opera > 9.50 - Opera < 11.60, and Safari < 5.1 - * (if the prototype or a property on the prototype has been set) - * incorrectly sets a function's `prototype` property [[Enumerable]] - * value to `true`. - * - * @memberOf _.support - * @type boolean - */ - support.enumPrototypes = propertyIsEnumerable.call(ctor, 'prototype'); + /** + * Creates a function that invokes `func` with the `this` binding of the + * created function and arguments from `start` and beyond provided as + * an array. + * + * **Note:** This method is based on the + * [rest parameter](https://mdn.io/rest_parameters). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Function + * @param {Function} func The function to apply a rest parameter to. + * @param {number} [start=func.length-1] The start position of the rest parameter. + * @returns {Function} Returns the new function. + * @example + * + * var say = _.rest(function(what, names) { + * return what + ' ' + _.initial(names).join(', ') + + * (_.size(names) > 1 ? ', & ' : '') + _.last(names); + * }); + * + * say('hello', 'fred', 'barney', 'pebbles'); + * // => 'hello fred, barney, & pebbles' + */ + function rest(func, start) { + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + start = start === undefined ? start : toInteger(start); + return baseRest(func, start); + } - /** - * Detect if functions can be decompiled by `Function#toString` - * (all but PS3 and older Opera mobile browsers & avoided in Windows 8 apps). - * - * @memberOf _.support - * @type boolean - */ - support.funcDecomp = !isNative(context.WinRTError) && reThis.test(runInContext); + /** + * Creates a function that invokes `func` with the `this` binding of the + * create function and an array of arguments much like + * [`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply). + * + * **Note:** This method is based on the + * [spread operator](https://mdn.io/spread_operator). + * + * @static + * @memberOf _ + * @since 3.2.0 + * @category Function + * @param {Function} func The function to spread arguments over. + * @param {number} [start=0] The start position of the spread. + * @returns {Function} Returns the new function. + * @example + * + * var say = _.spread(function(who, what) { + * return who + ' says ' + what; + * }); + * + * say(['fred', 'hello']); + * // => 'fred says hello' + * + * var numbers = Promise.all([ + * Promise.resolve(40), + * Promise.resolve(36) + * ]); + * + * numbers.then(_.spread(function(x, y) { + * return x + y; + * })); + * // => a Promise of 76 + */ + function spread(func, start) { + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + start = start == null ? 0 : nativeMax(toInteger(start), 0); + return baseRest(function(args) { + var array = args[start], + otherArgs = castSlice(args, 0, start); - /** - * Detect if `Function#name` is supported (all but IE). - * - * @memberOf _.support - * @type boolean - */ - support.funcNames = typeof Function.name == 'string'; + if (array) { + arrayPush(otherArgs, array); + } + return apply(func, this, otherArgs); + }); + } - /** - * Detect if `arguments` object indexes are non-enumerable - * (Firefox < 4, IE < 9, PhantomJS, Safari < 5.1). - * - * @memberOf _.support - * @type boolean - */ - support.nonEnumArgs = key != 0; + /** + * Creates a throttled function that only invokes `func` at most once per + * every `wait` milliseconds. The throttled function comes with a `cancel` + * method to cancel delayed `func` invocations and a `flush` method to + * immediately invoke them. Provide `options` to indicate whether `func` + * should be invoked on the leading and/or trailing edge of the `wait` + * timeout. The `func` is invoked with the last arguments provided to the + * throttled function. Subsequent calls to the throttled function return the + * result of the last `func` invocation. + * + * **Note:** If `leading` and `trailing` options are `true`, `func` is + * invoked on the trailing edge of the timeout only if the throttled function + * is invoked more than once during the `wait` timeout. + * + * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred + * until to the next tick, similar to `setTimeout` with a timeout of `0`. + * + * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) + * for details over the differences between `_.throttle` and `_.debounce`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to throttle. + * @param {number} [wait=0] The number of milliseconds to throttle invocations to. + * @param {Object} [options={}] The options object. + * @param {boolean} [options.leading=true] + * Specify invoking on the leading edge of the timeout. + * @param {boolean} [options.trailing=true] + * Specify invoking on the trailing edge of the timeout. + * @returns {Function} Returns the new throttled function. + * @example + * + * // Avoid excessively updating the position while scrolling. + * jQuery(window).on('scroll', _.throttle(updatePosition, 100)); + * + * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes. + * var throttled = _.throttle(renewToken, 300000, { 'trailing': false }); + * jQuery(element).on('click', throttled); + * + * // Cancel the trailing throttled invocation. + * jQuery(window).on('popstate', throttled.cancel); + */ + function throttle(func, wait, options) { + var leading = true, + trailing = true; - /** - * Detect if properties shadowing those on `Object.prototype` are non-enumerable. - * - * In IE < 9 an objects own properties, shadowing non-enumerable ones, are - * made non-enumerable as well (a.k.a the JScript [[DontEnum]] bug). - * - * @memberOf _.support - * @type boolean - */ - support.nonEnumShadows = !/valueOf/.test(props); + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + if (isObject(options)) { + leading = 'leading' in options ? !!options.leading : leading; + trailing = 'trailing' in options ? !!options.trailing : trailing; + } + return debounce(func, wait, { + 'leading': leading, + 'maxWait': wait, + 'trailing': trailing + }); + } - /** - * Detect if own properties are iterated after inherited properties (all but IE < 9). - * - * @memberOf _.support - * @type boolean - */ - support.ownLast = props[0] != 'x'; + /** + * Creates a function that accepts up to one argument, ignoring any + * additional arguments. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Function + * @param {Function} func The function to cap arguments for. + * @returns {Function} Returns the new capped function. + * @example + * + * _.map(['6', '8', '10'], _.unary(parseInt)); + * // => [6, 8, 10] + */ + function unary(func) { + return ary(func, 1); + } - /** - * Detect if `Array#shift` and `Array#splice` augment array-like objects correctly. - * - * Firefox < 10, IE compatibility mode, and IE < 9 have buggy Array `shift()` - * and `splice()` functions that fail to remove the last element, `value[0]`, - * of array-like objects even though the `length` property is set to `0`. - * The `shift()` method is buggy in IE 8 compatibility mode, while `splice()` - * is buggy regardless of mode in IE < 9 and buggy in compatibility mode in IE 9. - * - * @memberOf _.support - * @type boolean - */ - support.spliceObjects = (arrayRef.splice.call(object, 0, 1), !object[0]); + /** + * Creates a function that provides `value` to `wrapper` as its first + * argument. Any additional arguments provided to the function are appended + * to those provided to the `wrapper`. The wrapper is invoked with the `this` + * binding of the created function. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {*} value The value to wrap. + * @param {Function} [wrapper=identity] The wrapper function. + * @returns {Function} Returns the new function. + * @example + * + * var p = _.wrap(_.escape, function(func, text) { + * return '

' + func(text) + '

'; + * }); + * + * p('fred, barney, & pebbles'); + * // => '

fred, barney, & pebbles

' + */ + function wrap(value, wrapper) { + return partial(castFunction(wrapper), value); + } - /** - * Detect lack of support for accessing string characters by index. - * - * IE < 8 can't access characters by index and IE 8 can only access - * characters by index on string literals. - * - * @memberOf _.support - * @type boolean - */ - support.unindexedChars = ('x'[0] + Object('x')[0]) != 'xx'; + /*------------------------------------------------------------------------*/ - /** - * Detect if a DOM node's [[Class]] is resolvable (all but IE < 9) - * and that the JS engine errors when attempting to coerce an object to - * a string without a `toString` function. - * - * @memberOf _.support - * @type boolean - */ - try { - support.nodeClass = !(toString.call(document) == objectClass && !({ 'toString': 0 } + '')); - } catch(e) { - support.nodeClass = true; + /** + * Casts `value` as an array if it's not one. + * + * @static + * @memberOf _ + * @since 4.4.0 + * @category Lang + * @param {*} value The value to inspect. + * @returns {Array} Returns the cast array. + * @example + * + * _.castArray(1); + * // => [1] + * + * _.castArray({ 'a': 1 }); + * // => [{ 'a': 1 }] + * + * _.castArray('abc'); + * // => ['abc'] + * + * _.castArray(null); + * // => [null] + * + * _.castArray(undefined); + * // => [undefined] + * + * _.castArray(); + * // => [] + * + * var array = [1, 2, 3]; + * console.log(_.castArray(array) === array); + * // => true + */ + function castArray() { + if (!arguments.length) { + return []; } - }(1)); + var value = arguments[0]; + return isArray(value) ? value : [value]; + } + + /** + * Creates a shallow clone of `value`. + * + * **Note:** This method is loosely based on the + * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm) + * and supports cloning arrays, array buffers, booleans, date objects, maps, + * numbers, `Object` objects, regexes, sets, strings, symbols, and typed + * arrays. The own enumerable properties of `arguments` objects are cloned + * as plain objects. An empty object is returned for uncloneable values such + * as error objects, functions, DOM nodes, and WeakMaps. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to clone. + * @returns {*} Returns the cloned value. + * @see _.cloneDeep + * @example + * + * var objects = [{ 'a': 1 }, { 'b': 2 }]; + * + * var shallow = _.clone(objects); + * console.log(shallow[0] === objects[0]); + * // => true + */ + function clone(value) { + return baseClone(value, CLONE_SYMBOLS_FLAG); + } + + /** + * This method is like `_.clone` except that it accepts `customizer` which + * is invoked to produce the cloned value. If `customizer` returns `undefined`, + * cloning is handled by the method instead. The `customizer` is invoked with + * up to four arguments; (value [, index|key, object, stack]). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to clone. + * @param {Function} [customizer] The function to customize cloning. + * @returns {*} Returns the cloned value. + * @see _.cloneDeepWith + * @example + * + * function customizer(value) { + * if (_.isElement(value)) { + * return value.cloneNode(false); + * } + * } + * + * var el = _.cloneWith(document.body, customizer); + * + * console.log(el === document.body); + * // => false + * console.log(el.nodeName); + * // => 'BODY' + * console.log(el.childNodes.length); + * // => 0 + */ + function cloneWith(value, customizer) { + customizer = typeof customizer == 'function' ? customizer : undefined; + return baseClone(value, CLONE_SYMBOLS_FLAG, customizer); + } + + /** + * This method is like `_.clone` except that it recursively clones `value`. + * + * @static + * @memberOf _ + * @since 1.0.0 + * @category Lang + * @param {*} value The value to recursively clone. + * @returns {*} Returns the deep cloned value. + * @see _.clone + * @example + * + * var objects = [{ 'a': 1 }, { 'b': 2 }]; + * + * var deep = _.cloneDeep(objects); + * console.log(deep[0] === objects[0]); + * // => false + */ + function cloneDeep(value) { + return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG); + } + + /** + * This method is like `_.cloneWith` except that it recursively clones `value`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to recursively clone. + * @param {Function} [customizer] The function to customize cloning. + * @returns {*} Returns the deep cloned value. + * @see _.cloneWith + * @example + * + * function customizer(value) { + * if (_.isElement(value)) { + * return value.cloneNode(true); + * } + * } + * + * var el = _.cloneDeepWith(document.body, customizer); + * + * console.log(el === document.body); + * // => false + * console.log(el.nodeName); + * // => 'BODY' + * console.log(el.childNodes.length); + * // => 20 + */ + function cloneDeepWith(value, customizer) { + customizer = typeof customizer == 'function' ? customizer : undefined; + return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer); + } /** - * By default, the template delimiters used by Lo-Dash are similar to those in - * embedded Ruby (ERB). Change the following template settings to use alternative - * delimiters. + * Checks if `object` conforms to `source` by invoking the predicate + * properties of `source` with the corresponding property values of `object`. + * + * **Note:** This method is equivalent to `_.conforms` when `source` is + * partially applied. * * @static * @memberOf _ - * @type Object + * @since 4.14.0 + * @category Lang + * @param {Object} object The object to inspect. + * @param {Object} source The object of property predicates to conform to. + * @returns {boolean} Returns `true` if `object` conforms, else `false`. + * @example + * + * var object = { 'a': 1, 'b': 2 }; + * + * _.conformsTo(object, { 'b': function(n) { return n > 1; } }); + * // => true + * + * _.conformsTo(object, { 'b': function(n) { return n > 2; } }); + * // => false */ - lodash.templateSettings = { - - /** - * Used to detect `data` property values to be HTML-escaped. - * - * @memberOf _.templateSettings - * @type RegExp - */ - 'escape': /<%-([\s\S]+?)%>/g, - - /** - * Used to detect code to be evaluated. - * - * @memberOf _.templateSettings - * @type RegExp - */ - 'evaluate': /<%([\s\S]+?)%>/g, - - /** - * Used to detect `data` property values to inject. - * - * @memberOf _.templateSettings - * @type RegExp - */ - 'interpolate': reInterpolate, - - /** - * Used to reference the data object in the template text. - * - * @memberOf _.templateSettings - * @type string - */ - 'variable': '', - - /** - * Used to import variables into the compiled template. - * - * @memberOf _.templateSettings - * @type Object - */ - 'imports': { - - /** - * A reference to the `lodash` function. - * - * @memberOf _.templateSettings.imports - * @type Function - */ - '_': lodash - } - }; - - /*--------------------------------------------------------------------------*/ - - /** - * The template used to create iterator functions. - * - * @private - * @param {Object} data The data object used to populate the text. - * @returns {string} Returns the interpolated text. - */ - var iteratorTemplate = template( - // the `iterable` may be reassigned by the `top` snippet - 'var index, iterable = <%= firstArg %>, ' + - // assign the `result` variable an initial value - 'result = <%= init %>;\n' + - // exit early if the first argument is falsey - 'if (!iterable) return result;\n' + - // add code before the iteration branches - '<%= top %>;' + - - // array-like iteration: - '<% if (array) { %>\n' + - 'var length = iterable.length; index = -1;\n' + - 'if (<%= array %>) {' + - - // add support for accessing string characters by index if needed - ' <% if (support.unindexedChars) { %>\n' + - ' if (isString(iterable)) {\n' + - " iterable = iterable.split('')\n" + - ' }' + - ' <% } %>\n' + - - // iterate over the array-like value - ' while (++index < length) {\n' + - ' <%= loop %>;\n' + - ' }\n' + - '}\n' + - 'else {' + - - // object iteration: - // add support for iterating over `arguments` objects if needed - ' <% } else if (support.nonEnumArgs) { %>\n' + - ' var length = iterable.length; index = -1;\n' + - ' if (length && isArguments(iterable)) {\n' + - ' while (++index < length) {\n' + - " index += '';\n" + - ' <%= loop %>;\n' + - ' }\n' + - ' } else {' + - ' <% } %>' + - - // avoid iterating over `prototype` properties in older Firefox, Opera, and Safari - ' <% if (support.enumPrototypes) { %>\n' + - " var skipProto = typeof iterable == 'function';\n" + - ' <% } %>' + - - // avoid iterating over `Error.prototype` properties in older IE and Safari - ' <% if (support.enumErrorProps) { %>\n' + - ' var skipErrorProps = iterable === errorProto || iterable instanceof Error;\n' + - ' <% } %>' + - - // define conditions used in the loop - ' <%' + - ' var conditions = [];' + - ' if (support.enumPrototypes) { conditions.push(\'!(skipProto && index == "prototype")\'); }' + - ' if (support.enumErrorProps) { conditions.push(\'!(skipErrorProps && (index == "message" || index == "name"))\'); }' + - ' %>' + - - // iterate own properties using `Object.keys` - ' <% if (useHas && keys) { %>\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) { %> if (<%= conditions.join(' && ') %>) {\n <% } %>" + - ' <%= loop %>;' + - ' <% if (conditions.length) { %>\n }<% } %>\n' + - ' }' + - - // else using a for-in loop - ' <% } else { %>\n' + - ' for (index in iterable) {\n<%' + - ' if (useHas) { conditions.push("hasOwnProperty.call(iterable, index)"); }' + - " if (conditions.length) { %> if (<%= conditions.join(' && ') %>) {\n <% } %>" + - ' <%= loop %>;' + - ' <% if (conditions.length) { %>\n }<% } %>\n' + - ' }' + - - // Because IE < 9 can't set the `[[Enumerable]]` attribute of an - // existing property and the `constructor` property of a prototype - // defaults to non-enumerable, Lo-Dash skips the `constructor` - // property when it infers it's iterating over a `prototype` object. - ' <% if (support.nonEnumShadows) { %>\n\n' + - ' if (iterable !== objectProto) {\n' + - " var ctor = iterable.constructor,\n" + - ' isProto = iterable === (ctor && ctor.prototype),\n' + - ' className = iterable === stringProto ? stringClass : iterable === errorProto ? errorClass : toString.call(iterable),\n' + - ' nonEnum = nonEnumProps[className];\n' + - ' <% for (k = 0; k < 7; k++) { %>\n' + - " index = '<%= shadowedProps[k] %>';\n" + - ' if ((!(isProto && nonEnum[index]) && hasOwnProperty.call(iterable, index))<%' + - ' if (!useHas) { %> || (!nonEnum[index] && iterable[index] !== objectProto[index])<% }' + - ' %>) {\n' + - ' <%= loop %>;\n' + - ' }' + - ' <% } %>\n' + - ' }' + - ' <% } %>' + - ' <% } %>' + - ' <% if (array || support.nonEnumArgs) { %>\n}<% } %>\n' + - - // add code to the bottom of the iteration function - '<%= bottom %>;\n' + - // finally, return the `result` - 'return result' - ); - - /*--------------------------------------------------------------------------*/ + function conformsTo(object, source) { + return source == null || baseConformsTo(object, source, keys(source)); + } /** - * The base implementation of `_.bind` that creates the bound function and - * sets its meta data. + * Performs a + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * comparison between two values to determine if they are equivalent. * - * @private - * @param {Array} bindData The bind data array. - * @returns {Function} Returns the new bound function. + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * var object = { 'a': 1 }; + * var other = { 'a': 1 }; + * + * _.eq(object, object); + * // => true + * + * _.eq(object, other); + * // => false + * + * _.eq('a', 'a'); + * // => true + * + * _.eq('a', Object('a')); + * // => false + * + * _.eq(NaN, NaN); + * // => true */ - function baseBind(bindData) { - var func = bindData[0], - partialArgs = bindData[2], - thisArg = bindData[4]; - - function bound() { - // `Function#bind` spec - // http://es5.github.io/#x15.3.4.5 - if (partialArgs) { - // avoid `arguments` object deoptimizations by using `slice` instead - // of `Array.prototype.slice.call` and not assigning `arguments` to a - // variable as a ternary expression - var args = slice(partialArgs); - push.apply(args, arguments); - } - // mimic the constructor's `return` behavior - // http://es5.github.io/#x13.2.2 - if (this instanceof bound) { - // ensure `new bound` is an instance of `func` - var thisBinding = baseCreate(func.prototype), - result = func.apply(thisBinding, args || arguments); - return isObject(result) ? result : thisBinding; - } - return func.apply(thisArg, args || arguments); - } - setBindData(bound, bindData); - return bound; + function eq(value, other) { + return value === other || (value !== value && other !== other); } /** - * The base implementation of `_.clone` without argument juggling or support - * for `thisArg` binding. + * Checks if `value` is greater than `other`. * - * @private - * @param {*} value The value to clone. - * @param {boolean} [isDeep=false] Specify a deep clone. - * @param {Function} [callback] The function to customize cloning values. - * @param {Array} [stackA=[]] Tracks traversed source objects. - * @param {Array} [stackB=[]] Associates clones with source counterparts. - * @returns {*} Returns the cloned value. + * @static + * @memberOf _ + * @since 3.9.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if `value` is greater than `other`, + * else `false`. + * @see _.lt + * @example + * + * _.gt(3, 1); + * // => true + * + * _.gt(3, 3); + * // => false + * + * _.gt(1, 3); + * // => false */ - function baseClone(value, isDeep, callback, stackA, stackB) { - if (callback) { - var result = callback(value); - if (typeof result != 'undefined') { - return result; - } - } - // inspect [[Class]] - var isObj = isObject(value); - if (isObj) { - var className = toString.call(value); - if (!cloneableClasses[className] || (!support.nodeClass && isNode(value))) { - return value; - } - var ctor = ctorByClass[className]; - switch (className) { - case boolClass: - case dateClass: - return new ctor(+value); + var gt = createRelationalOperation(baseGt); - case numberClass: - case stringClass: - return new ctor(value); - - case regexpClass: - result = ctor(value.source, reFlags.exec(value)); - result.lastIndex = value.lastIndex; - return result; - } - } else { - return value; - } - var isArr = isArray(value); - if (isDeep) { - // check for circular references and return corresponding clone - var initedStack = !stackA; - stackA || (stackA = getArray()); - stackB || (stackB = getArray()); + /** + * Checks if `value` is greater than or equal to `other`. + * + * @static + * @memberOf _ + * @since 3.9.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if `value` is greater than or equal to + * `other`, else `false`. + * @see _.lte + * @example + * + * _.gte(3, 1); + * // => true + * + * _.gte(3, 3); + * // => true + * + * _.gte(1, 3); + * // => false + */ + var gte = createRelationalOperation(function(value, other) { + return value >= other; + }); - var length = stackA.length; - while (length--) { - if (stackA[length] == value) { - return stackB[length]; - } - } - result = isArr ? ctor(value.length) : {}; - } - else { - result = isArr ? slice(value) : assign({}, value); - } - // add array properties assigned by `RegExp#exec` - if (isArr) { - if (hasOwnProperty.call(value, 'index')) { - result.index = value.index; - } - if (hasOwnProperty.call(value, 'input')) { - result.input = value.input; - } - } - // exit for shallow clone - if (!isDeep) { - return result; - } - // add the source value to the stack of traversed objects - // and associate it with its clone - stackA.push(value); - stackB.push(result); + /** + * Checks if `value` is likely an `arguments` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an `arguments` object, + * else `false`. + * @example + * + * _.isArguments(function() { return arguments; }()); + * // => true + * + * _.isArguments([1, 2, 3]); + * // => false + */ + var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) { + return isObjectLike(value) && hasOwnProperty.call(value, 'callee') && + !propertyIsEnumerable.call(value, 'callee'); + }; - // recursively populate clone (susceptible to call stack limits) - (isArr ? baseEach : forOwn)(value, function(objValue, key) { - result[key] = baseClone(objValue, isDeep, callback, stackA, stackB); - }); + /** + * Checks if `value` is classified as an `Array` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array, else `false`. + * @example + * + * _.isArray([1, 2, 3]); + * // => true + * + * _.isArray(document.body.children); + * // => false + * + * _.isArray('abc'); + * // => false + * + * _.isArray(_.noop); + * // => false + */ + var isArray = Array.isArray; - if (initedStack) { - releaseArray(stackA); - releaseArray(stackB); - } - return result; - } + /** + * Checks if `value` is classified as an `ArrayBuffer` object. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`. + * @example + * + * _.isArrayBuffer(new ArrayBuffer(2)); + * // => true + * + * _.isArrayBuffer(new Array(2)); + * // => false + */ + var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer; /** - * The base implementation of `_.create` without support for assigning - * properties to the created object. + * Checks if `value` is array-like. A value is considered array-like if it's + * not a function and has a `value.length` that's an integer greater than or + * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`. * - * @private - * @param {Object} prototype The object to inherit from. - * @returns {Object} Returns the new object. + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is array-like, else `false`. + * @example + * + * _.isArrayLike([1, 2, 3]); + * // => true + * + * _.isArrayLike(document.body.children); + * // => true + * + * _.isArrayLike('abc'); + * // => true + * + * _.isArrayLike(_.noop); + * // => false */ - function baseCreate(prototype, properties) { - return isObject(prototype) ? nativeCreate(prototype) : {}; - } - // fallback for browsers without `Object.create` - if (!nativeCreate) { - baseCreate = (function() { - function Object() {} - return function(prototype) { - if (isObject(prototype)) { - Object.prototype = prototype; - var result = new Object; - Object.prototype = null; - } - return result || context.Object(); - }; - }()); + function isArrayLike(value) { + return value != null && isLength(value.length) && !isFunction(value); } /** - * The base implementation of `_.createCallback` without support for creating - * "_.pluck" or "_.where" style callbacks. + * This method is like `_.isArrayLike` except that it also checks if `value` + * is an object. * - * @private - * @param {*} [func=identity] The value to convert to a callback. - * @param {*} [thisArg] The `this` binding of the created callback. - * @param {number} [argCount] The number of arguments the callback accepts. - * @returns {Function} Returns a callback function. + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array-like object, + * else `false`. + * @example + * + * _.isArrayLikeObject([1, 2, 3]); + * // => true + * + * _.isArrayLikeObject(document.body.children); + * // => true + * + * _.isArrayLikeObject('abc'); + * // => false + * + * _.isArrayLikeObject(_.noop); + * // => false */ - function baseCreateCallback(func, thisArg, argCount) { - if (typeof func != 'function') { - return identity; - } - // exit early for no `thisArg` or already bound by `Function#bind` - if (typeof thisArg == 'undefined' || !('prototype' in func)) { - return func; - } - var bindData = func.__bindData__; - if (typeof bindData == 'undefined') { - if (support.funcNames) { - bindData = !func.name; - } - bindData = bindData || !support.funcDecomp; - if (!bindData) { - var source = fnToString.call(func); - if (!support.funcNames) { - bindData = !reFuncName.test(source); - } - if (!bindData) { - // checks if `func` references the `this` keyword and stores the result - bindData = reThis.test(source); - setBindData(func, bindData); - } - } - } - // exit early if there are no `this` references or `func` is bound - if (bindData === false || (bindData !== true && bindData[1] & 1)) { - return func; - } - switch (argCount) { - case 1: return function(value) { - return func.call(thisArg, value); - }; - case 2: return function(a, b) { - return func.call(thisArg, a, b); - }; - case 3: return function(value, index, collection) { - return func.call(thisArg, value, index, collection); - }; - case 4: return function(accumulator, value, index, collection) { - return func.call(thisArg, accumulator, value, index, collection); - }; - } - return bind(func, thisArg); + function isArrayLikeObject(value) { + return isObjectLike(value) && isArrayLike(value); } /** - * The base implementation of `createWrapper` that creates the wrapper and - * sets its meta data. + * Checks if `value` is classified as a boolean primitive or object. * - * @private - * @param {Array} bindData The bind data array. - * @returns {Function} Returns the new function. + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a boolean, else `false`. + * @example + * + * _.isBoolean(false); + * // => true + * + * _.isBoolean(null); + * // => false */ - function baseCreateWrapper(bindData) { - var func = bindData[0], - bitmask = bindData[1], - partialArgs = bindData[2], - partialRightArgs = bindData[3], - thisArg = bindData[4], - arity = bindData[5]; - - var isBind = bitmask & 1, - isBindKey = bitmask & 2, - isCurry = bitmask & 4, - isCurryBound = bitmask & 8, - key = func; - - function bound() { - var thisBinding = isBind ? thisArg : this; - if (partialArgs) { - var args = slice(partialArgs); - push.apply(args, arguments); - } - if (partialRightArgs || isCurry) { - args || (args = slice(arguments)); - if (partialRightArgs) { - push.apply(args, partialRightArgs); - } - if (isCurry && args.length < arity) { - bitmask |= 16 & ~32; - return baseCreateWrapper([func, (isCurryBound ? bitmask : bitmask & ~3), args, null, thisArg, arity]); - } - } - args || (args = arguments); - if (isBindKey) { - func = thisBinding[key]; - } - if (this instanceof bound) { - thisBinding = baseCreate(func.prototype); - var result = func.apply(thisBinding, args); - return isObject(result) ? result : thisBinding; - } - return func.apply(thisBinding, args); - } - setBindData(bound, bindData); - return bound; + function isBoolean(value) { + return value === true || value === false || + (isObjectLike(value) && baseGetTag(value) == boolTag); } /** - * The base implementation of `_.difference` that accepts a single array - * of values to exclude. + * Checks if `value` is a buffer. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a buffer, else `false`. + * @example + * + * _.isBuffer(new Buffer(2)); + * // => true + * + * _.isBuffer(new Uint8Array(2)); + * // => false + */ + var isBuffer = nativeIsBuffer || stubFalse; + + /** + * Checks if `value` is classified as a `Date` object. * - * @private - * @param {Array} array The array to process. - * @param {Array} [values] The array of values to exclude. - * @returns {Array} Returns a new array of filtered values. + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a date object, else `false`. + * @example + * + * _.isDate(new Date); + * // => true + * + * _.isDate('Mon April 23 2012'); + * // => false */ - function baseDifference(array, values) { - var index = -1, - indexOf = getIndexOf(), - length = array ? array.length : 0, - isLarge = length >= largeArraySize && indexOf === baseIndexOf, - result = []; - - if (isLarge) { - var cache = createCache(values); - if (cache) { - indexOf = cacheIndexOf; - values = cache; - } else { - isLarge = false; - } - } - while (++index < length) { - var value = array[index]; - if (indexOf(values, value) < 0) { - result.push(value); - } - } - if (isLarge) { - releaseObject(values); - } - return result; - } + var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate; /** - * The base implementation of `_.flatten` without support for callback - * shorthands or `thisArg` binding. + * Checks if `value` is likely a DOM element. * - * @private - * @param {Array} array The array to flatten. - * @param {boolean} [isShallow=false] A flag to restrict flattening to a single level. - * @param {boolean} [isStrict=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 baseFlatten(array, isShallow, isStrict, fromIndex) { - var index = (fromIndex || 0) - 1, - length = array ? array.length : 0, - result = []; - - while (++index < length) { - var value = array[index]; - - if (value && typeof value == 'object' && typeof value.length == 'number' - && (isArray(value) || isArguments(value))) { - // recursively flatten arrays (susceptible to call stack limits) - if (!isShallow) { - value = baseFlatten(value, isShallow, isStrict); - } - var valIndex = -1, - valLength = value.length, - resIndex = result.length; - - result.length += valLength; - while (++valIndex < valLength) { - result[resIndex++] = value[valIndex]; - } - } else if (!isStrict) { - result.push(value); - } - } - return result; + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`. + * @example + * + * _.isElement(document.body); + * // => true + * + * _.isElement(''); + * // => false + */ + function isElement(value) { + return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value); } /** - * The base implementation of `_.isEqual`, without support for `thisArg` binding, - * that allows partial "_.where" style comparisons. + * Checks if `value` is an empty object, collection, map, or set. * - * @private - * @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`. + * Objects are considered empty if they have no own enumerable string keyed + * properties. + * + * Array-like values such as `arguments` objects, arrays, buffers, strings, or + * jQuery-like collections are considered empty if they have a `length` of `0`. + * Similarly, maps and sets are considered empty if they have a `size` of `0`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is empty, else `false`. + * @example + * + * _.isEmpty(null); + * // => true + * + * _.isEmpty(true); + * // => true + * + * _.isEmpty(1); + * // => true + * + * _.isEmpty([1, 2, 3]); + * // => false + * + * _.isEmpty({ 'a': 1 }); + * // => false */ - 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; - } - } - // 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; + function isEmpty(value) { + if (value == null) { + return true; } - // compare [[Class]] names - var className = toString.call(a), - otherClass = toString.call(b); - - if (className == argsClass) { - className = objectClass; + if (isArrayLike(value) && + (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' || + isBuffer(value) || isTypedArray(value) || isArguments(value))) { + return !value.length; } - if (otherClass == argsClass) { - otherClass = objectClass; + var tag = getTag(value); + if (tag == mapTag || tag == setTag) { + return !value.size; } - if (className != otherClass) { - return false; + if (isPrototype(value)) { + return !baseKeys(value).length; } - 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 - var aWrapped = hasOwnProperty.call(a, '__wrapped__'), - bWrapped = hasOwnProperty.call(b, '__wrapped__'); - - if (aWrapped || bWrapped) { - return baseIsEqual(aWrapped ? a.__wrapped__ : a, bWrapped ? b.__wrapped__ : b, callback, isWhere, stackA, stackB); - } - // exit for functions and DOM nodes - if (className != objectClass || (!support.nodeClass && (isNode(a) || isNode(b)))) { + for (var key in value) { + if (hasOwnProperty.call(value, key)) { 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) && - ('constructor' in a && 'constructor' in b) - ) { - 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) { - // compare lengths to determine if a deep comparison is necessary - length = a.length; - size = b.length; - result = size == length; - - if (result || isWhere) { - // 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; - } - } - } } - else { - // 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); - } - }); - } - } - stackA.pop(); - stackB.pop(); - - if (initedStack) { - releaseArray(stackA); - releaseArray(stackB); - } - return result; + return true; } /** - * The base implementation of `_.merge` without argument juggling or support - * for `thisArg` binding. + * Performs a deep comparison between two values to determine if they are + * equivalent. * - * @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 `_.random` without argument juggling or support - * for returning floating-point numbers. + * **Note:** This method supports comparing arrays, array buffers, booleans, + * date objects, error objects, maps, numbers, `Object` objects, regexes, + * sets, strings, symbols, and typed arrays. `Object` objects are compared + * by their own, not inherited, enumerable properties. Functions and DOM + * nodes are compared by strict equality, i.e. `===`. * - * @private - * @param {number} min The minimum possible value. - * @param {number} max The maximum possible value. - * @returns {number} Returns a random number. - */ - function baseRandom(min, max) { - return min + floor(nativeRandom() * (max - min + 1)); - } - - /** - * The base implementation of `_.uniq` without support for callback shorthands - * or `thisArg` binding. + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example * - * @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. + * var object = { 'a': 1 }; + * var other = { 'a': 1 }; + * + * _.isEqual(object, other); + * // => true + * + * object === other; + * // => false */ - 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); - indexOf = cacheIndexOf; - seen = cache; - } - 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; + function isEqual(value, other) { + return baseIsEqual(value, other); } /** - * 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. + * This method is like `_.isEqual` except that it accepts `customizer` which + * is invoked to compare values. If `customizer` returns `undefined`, comparisons + * are handled by the method instead. The `customizer` is invoked with up to + * six arguments: (objValue, othValue [, index|key, object, other, stack]). * - * @private - * @param {Function} setter The setter function. - * @returns {Function} Returns the new aggregator function. + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @param {Function} [customizer] The function to customize comparisons. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * function isGreeting(value) { + * return /^h(?:i|ello)$/.test(value); + * } + * + * function customizer(objValue, othValue) { + * if (isGreeting(objValue) && isGreeting(othValue)) { + * return true; + * } + * } + * + * var array = ['hello', 'goodbye']; + * var other = ['hi', 'goodbye']; + * + * _.isEqualWith(array, other, customizer); + * // => true */ - 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; - }; + function isEqualWith(value, other, customizer) { + customizer = typeof customizer == 'function' ? customizer : undefined; + var result = customizer ? customizer(value, other) : undefined; + return result === undefined ? baseIsEqual(value, other, undefined, customizer) : !!result; } /** - * Creates a function that, when called, either curries or invokes `func` - * with an optional `this` binding and partially applied arguments. + * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`, + * `SyntaxError`, `TypeError`, or `URIError` object. * - * @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 function. + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an error object, else `false`. + * @example + * + * _.isError(new Error); + * // => true + * + * _.isError(Error); + * // => false */ - function createWrapper(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; - - 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 && bindData !== true) { - // clone `bindData` - bindData = slice(bindData); - if (bindData[2]) { - bindData[2] = slice(bindData[2]); - } - if (bindData[3]) { - bindData[3] = slice(bindData[3]); - } - // set `thisBinding` is not previously bound - if (isBind && !(bindData[1] & 1)) { - bindData[4] = thisArg; - } - // set if previously bound but not currently (subsequent curried functions) - if (!isBind && bindData[1] & 1) { - bitmask |= 8; - } - // set curried arity if not yet set - if (isCurry && !(bindData[1] & 4)) { - bindData[5] = arity; - } - // append partial left arguments - if (isPartial) { - push.apply(bindData[2] || (bindData[2] = []), partialArgs); - } - // append partial right arguments - if (isPartialRight) { - unshift.apply(bindData[3] || (bindData[3] = []), partialRightArgs); - } - // merge flags - bindData[1] |= bitmask; - return createWrapper.apply(null, bindData); + function isError(value) { + if (!isObjectLike(value)) { + return false; } - // fast path for `_.bind` - var creater = (bitmask == 1 || bitmask === 17) ? baseBind : baseCreateWrapper; - return creater([func, bitmask, partialArgs, partialRightArgs, thisArg, arity]); + var tag = baseGetTag(value); + return tag == errorTag || tag == domExcTag || + (typeof value.message == 'string' && typeof value.name == 'string' && !isPlainObject(value)); } /** - * Creates compiled iteration functions. + * Checks if `value` is a finite primitive number. * - * @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. + * **Note:** This method is based on + * [`Number.isFinite`](https://mdn.io/Number/isFinite). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a finite number, else `false`. + * @example + * + * _.isFinite(3); + * // => true + * + * _.isFinite(Number.MIN_VALUE); + * // => true + * + * _.isFinite(Infinity); + * // => false + * + * _.isFinite('3'); + * // => false */ - function createIterator() { - // data properties - iteratorData.shadowedProps = shadowedProps; - iteratorData.support = support; - - // iterator options - iteratorData.array = iteratorData.bottom = iteratorData.loop = iteratorData.top = ''; - iteratorData.init = 'iterable'; - iteratorData.useHas = true; - - // merge options into a template data object - for (var object, index = 0; object = arguments[index]; index++) { - for (var key in object) { - iteratorData[key] = object[key]; - } - } - var args = iteratorData.args; - iteratorData.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(iteratorData) + '\n}' - ); - - // return the compiled function - return factory( - baseCreateCallback, errorClass, errorProto, hasOwnProperty, - indicatorObject, isArguments, isArray, isString, iteratorData.keys, objectProto, - objectTypes, nonEnumProps, stringClass, stringProto, toString - ); + function isFinite(value) { + return typeof value == 'number' && nativeIsFinite(value); } /** - * Used by `escape` to convert characters to HTML entities. + * Checks if `value` is classified as a `Function` object. * - * @private - * @param {string} match The matched character to escape. - * @returns {string} Returns the escaped character. + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a function, else `false`. + * @example + * + * _.isFunction(_); + * // => true + * + * _.isFunction(/abc/); + * // => false */ - function escapeHtmlChar(match) { - return htmlEscapes[match]; + function isFunction(value) { + if (!isObject(value)) { + return false; + } + // The use of `Object#toString` avoids issues with the `typeof` operator + // in Safari 9 which returns 'object' for typed arrays and other constructors. + var tag = baseGetTag(value); + return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag; } /** - * Gets the appropriate "indexOf" function. If the `_.indexOf` method is - * customized, this method returns the custom method, otherwise it returns - * the `baseIndexOf` function. + * Checks if `value` is an integer. + * + * **Note:** This method is based on + * [`Number.isInteger`](https://mdn.io/Number/isInteger). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an integer, else `false`. + * @example + * + * _.isInteger(3); + * // => true + * + * _.isInteger(Number.MIN_VALUE); + * // => false * - * @private - * @returns {Function} Returns the "indexOf" function. - */ - function getIndexOf() { - var result = (result = lodash.indexOf) === indexOf ? baseIndexOf : result; - return result; - } - - /** - * Checks if `value` is a native function. + * _.isInteger(Infinity); + * // => false * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is a native function, else `false`. + * _.isInteger('3'); + * // => false */ - function isNative(value) { - return typeof value == 'function' && reNative.test(value); + function isInteger(value) { + return typeof value == 'number' && value == toInteger(value); } /** - * Sets `this` binding data on a given function. + * Checks if `value` is a valid array-like length. * - * @private - * @param {Function} func The function to set data on. - * @param {Array} value The data array to set. - */ - var setBindData = !defineProperty ? noop : function(func, value) { - descriptor.value = value; - defineProperty(func, '__bindData__', 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. + * **Note:** This method is loosely based on + * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). * - * @private + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a plain object, else `false`. + * @returns {boolean} Returns `true` if `value` is a valid length, else `false`. + * @example + * + * _.isLength(3); + * // => true + * + * _.isLength(Number.MIN_VALUE); + * // => false + * + * _.isLength(Infinity); + * // => false + * + * _.isLength('3'); + * // => 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; - } - // In most environments an object's own properties are iterated before - // its inherited properties. If the last iterated property is an object's - // own property then there are no inherited enumerable properties. - forIn(value, function(value, key) { - result = key; - }); - return typeof result == 'undefined' || hasOwnProperty.call(value, result); + function isLength(value) { + return typeof value == 'number' && + value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER; } /** - * Used by `unescape` to convert HTML entities to characters. + * Checks if `value` is the + * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) + * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) * - * @private - * @param {string} match The matched character to unescape. - * @returns {string} Returns the unescaped character. + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @example + * + * _.isObject({}); + * // => true + * + * _.isObject([1, 2, 3]); + * // => true + * + * _.isObject(_.noop); + * // => true + * + * _.isObject(null); + * // => false */ - function unescapeHtmlChar(match) { - return htmlUnescapes[match]; + function isObject(value) { + var type = typeof value; + return value != null && (type == 'object' || type == 'function'); } - /*--------------------------------------------------------------------------*/ - /** - * Checks if `value` is an `arguments` object. + * Checks if `value` is object-like. A value is object-like if it's not `null` + * and has a `typeof` result of "object". * * @static * @memberOf _ - * @category Objects + * @since 4.0.0 + * @category Lang * @param {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is an `arguments` object, else `false`. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. * @example * - * (function() { return _.isArguments(arguments); })(1, 2, 3); + * _.isObjectLike({}); * // => true * - * _.isArguments([1, 2, 3]); + * _.isObjectLike([1, 2, 3]); + * // => true + * + * _.isObjectLike(_.noop); + * // => false + * + * _.isObjectLike(null); * // => false */ - function isArguments(value) { - return value && typeof value == 'object' && typeof value.length == 'number' && - toString.call(value) == argsClass || false; - } - // fallback for browsers that can't detect `arguments` objects by [[Class]] - if (!support.argsClass) { - isArguments = function(value) { - return value && typeof value == 'object' && typeof value.length == 'number' && - hasOwnProperty.call(value, 'callee') && !propertyIsEnumerable.call(value, 'callee') || false; - }; + function isObjectLike(value) { + return value != null && typeof value == 'object'; } /** - * Checks if `value` is an array. + * Checks if `value` is classified as a `Map` object. * * @static * @memberOf _ - * @type Function - * @category Objects + * @since 4.3.0 + * @category Lang * @param {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is an array, else `false`. + * @returns {boolean} Returns `true` if `value` is a map, else `false`. * @example * - * (function() { return _.isArray(arguments); })(); - * // => false - * - * _.isArray([1, 2, 3]); + * _.isMap(new Map); * // => true + * + * _.isMap(new WeakMap); + * // => false */ - var isArray = nativeIsArray || function(value) { - return value && typeof value == 'object' && typeof value.length == 'number' && - toString.call(value) == arrayClass || false; - }; + var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap; /** - * A fallback implementation of `Object.keys` which produces an array of the - * given object's own enumerable property names. + * Performs a partial deep comparison between `object` and `source` to + * determine if `object` contains equivalent property values. * - * @private - * @type Function + * **Note:** This method is equivalent to `_.matches` when `source` is + * partially applied. + * + * Partial comparisons will match empty array and empty object `source` + * values against any array or object value, respectively. See `_.isEqual` + * for a list of supported value comparisons. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang * @param {Object} object The object to inspect. - * @returns {Array} Returns an array of property names. + * @param {Object} source The object of property values to match. + * @returns {boolean} Returns `true` if `object` is a match, else `false`. + * @example + * + * var object = { 'a': 1, 'b': 2 }; + * + * _.isMatch(object, { 'b': 2 }); + * // => true + * + * _.isMatch(object, { 'b': 1 }); + * // => false */ - var shimKeys = createIterator({ - 'args': 'object', - 'init': '[]', - 'top': 'if (!(objectTypes[typeof object])) return result', - 'loop': 'result.push(index)' - }); + function isMatch(object, source) { + return object === source || baseIsMatch(object, source, getMatchData(source)); + } /** - * Creates an array composed of the own enumerable property names of an object. + * This method is like `_.isMatch` except that it accepts `customizer` which + * is invoked to compare values. If `customizer` returns `undefined`, comparisons + * are handled by the method instead. The `customizer` is invoked with five + * arguments: (objValue, srcValue, index|key, object, source). * * @static * @memberOf _ - * @category Objects + * @since 4.0.0 + * @category Lang * @param {Object} object The object to inspect. - * @returns {Array} Returns an array of property names. + * @param {Object} source The object of property values to match. + * @param {Function} [customizer] The function to customize comparisons. + * @returns {boolean} Returns `true` if `object` is a match, else `false`. * @example * - * _.keys({ 'one': 1, 'two': 2, 'three': 3 }); - * // => ['one', 'two', 'three'] (property order is not guaranteed across environments) + * function isGreeting(value) { + * return /^h(?:i|ello)$/.test(value); + * } + * + * function customizer(objValue, srcValue) { + * if (isGreeting(objValue) && isGreeting(srcValue)) { + * return true; + * } + * } + * + * var object = { 'greeting': 'hello' }; + * var source = { 'greeting': 'hi' }; + * + * _.isMatchWith(object, source, customizer); + * // => true */ - var keys = !nativeKeys ? shimKeys : function(object) { - if (!isObject(object)) { - return []; - } - if ((support.enumPrototypes && typeof object == 'function') || - (support.nonEnumArgs && object.length && isArguments(object))) { - return shimKeys(object); - } - return nativeKeys(object); - }; - - /** 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 - }; + function isMatchWith(object, source, customizer) { + customizer = typeof customizer == 'function' ? customizer : undefined; + return baseIsMatch(object, source, getMatchData(source), customizer); + } /** - * Used to convert characters to HTML entities: + * Checks if `value` is `NaN`. + * + * **Note:** This method is based on + * [`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as + * global [`isNaN`](https://mdn.io/isNaN) which returns `true` for + * `undefined` and other non-number values. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`. + * @example + * + * _.isNaN(NaN); + * // => true + * + * _.isNaN(new Number(NaN)); + * // => true * - * Though the `>` character is escaped for symmetry, characters like `>` and `/` - * don't require escaping in HTML and have no special meaning unless they're part - * of a tag or an unquoted attribute value. - * http://mathiasbynens.be/notes/ambiguous-ampersands (under "semi-related fun fact") + * isNaN(undefined); + * // => true + * + * _.isNaN(undefined); + * // => false */ - var htmlEscapes = { - '&': '&', - '<': '<', - '>': '>', - '"': '"', - "'": ''' - }; - - /** 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'); + function isNaN(value) { + // An `NaN` primitive is the only value that is not equal to itself. + // Perform the `toStringTag` check first to avoid errors with some + // ActiveX objects in IE. + return isNumber(value) && value != +value; + } /** - * 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`. + * Checks if `value` is a pristine native function. * - * @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`. + * **Note:** This method can't reliably detect native functions in the presence + * of the core-js package because core-js circumvents this kind of detection. + * Despite multiple requests, the core-js maintainer has made it clear: any + * attempt to fix the detection will be obstructed. As a result, we're left + * with little choice but to throw an error. Unfortunately, this also affects + * packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill), + * which rely on core-js. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a native function, + * else `false`. + * @example + * + * _.isNative(Array.prototype.push); + * // => true + * + * _.isNative(_); + * // => false */ - var baseEach = createIterator(eachIteratorOptions); - - /*--------------------------------------------------------------------------*/ + function isNative(value) { + if (isMaskable(value)) { + throw new Error(CORE_ERROR_TEXT); + } + return baseIsNative(value); + } /** - * Assigns own enumerable properties of source object(s) to the destination - * object. Subsequent sources will overwrite property assignments of previous - * 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). + * Checks if `value` is `null`. * * @static * @memberOf _ - * @type Function - * @alias extend - * @category Objects - * @param {Object} object The destination object. - * @param {...Object} [source] The source objects. - * @param {Function} [callback] The function to customize assigning values. - * @param {*} [thisArg] The `this` binding of `callback`. - * @returns {Object} Returns the destination object. + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is `null`, else `false`. * @example * - * _.assign({ 'name': 'fred' }, { 'employer': 'slate' }); - * // => { 'name': 'fred', 'employer': 'slate' } - * - * var defaults = _.partialRight(_.assign, function(a, b) { - * return typeof a == 'undefined' ? b : a; - * }); + * _.isNull(null); + * // => true * - * var object = { 'name': 'barney' }; - * defaults(object, { 'name': 'fred', 'employer': 'slate' }); - * // => { 'name': 'barney', 'employer': 'slate' } - */ - var assign = createIterator(defaultsIteratorOptions, { - 'top': - defaultsIteratorOptions.top.replace(';', - ';\n' + - "if (argsLength > 3 && typeof args[argsLength - 2] == 'function') {\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' + - '}' - ), - 'loop': 'result[index] = callback ? callback(result[index], iterable[index]) : iterable[index]' - }); + * _.isNull(void 0); + * // => false + */ + function isNull(value) { + return value === null; + } /** - * Creates a clone of `value`. If `isDeep` 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). + * Checks if `value` is `null` or `undefined`. * * @static * @memberOf _ - * @category Objects - * @param {*} value The value to clone. - * @param {boolean} [isDeep=false] Specify a deep clone. - * @param {Function} [callback] The function to customize cloning values. - * @param {*} [thisArg] The `this` binding of `callback`. - * @returns {*} Returns the cloned value. + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is nullish, else `false`. * @example * - * var characters = [ - * { 'name': 'barney', 'age': 36 }, - * { 'name': 'fred', 'age': 40 } - * ]; + * _.isNil(null); + * // => true * - * var shallow = _.clone(characters); - * shallow[0] === characters[0]; + * _.isNil(void 0); * // => true * - * var deep = _.clone(characters, true); - * deep[0] === characters[0]; + * _.isNil(NaN); * // => 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, isDeep, callback, thisArg) { - // allows working with "Collections" methods without using their `index` - // and `collection` arguments for `isDeep` and `callback` - if (typeof isDeep != 'boolean' && isDeep != null) { - thisArg = callback; - callback = isDeep; - isDeep = false; - } - return baseClone(value, isDeep, typeof callback == 'function' && baseCreateCallback(callback, thisArg, 1)); + function isNil(value) { + return value == null; } /** - * 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). + * Checks if `value` is classified as a `Number` primitive or object. * - * 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 - * objects created by constructors other than `Object` are cloned to plain `Object` objects. - * See http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm. + * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are + * classified as numbers, use the `_.isFinite` method. * * @static * @memberOf _ - * @category Objects - * @param {*} value The value to deep clone. - * @param {Function} [callback] The function to customize cloning values. - * @param {*} [thisArg] The `this` binding of `callback`. - * @returns {*} Returns the deep cloned value. + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a number, else `false`. * @example * - * var characters = [ - * { 'name': 'barney', 'age': 36 }, - * { 'name': 'fred', 'age': 40 } - * ]; - * - * var deep = _.cloneDeep(characters); - * deep[0] === characters[0]; - * // => false + * _.isNumber(3); + * // => true * - * var view = { - * 'label': 'docs', - * 'node': element - * }; + * _.isNumber(Number.MIN_VALUE); + * // => true * - * var clone = _.cloneDeep(view, function(value) { - * return _.isElement(value) ? value.cloneNode(true) : undefined; - * }); + * _.isNumber(Infinity); + * // => true * - * clone.node == view.node; + * _.isNumber('3'); * // => false */ - function cloneDeep(value, callback, thisArg) { - return baseClone(value, true, typeof callback == 'function' && baseCreateCallback(callback, thisArg, 1)); + function isNumber(value) { + return typeof value == 'number' || + (isObjectLike(value) && baseGetTag(value) == numberTag); } /** - * Creates an object that inherits from the given `prototype` object. If a - * `properties` object is provided its own enumerable properties are assigned - * to the created object. + * Checks if `value` is a plain object, that is, an object created by the + * `Object` constructor or one with a `[[Prototype]]` of `null`. * * @static * @memberOf _ - * @category Objects - * @param {Object} prototype The object to inherit from. - * @param {Object} [properties] The properties to assign to the object. - * @returns {Object} Returns the new object. + * @since 0.8.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a plain object, else `false`. * @example * - * function Shape() { - * this.x = 0; - * this.y = 0; + * function Foo() { + * this.a = 1; * } * - * function Circle() { - * Shape.call(this); - * } + * _.isPlainObject(new Foo); + * // => false * - * Circle.prototype = _.create(Shape.prototype, { 'constructor': Circle }); + * _.isPlainObject([1, 2, 3]); + * // => false * - * var circle = new Circle; - * circle instanceof Circle; + * _.isPlainObject({ 'x': 0, 'y': 0 }); * // => true * - * circle instanceof Shape; + * _.isPlainObject(Object.create(null)); * // => true */ - function create(prototype, properties) { - var result = baseCreate(prototype); - return properties ? assign(result, properties) : result; + function isPlainObject(value) { + if (!isObjectLike(value) || baseGetTag(value) != objectTag) { + return false; + } + var proto = getPrototype(value); + if (proto === null) { + return true; + } + var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor; + return typeof Ctor == 'function' && Ctor instanceof Ctor && + funcToString.call(Ctor) == objectCtorString; } /** - * Assigns own enumerable properties of source object(s) to the destination - * object for all destination properties that resolve to `undefined`. Once a - * property is set, additional defaults of the same property will be ignored. + * Checks if `value` is classified as a `RegExp` object. * * @static * @memberOf _ - * @type Function - * @category Objects - * @param {Object} object The destination object. - * @param {...Object} [source] The source objects. - * @param- {Object} [guard] Allows working with `_.reduce` without using its - * `key` and `object` arguments as sources. - * @returns {Object} Returns the destination object. + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a regexp, else `false`. * @example * - * var object = { 'name': 'barney' }; - * _.defaults(object, { 'name': 'fred', 'employer': 'slate' }); - * // => { 'name': 'barney', 'employer': 'slate' } + * _.isRegExp(/abc/); + * // => true + * + * _.isRegExp('/abc/'); + * // => false */ - var defaults = createIterator(defaultsIteratorOptions); + var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp; /** - * 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. + * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754 + * double precision number which isn't the result of a rounded unsafe integer. * - * 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`. + * **Note:** This method is based on + * [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger). * * @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`. + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a safe integer, else `false`. * @example * - * var characters = { - * 'barney': { 'age': 36, 'blocked': false }, - * 'fred': { 'age': 40, 'blocked': true }, - * 'pebbles': { 'age': 1, 'blocked': false } - * }; + * _.isSafeInteger(3); + * // => true * - * _.findKey(characters, function(chr) { - * return chr.age < 40; - * }); - * // => 'barney' (property order is not guaranteed across environments) + * _.isSafeInteger(Number.MIN_VALUE); + * // => false * - * // using "_.where" callback shorthand - * _.findKey(characters, { 'age': 1 }); - * // => 'pebbles' + * _.isSafeInteger(Infinity); + * // => false * - * // using "_.pluck" callback shorthand - * _.findKey(characters, 'blocked'); - * // => 'fred' + * _.isSafeInteger('3'); + * // => false */ - function findKey(object, callback, thisArg) { - var result; - callback = lodash.createCallback(callback, thisArg, 3); - forOwn(object, function(value, key, object) { - if (callback(value, key, object)) { - result = key; - return false; - } - }); - return result; + function isSafeInteger(value) { + return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER; } /** - * This method is like `_.findKey` except that it iterates over elements - * of a `collection` in the opposite order. + * Checks if `value` is classified as a `Set` object. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a set, else `false`. + * @example * - * If a property name is provided for `callback` the created "_.pluck" style - * callback will return the property value of the given element. + * _.isSet(new Set); + * // => true * - * 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`. + * _.isSet(new WeakSet); + * // => false + */ + var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet; + + /** + * Checks if `value` is classified as a `String` primitive or object. * * @static + * @since 0.1.0 * @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`. + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a string, else `false`. * @example * - * var characters = { - * 'barney': { 'age': 36, 'blocked': true }, - * 'fred': { 'age': 40, 'blocked': false }, - * 'pebbles': { 'age': 1, 'blocked': true } - * }; + * _.isString('abc'); + * // => true * - * _.findLastKey(characters, function(chr) { - * return chr.age < 40; - * }); - * // => returns `pebbles`, assuming `_.findKey` returns `barney` + * _.isString(1); + * // => false + */ + function isString(value) { + return typeof value == 'string' || + (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag); + } + + /** + * Checks if `value` is classified as a `Symbol` primitive or object. * - * // using "_.where" callback shorthand - * _.findLastKey(characters, { 'age': 40 }); - * // => 'fred' + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. + * @example * - * // using "_.pluck" callback shorthand - * _.findLastKey(characters, 'blocked'); - * // => 'pebbles' - */ - 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; + * _.isSymbol(Symbol.iterator); + * // => true + * + * _.isSymbol('abc'); + * // => false + */ + function isSymbol(value) { + return typeof value == 'symbol' || + (isObjectLike(value) && baseGetTag(value) == symbolTag); } /** - * 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`. + * Checks if `value` is classified as a typed array. * * @static * @memberOf _ - * @type Function - * @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`. + * @since 3.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. * @example * - * function Shape() { - * this.x = 0; - * this.y = 0; - * } - * - * Shape.prototype.move = function(x, y) { - * this.x += x; - * this.y += y; - * }; + * _.isTypedArray(new Uint8Array); + * // => true * - * _.forIn(new Shape, function(value, key) { - * console.log(key); - * }); - * // => logs 'x', 'y', and 'move' (property order is not guaranteed across environments) + * _.isTypedArray([]); + * // => false */ - var forIn = createIterator(eachIteratorOptions, forOwnIteratorOptions, { - 'useHas': false - }); + var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray; /** - * This method is like `_.forIn` except that it iterates over elements - * of a `collection` in the opposite order. + * Checks if `value` is `undefined`. * * @static + * @since 0.1.0 * @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`. + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`. * @example * - * function Shape() { - * this.x = 0; - * this.y = 0; - * } - * - * Shape.prototype.move = function(x, y) { - * this.x += x; - * this.y += y; - * }; + * _.isUndefined(void 0); + * // => true * - * _.forInRight(new Shape, function(value, key) { - * console.log(key); - * }); - * // => logs 'move', 'y', and 'x' assuming `_.forIn ` logs 'x', 'y', and 'move' + * _.isUndefined(null); + * // => false */ - 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; + function isUndefined(value) { + return value === undefined; } /** - * 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`. + * Checks if `value` is classified as a `WeakMap` object. * * @static * @memberOf _ - * @type Function - * @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`. + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a weak map, else `false`. * @example * - * _.forOwn({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) { - * console.log(key); - * }); - * // => logs '0', '1', and 'length' (property order is not guaranteed across environments) + * _.isWeakMap(new WeakMap); + * // => true + * + * _.isWeakMap(new Map); + * // => false */ - var forOwn = createIterator(eachIteratorOptions, forOwnIteratorOptions); + function isWeakMap(value) { + return isObjectLike(value) && getTag(value) == weakMapTag; + } /** - * This method is like `_.forOwn` except that it iterates over elements - * of a `collection` in the opposite order. + * Checks if `value` is classified as a `WeakSet` object. * * @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`. + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a weak set, else `false`. * @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' + * _.isWeakSet(new WeakSet); + * // => true + * + * _.isWeakSet(new Set); + * // => false */ - 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; + function isWeakSet(value) { + return isObjectLike(value) && baseGetTag(value) == weakSetTag; } /** - * Creates a sorted array of property names of all enumerable properties, - * own and inherited, of `object` that have function values. + * Checks if `value` is less than `other`. * * @static * @memberOf _ - * @alias methods - * @category Objects - * @param {Object} object The object to inspect. - * @returns {Array} Returns an array of property names that have function values. + * @since 3.9.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if `value` is less than `other`, + * else `false`. + * @see _.gt * @example * - * _.functions(_); - * // => ['all', 'any', 'bind', 'bindAll', 'clone', 'compact', 'compose', ...] + * _.lt(1, 3); + * // => true + * + * _.lt(3, 3); + * // => false + * + * _.lt(3, 1); + * // => false */ - function functions(object) { - var result = []; - forIn(object, function(value, key) { - if (isFunction(value)) { - result.push(key); - } - }); - return result.sort(); - } + var lt = createRelationalOperation(baseLt); /** - * Checks if the specified property name exists as a direct property of `object`, - * instead of an inherited property. + * Checks if `value` is less than or equal to `other`. * * @static * @memberOf _ - * @category Objects - * @param {Object} object The object to inspect. - * @param {string} key The name of the property to check. - * @returns {boolean} Returns `true` if key is a direct property, else `false`. + * @since 3.9.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if `value` is less than or equal to + * `other`, else `false`. + * @see _.gte * @example * - * _.has({ 'a': 1, 'b': 2, 'c': 3 }, 'b'); + * _.lte(1, 3); + * // => true + * + * _.lte(3, 3); * // => true + * + * _.lte(3, 1); + * // => false */ - function has(object, key) { - return object ? hasOwnProperty.call(object, key) : false; - } + var lte = createRelationalOperation(function(value, other) { + return value <= other; + }); /** - * Creates an object composed of the inverted keys and values of the given object. + * Converts `value` to an array. * * @static + * @since 0.1.0 * @memberOf _ - * @category Objects - * @param {Object} object The object to invert. - * @returns {Object} Returns the created inverted object. + * @category Lang + * @param {*} value The value to convert. + * @returns {Array} Returns the converted array. * @example * - * _.invert({ 'first': 'fred', 'second': 'barney' }); - * // => { 'fred': 'first', 'barney': 'second' } + * _.toArray({ 'a': 1, 'b': 2 }); + * // => [1, 2] + * + * _.toArray('abc'); + * // => ['a', 'b', 'c'] + * + * _.toArray(1); + * // => [] + * + * _.toArray(null); + * // => [] */ - function invert(object) { - var index = -1, - props = keys(object), - length = props.length, - result = {}; - - while (++index < length) { - var key = props[index]; - result[object[key]] = key; + function toArray(value) { + if (!value) { + return []; } - return result; + if (isArrayLike(value)) { + return isString(value) ? stringToArray(value) : copyArray(value); + } + if (symIterator && value[symIterator]) { + return iteratorToArray(value[symIterator]()); + } + var tag = getTag(value), + func = tag == mapTag ? mapToArray : (tag == setTag ? setToArray : values); + + return func(value); } /** - * Checks if `value` is a boolean value. + * Converts `value` to a finite number. * * @static * @memberOf _ - * @category Objects - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is a boolean value, else `false`. + * @since 4.12.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {number} Returns the converted number. * @example * - * _.isBoolean(null); - * // => false + * _.toFinite(3.2); + * // => 3.2 + * + * _.toFinite(Number.MIN_VALUE); + * // => 5e-324 + * + * _.toFinite(Infinity); + * // => 1.7976931348623157e+308 + * + * _.toFinite('3.2'); + * // => 3.2 */ - function isBoolean(value) { - return value === true || value === false || - value && typeof value == 'object' && toString.call(value) == boolClass || false; + function toFinite(value) { + if (!value) { + return value === 0 ? value : 0; + } + value = toNumber(value); + if (value === INFINITY || value === -INFINITY) { + var sign = (value < 0 ? -1 : 1); + return sign * MAX_INTEGER; + } + return value === value ? value : 0; } /** - * Checks if `value` is a date. + * Converts `value` to an integer. + * + * **Note:** This method is loosely based on + * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger). * * @static * @memberOf _ - * @category Objects - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is a date, else `false`. + * @since 4.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {number} Returns the converted integer. * @example * - * _.isDate(new Date); - * // => true + * _.toInteger(3.2); + * // => 3 + * + * _.toInteger(Number.MIN_VALUE); + * // => 0 + * + * _.toInteger(Infinity); + * // => 1.7976931348623157e+308 + * + * _.toInteger('3.2'); + * // => 3 */ - function isDate(value) { - return value && typeof value == 'object' && toString.call(value) == dateClass || false; + function toInteger(value) { + var result = toFinite(value), + remainder = result % 1; + + return result === result ? (remainder ? result - remainder : result) : 0; } /** - * Checks if `value` is a DOM element. + * Converts `value` to an integer suitable for use as the length of an + * array-like object. + * + * **Note:** This method is based on + * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). * * @static * @memberOf _ - * @category Objects - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is a DOM element, else `false`. + * @since 4.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {number} Returns the converted integer. * @example * - * _.isElement(document.body); - * // => true + * _.toLength(3.2); + * // => 3 + * + * _.toLength(Number.MIN_VALUE); + * // => 0 + * + * _.toLength(Infinity); + * // => 4294967295 + * + * _.toLength('3.2'); + * // => 3 */ - function isElement(value) { - return value && value.nodeType === 1 || false; + function toLength(value) { + return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0; } /** - * Checks if `value` is empty. Arrays, strings, or `arguments` objects with a - * length of `0` and objects with no own enumerable properties are considered - * "empty". + * Converts `value` to a number. * * @static * @memberOf _ - * @category Objects - * @param {Array|Object|string} value The value to inspect. - * @returns {boolean} Returns `true` if the `value` is empty, else `false`. + * @since 4.0.0 + * @category Lang + * @param {*} value The value to process. + * @returns {number} Returns the number. * @example * - * _.isEmpty([1, 2, 3]); - * // => false + * _.toNumber(3.2); + * // => 3.2 * - * _.isEmpty({}); - * // => true + * _.toNumber(Number.MIN_VALUE); + * // => 5e-324 * - * _.isEmpty(''); - * // => true + * _.toNumber(Infinity); + * // => Infinity + * + * _.toNumber('3.2'); + * // => 3.2 */ - function isEmpty(value) { - var result = true; - if (!value) { - return result; + function toNumber(value) { + if (typeof value == 'number') { + return value; } - var className = toString.call(value), - length = value.length; - - if ((className == arrayClass || className == stringClass || - (support.argsClass ? className == argsClass : isArguments(value))) || - (className == objectClass && typeof length == 'number' && isFunction(value.splice))) { - return !length; + if (isSymbol(value)) { + return NAN; } - forOwn(value, function() { - return (result = false); - }); - return result; + if (isObject(value)) { + var other = typeof value.valueOf == 'function' ? value.valueOf() : value; + value = isObject(other) ? (other + '') : other; + } + if (typeof value != 'string') { + return value === 0 ? value : +value; + } + value = baseTrim(value); + var isBinary = reIsBinary.test(value); + return (isBinary || reIsOctal.test(value)) + ? freeParseInt(value.slice(2), isBinary ? 2 : 8) + : (reIsBadHex.test(value) ? NAN : +value); } /** - * Performs a deep comparison between two values to determine if they are - * 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). + * Converts `value` to a plain object flattening inherited enumerable string + * keyed properties of `value` to own properties of the plain object. * * @static * @memberOf _ - * @category Objects - * @param {*} a The value to compare. - * @param {*} b The other value to compare. - * @param {Function} [callback] The function to customize comparing values. - * @param {*} [thisArg] The `this` binding of `callback`. - * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @since 3.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {Object} Returns the converted plain object. * @example * - * var object = { 'name': 'fred' }; - * var copy = { 'name': 'fred' }; - * - * object == copy; - * // => false - * - * _.isEqual(object, copy); - * // => true + * function Foo() { + * this.b = 2; + * } * - * var words = ['hello', 'goodbye']; - * var otherWords = ['hi', 'goodbye']; + * Foo.prototype.c = 3; * - * _.isEqual(words, otherWords, function(a, b) { - * var reGreet = /^(?:hello|hi)$/i, - * aGreet = _.isString(a) && reGreet.test(a), - * bGreet = _.isString(b) && reGreet.test(b); + * _.assign({ 'a': 1 }, new Foo); + * // => { 'a': 1, 'b': 2 } * - * return (aGreet || bGreet) ? (aGreet == bGreet) : undefined; - * }); - * // => true + * _.assign({ 'a': 1 }, _.toPlainObject(new Foo)); + * // => { 'a': 1, 'b': 2, 'c': 3 } */ - function isEqual(a, b, callback, thisArg) { - return baseIsEqual(a, b, typeof callback == 'function' && baseCreateCallback(callback, thisArg, 2)); + function toPlainObject(value) { + return copyObject(value, keysIn(value)); } /** - * 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.io/#x15.1.2.5. + * Converts `value` to a safe integer. A safe integer can be compared and + * represented correctly. * * @static * @memberOf _ - * @category Objects - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is finite, else `false`. + * @since 4.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {number} Returns the converted integer. * @example * - * _.isFinite(-101); - * // => true - * - * _.isFinite('10'); - * // => true + * _.toSafeInteger(3.2); + * // => 3 * - * _.isFinite(true); - * // => false + * _.toSafeInteger(Number.MIN_VALUE); + * // => 0 * - * _.isFinite(''); - * // => false + * _.toSafeInteger(Infinity); + * // => 9007199254740991 * - * _.isFinite(Infinity); - * // => false + * _.toSafeInteger('3.2'); + * // => 3 */ - function isFinite(value) { - return nativeIsFinite(value) && !nativeIsNaN(parseFloat(value)); + function toSafeInteger(value) { + return value + ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER) + : (value === 0 ? value : 0); } /** - * Checks if `value` is a function. + * Converts `value` to a string. An empty string is returned for `null` + * and `undefined` values. The sign of `-0` is preserved. * * @static * @memberOf _ - * @category Objects - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is a function, else `false`. + * @since 4.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {string} Returns the converted string. * @example * - * _.isFunction(_); - * // => true + * _.toString(null); + * // => '' + * + * _.toString(-0); + * // => '-0' + * + * _.toString([1, 2, 3]); + * // => '1,2,3' */ - function isFunction(value) { - return typeof value == 'function'; - } - // fallback for older versions of Chrome and Safari - if (isFunction(/x/)) { - isFunction = function(value) { - return typeof value == 'function' && toString.call(value) == funcClass; - }; + function toString(value) { + return value == null ? '' : baseToString(value); } + /*------------------------------------------------------------------------*/ + /** - * Checks if `value` is the language type of Object. - * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) + * Assigns own enumerable string keyed properties of source objects to the + * destination object. Source objects are applied from left to right. + * Subsequent sources overwrite property assignments of previous sources. + * + * **Note:** This method mutates `object` and is loosely based on + * [`Object.assign`](https://mdn.io/Object/assign). * * @static * @memberOf _ - * @category Objects - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is an object, else `false`. + * @since 0.10.0 + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. + * @see _.assignIn * @example * - * _.isObject({}); - * // => true + * function Foo() { + * this.a = 1; + * } * - * _.isObject([1, 2, 3]); - * // => true + * function Bar() { + * this.c = 3; + * } * - * _.isObject(1); - * // => false + * Foo.prototype.b = 2; + * Bar.prototype.d = 4; + * + * _.assign({ 'a': 0 }, new Foo, new Bar); + * // => { 'a': 1, 'c': 3 } */ - function isObject(value) { - // check if the value is the ECMAScript language type of Object - // 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]); - } + var assign = createAssigner(function(object, source) { + if (isPrototype(source) || isArrayLike(source)) { + copyObject(source, keys(source), object); + return; + } + for (var key in source) { + if (hasOwnProperty.call(source, key)) { + assignValue(object, key, source[key]); + } + } + }); /** - * Checks if `value` is `NaN`. + * This method is like `_.assign` except that it iterates over own and + * inherited source properties. * - * 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. + * **Note:** This method mutates `object`. * * @static * @memberOf _ - * @category Objects - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is `NaN`, else `false`. + * @since 4.0.0 + * @alias extend + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. + * @see _.assign * @example * - * _.isNaN(NaN); - * // => true + * function Foo() { + * this.a = 1; + * } * - * _.isNaN(new Number(NaN)); - * // => true + * function Bar() { + * this.c = 3; + * } * - * isNaN(undefined); - * // => true + * Foo.prototype.b = 2; + * Bar.prototype.d = 4; * - * _.isNaN(undefined); - * // => false + * _.assignIn({ 'a': 0 }, new Foo, new Bar); + * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 } */ - 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; - } + var assignIn = createAssigner(function(object, source) { + copyObject(source, keysIn(source), object); + }); /** - * Checks if `value` is `null`. + * This method is like `_.assignIn` except that it accepts `customizer` + * which is invoked to produce the assigned values. If `customizer` returns + * `undefined`, assignment is handled by the method instead. The `customizer` + * is invoked with five arguments: (objValue, srcValue, key, object, source). + * + * **Note:** This method mutates `object`. * * @static * @memberOf _ - * @category Objects - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is `null`, else `false`. + * @since 4.0.0 + * @alias extendWith + * @category Object + * @param {Object} object The destination object. + * @param {...Object} sources The source objects. + * @param {Function} [customizer] The function to customize assigned values. + * @returns {Object} Returns `object`. + * @see _.assignWith * @example * - * _.isNull(null); - * // => true + * function customizer(objValue, srcValue) { + * return _.isUndefined(objValue) ? srcValue : objValue; + * } * - * _.isNull(undefined); - * // => false + * var defaults = _.partialRight(_.assignInWith, customizer); + * + * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); + * // => { 'a': 1, 'b': 2 } */ - function isNull(value) { - return value === null; - } + var assignInWith = createAssigner(function(object, source, srcIndex, customizer) { + copyObject(source, keysIn(source), object, customizer); + }); /** - * Checks if `value` is a number. + * This method is like `_.assign` except that it accepts `customizer` + * which is invoked to produce the assigned values. If `customizer` returns + * `undefined`, assignment is handled by the method instead. The `customizer` + * is invoked with five arguments: (objValue, srcValue, key, object, source). * - * Note: `NaN` is considered a number. See http://es5.github.io/#x8.5. + * **Note:** This method mutates `object`. * * @static * @memberOf _ - * @category Objects - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is a number, else `false`. + * @since 4.0.0 + * @category Object + * @param {Object} object The destination object. + * @param {...Object} sources The source objects. + * @param {Function} [customizer] The function to customize assigned values. + * @returns {Object} Returns `object`. + * @see _.assignInWith * @example * - * _.isNumber(8.4 * 5); - * // => true + * function customizer(objValue, srcValue) { + * return _.isUndefined(objValue) ? srcValue : objValue; + * } + * + * var defaults = _.partialRight(_.assignWith, customizer); + * + * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); + * // => { 'a': 1, 'b': 2 } */ - function isNumber(value) { - return typeof value == 'number' || - value && typeof value == 'object' && toString.call(value) == numberClass || false; - } + var assignWith = createAssigner(function(object, source, srcIndex, customizer) { + copyObject(source, keys(source), object, customizer); + }); + + /** + * Creates an array of values corresponding to `paths` of `object`. + * + * @static + * @memberOf _ + * @since 1.0.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {...(string|string[])} [paths] The property paths to pick. + * @returns {Array} Returns the picked values. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] }; + * + * _.at(object, ['a[0].b.c', 'a[1]']); + * // => [3, 4] + */ + var at = flatRest(baseAt); /** - * Checks if `value` is an object created by the `Object` constructor. + * Creates an object that inherits from the `prototype` object. If a + * `properties` object is given, its own enumerable string keyed properties + * are assigned to the created object. * * @static * @memberOf _ - * @category Objects - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a plain object, else `false`. + * @since 2.3.0 + * @category Object + * @param {Object} prototype The object to inherit from. + * @param {Object} [properties] The properties to assign to the object. + * @returns {Object} Returns the new object. * @example * * function Shape() { @@ -2862,3889 +12810,3451 @@ * this.y = 0; * } * - * _.isPlainObject(new Shape); - * // => false + * function Circle() { + * Shape.call(this); + * } * - * _.isPlainObject([1, 2, 3]); - * // => false + * Circle.prototype = _.create(Shape.prototype, { + * 'constructor': Circle + * }); * - * _.isPlainObject({ 'x': 0, 'y': 0 }); + * var circle = new Circle; + * circle instanceof Circle; + * // => true + * + * circle instanceof Shape; * // => true */ - var isPlainObject = !getPrototypeOf ? shimIsPlainObject : function(value) { - if (!(value && toString.call(value) == objectClass) || (!support.argsClass && isArguments(value))) { - return false; - } - var valueOf = value.valueOf, - objProto = isNative(valueOf) && (objProto = getPrototypeOf(valueOf)) && getPrototypeOf(objProto); - - return objProto - ? (value == objProto || getPrototypeOf(value) == objProto) - : shimIsPlainObject(value); - }; + function create(prototype, properties) { + var result = baseCreate(prototype); + return properties == null ? result : baseAssign(result, properties); + } /** - * Checks if `value` is a regular expression. + * Assigns own and inherited enumerable string keyed properties of source + * objects to the destination object for all destination properties that + * resolve to `undefined`. Source objects are applied from left to right. + * Once a property is set, additional values of the same property are ignored. + * + * **Note:** This method mutates `object`. * * @static + * @since 0.1.0 * @memberOf _ - * @category Objects - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is a regular expression, else `false`. + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. + * @see _.defaultsDeep * @example * - * _.isRegExp(/fred/); - * // => true + * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); + * // => { 'a': 1, 'b': 2 } */ - function isRegExp(value) { - return value && objectTypes[typeof value] && toString.call(value) == regexpClass || false; - } + var defaults = baseRest(function(object, sources) { + object = Object(object); + + var index = -1; + var length = sources.length; + var guard = length > 2 ? sources[2] : undefined; + + if (guard && isIterateeCall(sources[0], sources[1], guard)) { + length = 1; + } + + while (++index < length) { + var source = sources[index]; + var props = keysIn(source); + var propsIndex = -1; + var propsLength = props.length; + + while (++propsIndex < propsLength) { + var key = props[propsIndex]; + var value = object[key]; + + if (value === undefined || + (eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) { + object[key] = source[key]; + } + } + } + + return object; + }); /** - * Checks if `value` is a string. + * This method is like `_.defaults` except that it recursively assigns + * default properties. + * + * **Note:** This method mutates `object`. * * @static * @memberOf _ - * @category Objects - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is a string, else `false`. + * @since 3.10.0 + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. + * @see _.defaults * @example * - * _.isString('fred'); - * // => true + * _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } }); + * // => { 'a': { 'b': 2, 'c': 3 } } */ - function isString(value) { - return typeof value == 'string' || - value && typeof value == 'object' && toString.call(value) == stringClass || false; - } + var defaultsDeep = baseRest(function(args) { + args.push(undefined, customDefaultsMerge); + return apply(mergeWith, undefined, args); + }); /** - * Checks if `value` is `undefined`. + * This method is like `_.find` except that it returns the key of the first + * element `predicate` returns truthy for instead of the element itself. * * @static * @memberOf _ - * @category Objects - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if the `value` is `undefined`, else `false`. + * @since 1.1.0 + * @category Object + * @param {Object} object The object to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {string|undefined} Returns the key of the matched element, + * else `undefined`. * @example * - * _.isUndefined(void 0); - * // => true + * var users = { + * 'barney': { 'age': 36, 'active': true }, + * 'fred': { 'age': 40, 'active': false }, + * 'pebbles': { 'age': 1, 'active': true } + * }; + * + * _.findKey(users, function(o) { return o.age < 40; }); + * // => 'barney' (iteration order is not guaranteed) + * + * // The `_.matches` iteratee shorthand. + * _.findKey(users, { 'age': 1, 'active': true }); + * // => 'pebbles' + * + * // The `_.matchesProperty` iteratee shorthand. + * _.findKey(users, ['active', false]); + * // => 'fred' + * + * // The `_.property` iteratee shorthand. + * _.findKey(users, 'active'); + * // => 'barney' */ - function isUndefined(value) { - return typeof value == 'undefined'; + function findKey(object, predicate) { + return baseFindKey(object, getIteratee(predicate, 3), baseForOwn); } /** - * Creates an object with the same keys as `object` and values generated by - * running each own enumerable property of `object` through the callback. - * The callback is bound to `thisArg` and invoked with three arguments; - * (value, key, object). - * - * 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`. + * 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 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 object with values of the results of each `callback` execution. + * @since 2.0.0 + * @category Object + * @param {Object} object The object to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {string|undefined} Returns the key of the matched element, + * else `undefined`. * @example * - * _.mapValues({ 'a': 1, 'b': 2, 'c': 3} , function(num) { return num * 3; }); - * // => { 'a': 3, 'b': 6, 'c': 9 } - * - * var characters = { - * 'fred': { 'name': 'fred', 'age': 40 }, - * 'pebbles': { 'name': 'pebbles', 'age': 1 } + * var users = { + * 'barney': { 'age': 36, 'active': true }, + * 'fred': { 'age': 40, 'active': false }, + * 'pebbles': { 'age': 1, 'active': true } * }; * - * // using "_.pluck" callback shorthand - * _.mapValues(characters, 'age'); - * // => { 'fred': 40, 'pebbles': 1 } + * _.findLastKey(users, function(o) { return o.age < 40; }); + * // => returns 'pebbles' assuming `_.findKey` returns 'barney' + * + * // The `_.matches` iteratee shorthand. + * _.findLastKey(users, { 'age': 36, 'active': true }); + * // => 'barney' + * + * // The `_.matchesProperty` iteratee shorthand. + * _.findLastKey(users, ['active', false]); + * // => 'fred' + * + * // The `_.property` iteratee shorthand. + * _.findLastKey(users, 'active'); + * // => 'pebbles' */ - function mapValues(object, callback, thisArg) { - var result = {}; - callback = lodash.createCallback(callback, thisArg, 3); - - forOwn(object, function(value, key, object) { - result[key] = callback(value, key, object); - }); - return result; + function findLastKey(object, predicate) { + return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight); } /** - * 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 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). + * Iterates over own and inherited enumerable string keyed properties of an + * object and invokes `iteratee` for each property. The iteratee is invoked + * with three arguments: (value, key, object). Iteratee functions may exit + * iteration early by explicitly returning `false`. * * @static * @memberOf _ - * @category Objects - * @param {Object} object The destination object. - * @param {...Object} [source] The source objects. - * @param {Function} [callback] The function to customize merging properties. - * @param {*} [thisArg] The `this` binding of `callback`. - * @returns {Object} Returns the destination object. + * @since 0.3.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns `object`. + * @see _.forInRight * @example * - * var names = { - * 'characters': [ - * { 'name': 'barney' }, - * { 'name': 'fred' } - * ] - * }; - * - * var ages = { - * 'characters': [ - * { 'age': 36 }, - * { 'age': 40 } - * ] - * }; - * - * _.merge(names, ages); - * // => { 'characters': [{ 'name': 'barney', 'age': 36 }, { 'name': 'fred', 'age': 40 }] } - * - * var food = { - * 'fruits': ['apple'], - * 'vegetables': ['beet'] - * }; + * function Foo() { + * this.a = 1; + * this.b = 2; + * } * - * var otherFood = { - * 'fruits': ['banana'], - * 'vegetables': ['carrot'] - * }; + * Foo.prototype.c = 3; * - * _.merge(food, otherFood, function(a, b) { - * return _.isArray(a) ? a.concat(b) : undefined; + * _.forIn(new Foo, function(value, key) { + * console.log(key); * }); - * // => { 'fruits': ['apple', 'banana'], 'vegetables': ['beet', 'carrot] } + * // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed). */ - 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 = slice(arguments, 1, length), - index = -1, - stackA = getArray(), - stackB = getArray(); - - while (++index < length) { - baseMerge(object, sources[index], callback, stackA, stackB); - } - releaseArray(stackA); - releaseArray(stackB); - return object; + function forIn(object, iteratee) { + return object == null + ? object + : baseFor(object, getIteratee(iteratee, 3), keysIn); } /** - * 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 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). + * This method is like `_.forIn` except that it iterates over properties of + * `object` in the opposite order. * * @static * @memberOf _ - * @category Objects - * @param {Object} object The source object. - * @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. + * @since 2.0.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns `object`. + * @see _.forIn * @example * - * _.omit({ 'name': 'fred', 'age': 40 }, 'age'); - * // => { 'name': 'fred' } + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; * - * _.omit({ 'name': 'fred', 'age': 40 }, function(value) { - * return typeof value == 'number'; + * _.forInRight(new Foo, function(value, key) { + * console.log(key); * }); - * // => { 'name': 'fred' } + * // => Logs 'c', 'b', then 'a' assuming `_.forIn` logs 'a', 'b', then 'c'. */ - function omit(object, callback, thisArg) { - var result = {}; - if (typeof callback != 'function') { - var props = []; - forIn(object, function(value, key) { - props.push(key); - }); - props = baseDifference(props, baseFlatten(arguments, true, false, 1)); - - var index = -1, - length = props.length; - - while (++index < length) { - var key = props[index]; - result[key] = object[key]; - } - } else { - callback = lodash.createCallback(callback, thisArg, 3); - forIn(object, function(value, key, object) { - if (!callback(value, key, object)) { - result[key] = value; - } - }); - } - return result; + function forInRight(object, iteratee) { + return object == null + ? object + : baseForRight(object, getIteratee(iteratee, 3), keysIn); } /** - * Creates a two dimensional array of an object's key-value pairs, - * i.e. `[[key1, value1], [key2, value2]]`. + * Iterates over own enumerable string keyed properties of an object and + * invokes `iteratee` for each property. The iteratee is invoked with three + * arguments: (value, key, object). Iteratee functions may exit iteration + * early by explicitly returning `false`. * * @static * @memberOf _ - * @category Objects - * @param {Object} object The object to inspect. - * @returns {Array} Returns new array of key-value pairs. + * @since 0.3.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns `object`. + * @see _.forOwnRight * @example * - * _.pairs({ 'barney': 36, 'fred': 40 }); - * // => [['barney', 36], ['fred', 40]] (property order is not guaranteed across environments) + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.forOwn(new Foo, function(value, key) { + * console.log(key); + * }); + * // => Logs 'a' then 'b' (iteration order is not guaranteed). */ - function pairs(object) { - var index = -1, - props = keys(object), - length = props.length, - result = Array(length); - - while (++index < length) { - var key = props[index]; - result[index] = [key, object[key]]; - } - return result; + function forOwn(object, iteratee) { + return object && baseForOwn(object, getIteratee(iteratee, 3)); } /** - * 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 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). + * This method is like `_.forOwn` except that it iterates over properties of + * `object` in the opposite order. * * @static * @memberOf _ - * @category Objects - * @param {Object} object The source object. - * @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. + * @since 2.0.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns `object`. + * @see _.forOwn * @example * - * _.pick({ 'name': 'fred', '_userid': 'fred1' }, 'name'); - * // => { 'name': 'fred' } + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; * - * _.pick({ 'name': 'fred', '_userid': 'fred1' }, function(value, key) { - * return key.charAt(0) != '_'; + * _.forOwnRight(new Foo, function(value, key) { + * console.log(key); * }); - * // => { 'name': 'fred' } + * // => Logs 'b' then 'a' assuming `_.forOwn` logs 'a' then 'b'. */ - function pick(object, callback, thisArg) { - var result = {}; - if (typeof callback != 'function') { - var index = -1, - props = baseFlatten(arguments, true, false, 1), - length = isObject(object) ? props.length : 0; - - while (++index < length) { - var key = props[index]; - if (key in object) { - result[key] = object[key]; - } - } - } else { - callback = lodash.createCallback(callback, thisArg, 3); - forIn(object, function(value, key, object) { - if (callback(value, key, object)) { - result[key] = value; - } - }); - } - return result; + function forOwnRight(object, iteratee) { + return object && baseForOwnRight(object, getIteratee(iteratee, 3)); } /** - * An alternative to `_.reduce` this method transforms `object` to a new - * `accumulator` object which is the result of running each of its own - * enumerable properties 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`. + * Creates an array of function property names from own enumerable properties + * of `object`. * * @static + * @since 0.1.0 * @memberOf _ - * @category Objects - * @param {Array|Object} object The object to iterate over. - * @param {Function} [callback=identity] The function called per iteration. - * @param {*} [accumulator] The custom accumulator value. - * @param {*} [thisArg] The `this` binding of `callback`. - * @returns {*} Returns the accumulated value. + * @category Object + * @param {Object} object The object to inspect. + * @returns {Array} Returns the function names. + * @see _.functionsIn * @example * - * var squares = _.transform([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], function(result, num) { - * num *= num; - * if (num % 2) { - * return result.push(num) < 3; - * } - * }); - * // => [1, 9, 25] + * function Foo() { + * this.a = _.constant('a'); + * this.b = _.constant('b'); + * } * - * var mapped = _.transform({ 'a': 1, 'b': 2, 'c': 3 }, function(result, num, key) { - * result[key] = num * 3; - * }); - * // => { 'a': 3, 'b': 6, 'c': 9 } + * Foo.prototype.c = _.constant('c'); + * + * _.functions(new Foo); + * // => ['a', 'b'] */ - function transform(object, callback, accumulator, thisArg) { - var isArr = isArray(object); - if (accumulator == null) { - if (isArr) { - accumulator = []; - } else { - var ctor = object && object.constructor, - proto = ctor && ctor.prototype; - - accumulator = baseCreate(proto); - } - } - if (callback) { - callback = lodash.createCallback(callback, thisArg, 4); - (isArr ? baseEach : forOwn)(object, function(value, index, object) { - return callback(accumulator, value, index, object); - }); - } - return accumulator; + function functions(object) { + return object == null ? [] : baseFunctions(object, keys(object)); } /** - * Creates an array composed of the own enumerable property values of `object`. + * Creates an array of function property names from own and inherited + * enumerable properties of `object`. * * @static * @memberOf _ - * @category Objects + * @since 4.0.0 + * @category Object * @param {Object} object The object to inspect. - * @returns {Array} Returns an array of property values. + * @returns {Array} Returns the function names. + * @see _.functions * @example * - * _.values({ 'one': 1, 'two': 2, 'three': 3 }); - * // => [1, 2, 3] (property order is not guaranteed across environments) + * function Foo() { + * this.a = _.constant('a'); + * this.b = _.constant('b'); + * } + * + * Foo.prototype.c = _.constant('c'); + * + * _.functionsIn(new Foo); + * // => ['a', 'b', 'c'] */ - function values(object) { - var index = -1, - props = keys(object), - length = props.length, - result = Array(length); - - while (++index < length) { - result[index] = object[props[index]]; - } - return result; + function functionsIn(object) { + return object == null ? [] : baseFunctions(object, keysIn(object)); } - /*--------------------------------------------------------------------------*/ - /** - * Creates an array of elements from the specified indexes, or keys, of the - * `collection`. Indexes may be specified as individual arguments or as arrays - * of indexes. + * Gets the value at `path` of `object`. If the resolved value is + * `undefined`, the `defaultValue` is returned in its place. * * @static * @memberOf _ - * @category Collections - * @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. + * @since 3.7.0 + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path of the property to get. + * @param {*} [defaultValue] The value returned for `undefined` resolved values. + * @returns {*} Returns the resolved value. * @example * - * _.at(['a', 'b', 'c', 'd', 'e'], [0, 2, 4]); - * // => ['a', 'c', 'e'] + * var object = { 'a': [{ 'b': { 'c': 3 } }] }; + * + * _.get(object, 'a[0].b.c'); + * // => 3 + * + * _.get(object, ['a', '0', 'b', 'c']); + * // => 3 * - * _.at(['fred', 'barney', 'pebbles'], 0, 2); - * // => ['fred', 'pebbles'] + * _.get(object, 'a.b.c', 'default'); + * // => 'default' */ - function at(collection) { - 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)) { - collection = collection.split(''); - } - while(++index < length) { - result[index] = collection[props[index]]; - } - return result; + function get(object, path, defaultValue) { + var result = object == null ? undefined : baseGet(object, path); + return result === undefined ? defaultValue : result; } /** - * 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. + * Checks if `path` is a direct property of `object`. * * @static + * @since 0.1.0 * @memberOf _ - * @alias include - * @category Collections - * @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`. + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path to check. + * @returns {boolean} Returns `true` if `path` exists, else `false`. * @example * - * _.contains([1, 2, 3], 1); + * var object = { 'a': { 'b': 2 } }; + * var other = _.create({ 'a': _.create({ 'b': 2 }) }); + * + * _.has(object, 'a'); + * // => true + * + * _.has(object, 'a.b'); + * // => true + * + * _.has(object, ['a', 'b']); * // => true * - * _.contains([1, 2, 3], 1, 2); + * _.has(other, 'a'); * // => false + */ + function has(object, path) { + return object != null && hasPath(object, path, baseHas); + } + + /** + * Checks if `path` is a direct or inherited property of `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path to check. + * @returns {boolean} Returns `true` if `path` exists, else `false`. + * @example * - * _.contains({ 'name': 'fred', 'age': 40 }, 'fred'); + * var object = _.create({ 'a': _.create({ 'b': 2 }) }); + * + * _.hasIn(object, 'a'); + * // => true + * + * _.hasIn(object, 'a.b'); * // => true * - * _.contains('pebbles', 'eb'); + * _.hasIn(object, ['a', 'b']); * // => true + * + * _.hasIn(object, 'b'); + * // => false */ - function contains(collection, target, fromIndex) { - var index = -1, - indexOf = getIndexOf(), - length = collection ? collection.length : 0, - result = false; - - fromIndex = (fromIndex < 0 ? nativeMax(0, length + fromIndex) : fromIndex) || 0; - 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 { - baseEach(collection, function(value) { - if (++index >= fromIndex) { - return !(result = value === target); - } - }); - } - return result; + function hasIn(object, path) { + return object != null && hasPath(object, path, baseHasIn); } /** - * 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). + * Creates an object composed of the inverted keys and values of `object`. + * If `object` contains duplicate values, subsequent values overwrite + * property assignments of previous values. + * + * @static + * @memberOf _ + * @since 0.7.0 + * @category Object + * @param {Object} object The object to invert. + * @returns {Object} Returns the new inverted object. + * @example * - * If a property name is provided for `callback` the created "_.pluck" style - * callback will return the property value of the given element. + * var object = { 'a': 1, 'b': 2, 'c': 1 }; * - * 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`. + * _.invert(object); + * // => { '1': 'c', '2': 'b' } + */ + var invert = createInverter(function(result, value, key) { + if (value != null && + typeof value.toString != 'function') { + value = nativeObjectToString.call(value); + } + + result[value] = key; + }, constant(identity)); + + /** + * This method is like `_.invert` except that the inverted object is generated + * from the results of running each element of `object` thru `iteratee`. The + * corresponding inverted value of each inverted key is an array of keys + * responsible for generating the inverted value. The iteratee is invoked + * with one argument: (value). * * @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. + * @since 4.1.0 + * @category Object + * @param {Object} object The object to invert. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Object} Returns the new inverted object. * @example * - * _.countBy([4.3, 6.1, 6.4], function(num) { return Math.floor(num); }); - * // => { '4': 1, '6': 2 } + * var object = { 'a': 1, 'b': 2, 'c': 1 }; * - * _.countBy([4.3, 6.1, 6.4], function(num) { return this.floor(num); }, Math); - * // => { '4': 1, '6': 2 } + * _.invertBy(object); + * // => { '1': ['a', 'c'], '2': ['b'] } * - * _.countBy(['one', 'two', 'three'], 'length'); - * // => { '3': 2, '5': 1 } + * _.invertBy(object, function(value) { + * return 'group' + value; + * }); + * // => { 'group1': ['a', 'c'], 'group2': ['b'] } */ - var countBy = createAggregator(function(result, value, key) { - (hasOwnProperty.call(result, key) ? result[key]++ : result[key] = 1); - }); + var invertBy = createInverter(function(result, value, key) { + if (value != null && + typeof value.toString != 'function') { + value = nativeObjectToString.call(value); + } + + if (hasOwnProperty.call(result, value)) { + result[value].push(key); + } else { + result[value] = [key]; + } + }, getIteratee); /** - * 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 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`. + * Invokes the method at `path` of `object`. * * @static * @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 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`. + * @since 4.0.0 + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path of the method to invoke. + * @param {...*} [args] The arguments to invoke the method with. + * @returns {*} Returns the result of the invoked method. * @example * - * _.every([true, 1, null, 'yes']); - * // => false - * - * var characters = [ - * { 'name': 'barney', 'age': 36 }, - * { 'name': 'fred', 'age': 40 } - * ]; - * - * // using "_.pluck" callback shorthand - * _.every(characters, 'age'); - * // => true + * var object = { 'a': [{ 'b': { 'c': [1, 2, 3, 4] } }] }; * - * // using "_.where" callback shorthand - * _.every(characters, { 'age': 36 }); - * // => false + * _.invoke(object, 'a[0].b.c.slice', 1, 3); + * // => [2, 3] */ - function every(collection, callback, thisArg) { - var result = true; - callback = lodash.createCallback(callback, thisArg, 3); - - if (isArray(collection)) { - var index = -1, - length = collection.length; - - while (++index < length) { - if (!(result = !!callback(collection[index], index, collection))) { - break; - } - } - } else { - baseEach(collection, function(value, index, collection) { - return (result = !!callback(value, index, collection)); - }); - } - return result; - } + var invoke = baseRest(baseInvoke); /** - * 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 provided for `callback` the created "_.pluck" style - * callback will return the property value of the given element. + * Creates an array of the own enumerable property names of `object`. * - * 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`. + * **Note:** Non-object values are coerced to objects. See the + * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) + * for more details. * * @static + * @since 0.1.0 * @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 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. + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. * @example * - * var evens = _.filter([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; }); - * // => [2, 4, 6] + * function Foo() { + * this.a = 1; + * this.b = 2; + * } * - * var characters = [ - * { 'name': 'barney', 'age': 36, 'blocked': false }, - * { 'name': 'fred', 'age': 40, 'blocked': true } - * ]; + * Foo.prototype.c = 3; * - * // using "_.pluck" callback shorthand - * _.filter(characters, 'blocked'); - * // => [{ 'name': 'fred', 'age': 40, 'blocked': true }] + * _.keys(new Foo); + * // => ['a', 'b'] (iteration order is not guaranteed) * - * // using "_.where" callback shorthand - * _.filter(characters, { 'age': 36 }); - * // => [{ 'name': 'barney', 'age': 36, 'blocked': false }] + * _.keys('hi'); + * // => ['0', '1'] */ - function filter(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]; - if (callback(value, index, collection)) { - result.push(value); - } - } - } else { - baseEach(collection, function(value, index, collection) { - if (callback(value, index, collection)) { - result.push(value); - } - }); - } - return result; + function keys(object) { + return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object); } /** - * 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). + * Creates an array of the own and inherited enumerable property names of `object`. * - * 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`. + * **Note:** Non-object values are coerced to objects. * * @static * @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 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`. + * @since 3.0.0 + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. * @example * - * var characters = [ - * { 'name': 'barney', 'age': 36, 'blocked': false }, - * { 'name': 'fred', 'age': 40, 'blocked': true }, - * { 'name': 'pebbles', 'age': 1, 'blocked': false } - * ]; - * - * _.find(characters, function(chr) { - * return chr.age < 40; - * }); - * // => { 'name': 'barney', 'age': 36, 'blocked': false } + * function Foo() { + * this.a = 1; + * this.b = 2; + * } * - * // using "_.where" callback shorthand - * _.find(characters, { 'age': 1 }); - * // => { 'name': 'pebbles', 'age': 1, 'blocked': false } + * Foo.prototype.c = 3; * - * // using "_.pluck" callback shorthand - * _.find(characters, 'blocked'); - * // => { 'name': 'fred', 'age': 40, 'blocked': true } + * _.keysIn(new Foo); + * // => ['a', 'b', 'c'] (iteration order is not guaranteed) */ - function find(collection, callback, thisArg) { - callback = lodash.createCallback(callback, thisArg, 3); - - if (isArray(collection)) { - var index = -1, - length = collection.length; - - while (++index < length) { - var value = collection[index]; - if (callback(value, index, collection)) { - return value; - } - } - } else { - var result; - baseEach(collection, function(value, index, collection) { - if (callback(value, index, collection)) { - result = value; - return false; - } - }); - return result; - } + function keysIn(object) { + return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object); } /** - * This method is like `_.find` except that it iterates over elements - * of a `collection` from right to left. + * The opposite of `_.mapValues`; this method creates an object with the + * same values as `object` and keys generated by running each own enumerable + * string keyed property of `object` thru `iteratee`. The iteratee is invoked + * with three arguments: (value, key, object). * * @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`. + * @since 3.8.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns the new mapped object. + * @see _.mapValues * @example * - * _.findLast([1, 2, 3, 4], function(num) { - * return num % 2 == 1; + * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) { + * return key + value; * }); - * // => 3 + * // => { 'a1': 1, 'b2': 2 } */ - 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; - } + function mapKeys(object, iteratee) { + var result = {}; + iteratee = getIteratee(iteratee, 3); + + baseForOwn(object, function(value, key, object) { + baseAssignValue(result, iteratee(value, key, object), value); }); 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`. - * - * Note: As with other "Collections" methods, objects with a `length` property - * are iterated like arrays. To avoid this behavior `_.forIn` or `_.forOwn` - * may be used for object iteration. + * Creates an object with the same keys as `object` and values generated + * by running each own enumerable string keyed property of `object` thru + * `iteratee`. The iteratee is invoked with three arguments: + * (value, key, object). * * @static * @memberOf _ - * @alias each - * @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`. + * @since 2.4.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns the new mapped object. + * @see _.mapKeys * @example * - * _([1, 2, 3]).forEach(function(num) { console.log(num); }).join(','); - * // => logs each number and returns '1,2,3' + * var users = { + * 'fred': { 'user': 'fred', 'age': 40 }, + * 'pebbles': { 'user': 'pebbles', 'age': 1 } + * }; + * + * _.mapValues(users, function(o) { return o.age; }); + * // => { 'fred': 40, 'pebbles': 1 } (iteration 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) + * // The `_.property` iteratee shorthand. + * _.mapValues(users, 'age'); + * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed) */ - function forEach(collection, callback, thisArg) { - if (callback && typeof thisArg == 'undefined' && isArray(collection)) { - var index = -1, - length = collection.length; + function mapValues(object, iteratee) { + var result = {}; + iteratee = getIteratee(iteratee, 3); - while (++index < length) { - if (callback(collection[index], index, collection) === false) { - break; - } - } - } else { - baseEach(collection, callback, thisArg); - } - return collection; + baseForOwn(object, function(value, key, object) { + baseAssignValue(result, key, iteratee(value, key, object)); + }); + return result; } /** - * This method is like `_.forEach` except that it iterates over elements - * of a `collection` from right to left. + * This method is like `_.assign` except that it recursively merges own and + * inherited enumerable string keyed properties of source objects into the + * destination object. Source properties that resolve to `undefined` are + * skipped if a destination value exists. Array and plain object properties + * are merged recursively. Other objects and value types are overridden by + * assignment. Source objects are applied from left to right. Subsequent + * sources overwrite property assignments of previous sources. + * + * **Note:** This method mutates `object`. * * @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`. + * @since 0.5.0 + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. * @example * - * _([1, 2, 3]).forEachRight(function(num) { console.log(num); }).join(','); - * // => logs each number from right to left and returns '3,2,1' + * var object = { + * 'a': [{ 'b': 2 }, { 'd': 4 }] + * }; + * + * var other = { + * 'a': [{ 'c': 3 }, { 'e': 5 }] + * }; + * + * _.merge(object, other); + * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] } */ - 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; - } + var merge = createAssigner(function(object, source, srcIndex) { + baseMerge(object, source, srcIndex); + }); /** - * 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 provided for `callback` the created "_.pluck" style - * callback will return the property value of the given element. + * This method is like `_.merge` except that it accepts `customizer` which + * is invoked to produce the merged values of the destination and source + * properties. If `customizer` returns `undefined`, merging is handled by the + * method instead. The `customizer` is invoked with six arguments: + * (objValue, srcValue, key, object, source, stack). * - * 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` + * **Note:** This method mutates `object`. * * @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. + * @since 4.0.0 + * @category Object + * @param {Object} object The destination object. + * @param {...Object} sources The source objects. + * @param {Function} customizer The function to customize assigned values. + * @returns {Object} Returns `object`. * @example * - * _.groupBy([4.2, 6.1, 6.4], function(num) { return Math.floor(num); }); - * // => { '4': [4.2], '6': [6.1, 6.4] } + * function customizer(objValue, srcValue) { + * if (_.isArray(objValue)) { + * return objValue.concat(srcValue); + * } + * } * - * _.groupBy([4.2, 6.1, 6.4], function(num) { return this.floor(num); }, Math); - * // => { '4': [4.2], '6': [6.1, 6.4] } + * var object = { 'a': [1], 'b': [2] }; + * var other = { 'a': [3], 'b': [4] }; * - * // using "_.pluck" callback shorthand - * _.groupBy(['one', 'two', 'three'], 'length'); - * // => { '3': ['one', 'two'], '5': ['three'] } + * _.mergeWith(object, other, customizer); + * // => { 'a': [1, 3], 'b': [2, 4] } */ - var groupBy = createAggregator(function(result, value, key) { - (hasOwnProperty.call(result, key) ? result[key] : result[key] = []).push(value); + var mergeWith = createAssigner(function(object, source, srcIndex, customizer) { + baseMerge(object, source, srcIndex, customizer); }); /** - * 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). + * The opposite of `_.pick`; this method creates an object composed of the + * own and inherited enumerable property paths of `object` that are not omitted. * - * If a property name is provided for `callback` the created "_.pluck" style - * callback will return the property value of the given element. + * **Note:** This method is considerably slower than `_.pick`. * - * 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 + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The source object. + * @param {...(string|string[])} [paths] The property paths to omit. + * @returns {Object} Returns the new object. + * @example + * + * var object = { 'a': 1, 'b': '2', 'c': 3 }; + * + * _.omit(object, ['a', 'c']); + * // => { 'b': '2' } + */ + var omit = flatRest(function(object, paths) { + var result = {}; + if (object == null) { + return result; + } + var isDeep = false; + paths = arrayMap(paths, function(path) { + path = castPath(path, object); + isDeep || (isDeep = path.length > 1); + return path; + }); + copyObject(object, getAllKeysIn(object), result); + if (isDeep) { + result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone); + } + var length = paths.length; + while (length--) { + baseUnset(result, paths[length]); + } + return result; + }); + + /** + * The opposite of `_.pickBy`; this method creates an object composed of + * the own and inherited enumerable string keyed properties of `object` that + * `predicate` doesn't return truthy for. The predicate is invoked with two + * arguments: (value, key). * * @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. + * @since 4.0.0 + * @category Object + * @param {Object} object The source object. + * @param {Function} [predicate=_.identity] The function invoked per property. + * @returns {Object} Returns the new object. * @example * - * var keys = [ - * { 'dir': 'left', 'code': 97 }, - * { 'dir': 'right', 'code': 100 } - * ]; + * var object = { 'a': 1, 'b': '2', 'c': 3 }; * - * _.indexBy(keys, 'dir'); - * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } } + * _.omitBy(object, _.isNumber); + * // => { 'b': '2' } + */ + function omitBy(object, predicate) { + return pickBy(object, negate(getIteratee(predicate))); + } + + /** + * Creates an object composed of the picked `object` properties. * - * _.indexBy(keys, function(key) { return String.fromCharCode(key.code); }); - * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } } + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The source object. + * @param {...(string|string[])} [paths] The property paths to pick. + * @returns {Object} Returns the new object. + * @example * - * _.indexBy(characters, function(key) { this.fromCharCode(key.code); }, String); - * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } } + * var object = { 'a': 1, 'b': '2', 'c': 3 }; + * + * _.pick(object, ['a', 'c']); + * // => { 'a': 1, 'c': 3 } */ - var indexBy = createAggregator(function(result, value, key) { - result[key] = value; + var pick = flatRest(function(object, paths) { + return object == null ? {} : basePick(object, paths); }); /** - * 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 provided to each invoked method. If `methodName` is a function it - * will be invoked for, and `this` bound to, each element in the `collection`. + * Creates an object composed of the `object` properties `predicate` returns + * truthy for. The predicate is invoked with two arguments: (value, key). * * @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 - * the function invoked per iteration. - * @param {...*} [arg] Arguments to invoke the method with. - * @returns {Array} Returns a new array of the results of each invoked method. + * @since 4.0.0 + * @category Object + * @param {Object} object The source object. + * @param {Function} [predicate=_.identity] The function invoked per property. + * @returns {Object} Returns the new object. * @example * - * _.invoke([[5, 1, 7], [3, 2, 1]], 'sort'); - * // => [[1, 5, 7], [1, 2, 3]] + * var object = { 'a': 1, 'b': '2', 'c': 3 }; * - * _.invoke([123, 456], String.prototype.split, ''); - * // => [['1', '2', '3'], ['4', '5', '6']] + * _.pickBy(object, _.isNumber); + * // => { 'a': 1, 'c': 3 } */ - function invoke(collection, methodName) { - var args = slice(arguments, 2), - index = -1, - isFunc = typeof methodName == 'function', - length = collection ? collection.length : 0, - result = Array(typeof length == 'number' ? length : 0); - - forEach(collection, function(value) { - result[++index] = (isFunc ? methodName : value[methodName]).apply(value, args); + function pickBy(object, predicate) { + if (object == null) { + return {}; + } + var props = arrayMap(getAllKeysIn(object), function(prop) { + return [prop]; + }); + predicate = getIteratee(predicate); + return basePickBy(object, props, function(value, path) { + return predicate(value, path[0]); }); - return result; } /** - * 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 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`. + * This method is like `_.get` except that if the resolved value is a + * function it's invoked with the `this` binding of its parent object and + * its result is returned. * * @static + * @since 0.1.0 * @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 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. + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path of the property to resolve. + * @param {*} [defaultValue] The value returned for `undefined` resolved values. + * @returns {*} Returns the resolved value. * @example * - * _.map([1, 2, 3], function(num) { return num * 3; }); - * // => [3, 6, 9] + * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] }; * - * _.map({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { return num * 3; }); - * // => [3, 6, 9] (property order is not guaranteed across environments) + * _.result(object, 'a[0].b.c1'); + * // => 3 * - * var characters = [ - * { 'name': 'barney', 'age': 36 }, - * { 'name': 'fred', 'age': 40 } - * ]; + * _.result(object, 'a[0].b.c2'); + * // => 4 * - * // using "_.pluck" callback shorthand - * _.map(characters, 'name'); - * // => ['barney', 'fred'] + * _.result(object, 'a[0].b.c3', 'default'); + * // => 'default' + * + * _.result(object, 'a[0].b.c3', _.constant('default')); + * // => 'default' */ - function map(collection, callback, thisArg) { + function result(object, path, defaultValue) { + path = castPath(path, object); + var index = -1, - length = collection ? collection.length : 0, - result = Array(typeof length == 'number' ? length : 0); + length = path.length; - callback = lodash.createCallback(callback, thisArg, 3); - if (isArray(collection)) { - while (++index < length) { - result[index] = callback(collection[index], index, collection); + // Ensure the loop is entered when path is empty. + if (!length) { + length = 1; + object = undefined; + } + while (++index < length) { + var value = object == null ? undefined : object[toKey(path[index])]; + if (value === undefined) { + index = length; + value = defaultValue; } - } else { - baseEach(collection, function(value, key, collection) { - result[++index] = callback(value, key, collection); - }); + object = isFunction(value) ? value.call(object) : value; } - return result; + return object; } /** - * Retrieves the maximum value of a collection. If the collection is empty or - * falsey `-Infinity` is returned. If a callback is provided it will be executed - * for each value in the collection 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 provided for `callback` the created "_.pluck" style - * callback will return the property value of the given element. + * Sets the value at `path` of `object`. If a portion of `path` doesn't exist, + * it's created. Arrays are created for missing index properties while objects + * are created for all other missing properties. Use `_.setWith` to customize + * `path` creation. * - * 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`. + * **Note:** This method mutates `object`. * * @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 maximum value. + * @since 3.7.0 + * @category Object + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to set. + * @param {*} value The value to set. + * @returns {Object} Returns `object`. * @example * - * _.max([4, 2, 8, 6]); - * // => 8 - * - * var characters = [ - * { 'name': 'barney', 'age': 36 }, - * { 'name': 'fred', 'age': 40 } - * ]; + * var object = { 'a': [{ 'b': { 'c': 3 } }] }; * - * _.max(characters, function(chr) { return chr.age; }); - * // => { 'name': 'fred', 'age': 40 }; + * _.set(object, 'a[0].b.c', 4); + * console.log(object.a[0].b.c); + * // => 4 * - * // using "_.pluck" callback shorthand - * _.max(characters, 'age'); - * // => { 'name': 'fred', 'age': 40 }; + * _.set(object, ['x', '0', 'y', 'z'], 5); + * console.log(object.x[0].y.z); + * // => 5 */ - function max(collection, callback, thisArg) { - var computed = -Infinity, - result = computed; - - // allows working with functions like `_.map` without using - // their `index` argument as a callback - if (typeof callback != 'function' && thisArg && thisArg[callback] === collection) { - callback = null; - } - if (callback == null && isArray(collection)) { - var index = -1, - length = collection.length; - - while (++index < length) { - var value = collection[index]; - if (value > result) { - result = value; - } - } - } else { - callback = (callback == null && isString(collection)) - ? charAtCallback - : lodash.createCallback(callback, thisArg, 3); - - baseEach(collection, function(value, index, collection) { - var current = callback(value, index, collection); - if (current > computed) { - computed = current; - result = value; - } - }); - } - return result; + function set(object, path, value) { + return object == null ? object : baseSet(object, path, value); } /** - * Retrieves the minimum value of a collection. If the collection is empty or - * falsey `Infinity` is returned. If a callback is provided it will be executed - * for each value in the collection 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 provided for `callback` the created "_.pluck" style - * callback will return the property value of the given element. + * This method is like `_.set` except that it accepts `customizer` which is + * invoked to produce the objects of `path`. If `customizer` returns `undefined` + * path creation is handled by the method instead. The `customizer` is invoked + * with three arguments: (nsValue, key, nsObject). * - * 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`. + * **Note:** This method mutates `object`. * * @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 minimum value. + * @since 4.0.0 + * @category Object + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to set. + * @param {*} value The value to set. + * @param {Function} [customizer] The function to customize assigned values. + * @returns {Object} Returns `object`. * @example * - * _.min([4, 2, 8, 6]); - * // => 2 + * var object = {}; * - * var characters = [ - * { 'name': 'barney', 'age': 36 }, - * { 'name': 'fred', 'age': 40 } - * ]; + * _.setWith(object, '[0][1]', 'a', Object); + * // => { '0': { '1': 'a' } } + */ + function setWith(object, path, value, customizer) { + customizer = typeof customizer == 'function' ? customizer : undefined; + return object == null ? object : baseSet(object, path, value, customizer); + } + + /** + * Creates an array of own enumerable string keyed-value pairs for `object` + * which can be consumed by `_.fromPairs`. If `object` is a map or set, its + * entries are returned. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @alias entries + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the key-value pairs. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } * - * _.min(characters, function(chr) { return chr.age; }); - * // => { 'name': 'barney', 'age': 36 }; + * Foo.prototype.c = 3; * - * // using "_.pluck" callback shorthand - * _.min(characters, 'age'); - * // => { 'name': 'barney', 'age': 36 }; + * _.toPairs(new Foo); + * // => [['a', 1], ['b', 2]] (iteration order is not guaranteed) */ - function min(collection, callback, thisArg) { - var computed = Infinity, - result = computed; - - // allows working with functions like `_.map` without using - // their `index` argument as a callback - if (typeof callback != 'function' && thisArg && thisArg[callback] === collection) { - callback = null; - } - if (callback == null && isArray(collection)) { - var index = -1, - length = collection.length; - - while (++index < length) { - var value = collection[index]; - if (value < result) { - result = value; - } - } - } else { - callback = (callback == null && isString(collection)) - ? charAtCallback - : lodash.createCallback(callback, thisArg, 3); - - baseEach(collection, function(value, index, collection) { - var current = callback(value, index, collection); - if (current < computed) { - computed = current; - result = value; - } - }); - } - return result; - } + var toPairs = createToPairs(keys); /** - * Retrieves the value of a specified property from all elements in the collection. + * Creates an array of own and inherited enumerable string keyed-value pairs + * for `object` which can be consumed by `_.fromPairs`. If `object` is a map + * or set, its entries are returned. * * @static * @memberOf _ - * @type Function - * @category Collections - * @param {Array|Object|string} collection The collection to iterate over. - * @param {string} property The name of the property to pluck. - * @returns {Array} Returns a new array of property values. + * @since 4.0.0 + * @alias entriesIn + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the key-value pairs. * @example * - * var characters = [ - * { 'name': 'barney', 'age': 36 }, - * { 'name': 'fred', 'age': 40 } - * ]; + * function Foo() { + * this.a = 1; + * this.b = 2; + * } * - * _.pluck(characters, 'name'); - * // => ['barney', 'fred'] + * Foo.prototype.c = 3; + * + * _.toPairsIn(new Foo); + * // => [['a', 1], ['b', 2], ['c', 3]] (iteration order is not guaranteed) */ - var pluck = map; + var toPairsIn = createToPairs(keysIn); /** - * 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). + * An alternative to `_.reduce`; this method transforms `object` to a new + * `accumulator` object which is the result of running each of its own + * enumerable string keyed properties thru `iteratee`, with each invocation + * potentially mutating the `accumulator` object. If `accumulator` is not + * provided, a new object with the same `[[Prototype]]` will be used. The + * iteratee is invoked with four arguments: (accumulator, value, key, object). + * Iteratee functions may exit iteration early by explicitly returning `false`. * * @static * @memberOf _ - * @alias foldl, inject - * @category Collections - * @param {Array|Object|string} collection The collection to iterate over. - * @param {Function} [callback=identity] The function called per iteration. - * @param {*} [accumulator] Initial value of the accumulator. - * @param {*} [thisArg] The `this` binding of `callback`. + * @since 1.3.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @param {*} [accumulator] The custom accumulator value. * @returns {*} Returns the accumulated value. * @example * - * var sum = _.reduce([1, 2, 3], function(sum, num) { - * return sum + num; - * }); - * // => 6 + * _.transform([2, 3, 4], function(result, n) { + * result.push(n *= n); + * return n % 2 == 0; + * }, []); + * // => [4, 9] * - * var mapped = _.reduce({ 'a': 1, 'b': 2, 'c': 3 }, function(result, num, key) { - * result[key] = num * 3; - * return result; + * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) { + * (result[value] || (result[value] = [])).push(key); * }, {}); - * // => { 'a': 3, 'b': 6, 'c': 9 } + * // => { '1': ['a', 'c'], '2': ['b'] } */ - function reduce(collection, callback, accumulator, thisArg) { - var noaccum = arguments.length < 3; - callback = lodash.createCallback(callback, thisArg, 4); + function transform(object, iteratee, accumulator) { + var isArr = isArray(object), + isArrLike = isArr || isBuffer(object) || isTypedArray(object); - if (isArray(collection)) { - var index = -1, - length = collection.length; - - if (noaccum) { - accumulator = collection[++index]; + iteratee = getIteratee(iteratee, 4); + if (accumulator == null) { + var Ctor = object && object.constructor; + if (isArrLike) { + accumulator = isArr ? new Ctor : []; } - while (++index < length) { - accumulator = callback(accumulator, collection[index], index, collection); + else if (isObject(object)) { + accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {}; + } + else { + accumulator = {}; } - } else { - baseEach(collection, function(value, index, collection) { - accumulator = noaccum - ? (noaccum = false, value) - : callback(accumulator, value, index, collection) - }); } + (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object) { + return iteratee(accumulator, value, index, object); + }); return accumulator; } /** - * This method is like `_.reduce` except that it iterates over elements - * of a `collection` from right to left. + * Removes the property at `path` of `object`. + * + * **Note:** This method mutates `object`. * * @static * @memberOf _ - * @alias foldr - * @category Collections - * @param {Array|Object|string} collection The collection to iterate over. - * @param {Function} [callback=identity] The function called per iteration. - * @param {*} [accumulator] Initial value of the accumulator. - * @param {*} [thisArg] The `this` binding of `callback`. - * @returns {*} Returns the accumulated value. + * @since 4.0.0 + * @category Object + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to unset. + * @returns {boolean} Returns `true` if the property is deleted, else `false`. * @example * - * var list = [[0, 1], [2, 3], [4, 5]]; - * var flat = _.reduceRight(list, function(a, b) { return a.concat(b); }, []); - * // => [4, 5, 2, 3, 0, 1] - */ - function reduceRight(collection, callback, accumulator, thisArg) { - var noaccum = arguments.length < 3; - callback = lodash.createCallback(callback, thisArg, 4); - forEachRight(collection, function(value, index, collection) { - accumulator = noaccum - ? (noaccum = false, value) - : callback(accumulator, value, index, collection); - }); - return accumulator; + * var object = { 'a': [{ 'b': { 'c': 7 } }] }; + * _.unset(object, 'a[0].b.c'); + * // => true + * + * console.log(object); + * // => { 'a': [{ 'b': {} }] }; + * + * _.unset(object, ['a', '0', 'b', 'c']); + * // => true + * + * console.log(object); + * // => { 'a': [{ 'b': {} }] }; + */ + function unset(object, path) { + return object == null ? true : baseUnset(object, path); } /** - * 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 provided for `callback` the created "_.pluck" style - * callback will return the property value of the given element. + * This method is like `_.set` except that accepts `updater` to produce the + * value to set. Use `_.updateWith` to customize `path` creation. The `updater` + * is invoked with one argument: (value). * - * If an object is provided for `callback` the created "_.where" style callback - * will return `true` for elements that have the properties of the given object, - * else `false`. + * **Note:** This method mutates `object`. * * @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 {Array} Returns a new array of elements that failed the callback check. + * @since 4.6.0 + * @category Object + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to set. + * @param {Function} updater The function to produce the updated value. + * @returns {Object} Returns `object`. * @example * - * var odds = _.reject([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; }); - * // => [1, 3, 5] - * - * var characters = [ - * { 'name': 'barney', 'age': 36, 'blocked': false }, - * { 'name': 'fred', 'age': 40, 'blocked': true } - * ]; + * var object = { 'a': [{ 'b': { 'c': 3 } }] }; * - * // using "_.pluck" callback shorthand - * _.reject(characters, 'blocked'); - * // => [{ 'name': 'barney', 'age': 36, 'blocked': false }] + * _.update(object, 'a[0].b.c', function(n) { return n * n; }); + * console.log(object.a[0].b.c); + * // => 9 * - * // using "_.where" callback shorthand - * _.reject(characters, { 'age': 36 }); - * // => [{ 'name': 'fred', 'age': 40, 'blocked': true }] + * _.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; }); + * console.log(object.x[0].y.z); + * // => 0 */ - function reject(collection, callback, thisArg) { - callback = lodash.createCallback(callback, thisArg, 3); - return filter(collection, function(value, index, collection) { - return !callback(value, index, collection); - }); + function update(object, path, updater) { + return object == null ? object : baseUpdate(object, path, castFunction(updater)); } /** - * Retrieves a random element or `n` random elements from a collection. + * This method is like `_.update` except that it accepts `customizer` which is + * invoked to produce the objects of `path`. If `customizer` returns `undefined` + * path creation is handled by the method instead. The `customizer` is invoked + * with three arguments: (nsValue, key, nsObject). + * + * **Note:** This method mutates `object`. * * @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 `index` arguments as `n`. - * @returns {Array} Returns the random sample(s) of `collection`. + * @since 4.6.0 + * @category Object + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to set. + * @param {Function} updater The function to produce the updated value. + * @param {Function} [customizer] The function to customize assigned values. + * @returns {Object} Returns `object`. * @example * - * _.sample([1, 2, 3, 4]); - * // => 2 + * var object = {}; * - * _.sample([1, 2, 3, 4], 2); - * // => [3, 1] + * _.updateWith(object, '[0][1]', _.constant('a'), Object); + * // => { '0': { '1': 'a' } } */ - function sample(collection, n, guard) { - if (collection && typeof collection.length != 'number') { - collection = values(collection); - } else if (support.unindexedChars && isString(collection)) { - collection = collection.split(''); - } - if (n == null || guard) { - return collection ? collection[baseRandom(0, collection.length - 1)] : undefined; - } - var result = shuffle(collection); - result.length = nativeMin(nativeMax(0, n), result.length); - return result; + function updateWith(object, path, updater, customizer) { + customizer = typeof customizer == 'function' ? customizer : undefined; + return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer); } /** - * Creates an array of shuffled values, using a version of the Fisher-Yates - * shuffle. See http://en.wikipedia.org/wiki/Fisher-Yates_shuffle. + * Creates an array of the own enumerable string keyed property values of `object`. + * + * **Note:** Non-object values are coerced to objects. * * @static + * @since 0.1.0 * @memberOf _ - * @category Collections - * @param {Array|Object|string} collection The collection to shuffle. - * @returns {Array} Returns a new shuffled collection. + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property values. * @example * - * _.shuffle([1, 2, 3, 4, 5, 6]); - * // => [4, 1, 6, 3, 5, 2] + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.values(new Foo); + * // => [1, 2] (iteration order is not guaranteed) + * + * _.values('hi'); + * // => ['h', 'i'] */ - function shuffle(collection) { - var index = -1, - length = collection ? collection.length : 0, - result = Array(typeof length == 'number' ? length : 0); - - forEach(collection, function(value) { - var rand = baseRandom(0, ++index); - result[index] = result[rand]; - result[rand] = value; - }); - return result; + function values(object) { + return object == null ? [] : baseValues(object, keys(object)); } /** - * Gets the size of the `collection` by returning `collection.length` for arrays - * and array-like objects or the number of own enumerable properties for objects. + * Creates an array of the own and inherited enumerable string keyed property + * values of `object`. + * + * **Note:** Non-object values are coerced to objects. * * @static * @memberOf _ - * @category Collections - * @param {Array|Object|string} collection The collection to inspect. - * @returns {number} Returns `collection.length` or number of own enumerable properties. + * @since 3.0.0 + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property values. * @example * - * _.size([1, 2]); - * // => 2 + * function Foo() { + * this.a = 1; + * this.b = 2; + * } * - * _.size({ 'one': 1, 'two': 2, 'three': 3 }); - * // => 3 + * Foo.prototype.c = 3; * - * _.size('pebbles'); - * // => 7 + * _.valuesIn(new Foo); + * // => [1, 2, 3] (iteration order is not guaranteed) */ - function size(collection) { - var length = collection ? collection.length : 0; - return typeof length == 'number' ? length : keys(collection).length; + function valuesIn(object) { + return object == null ? [] : baseValues(object, keysIn(object)); } + /*------------------------------------------------------------------------*/ + /** - * 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). + * Clamps `number` within the inclusive `lower` and `upper` bounds. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Number + * @param {number} number The number to clamp. + * @param {number} [lower] The lower bound. + * @param {number} upper The upper bound. + * @returns {number} Returns the clamped number. + * @example * - * If a property name is provided for `callback` the created "_.pluck" style - * callback will return the property value of the given element. + * _.clamp(-10, -5, 5); + * // => -5 * - * 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`. + * _.clamp(10, -5, 5); + * // => 5 + */ + function clamp(number, lower, upper) { + if (upper === undefined) { + upper = lower; + lower = undefined; + } + if (upper !== undefined) { + upper = toNumber(upper); + upper = upper === upper ? upper : 0; + } + if (lower !== undefined) { + lower = toNumber(lower); + lower = lower === lower ? lower : 0; + } + return baseClamp(toNumber(number), lower, upper); + } + + /** + * Checks if `n` is between `start` and up to, but not including, `end`. If + * `end` is not specified, it's set to `start` with `start` then set to `0`. + * If `start` is greater than `end` the params are swapped to support + * negative ranges. * * @static * @memberOf _ - * @alias any - * @category Collections - * @param {Array|Object|string} collection The collection to iterate over. - * @param {Function|Object|string} [callback=identity] The function called - * per iteration. If a property name or object is provided it will be used - * to create a "_.pluck" or "_.where" style callback, respectively. - * @param {*} [thisArg] The `this` binding of `callback`. - * @returns {boolean} Returns `true` if any element passed the callback check, - * else `false`. + * @since 3.3.0 + * @category Number + * @param {number} number The number to check. + * @param {number} [start=0] The start of the range. + * @param {number} end The end of the range. + * @returns {boolean} Returns `true` if `number` is in the range, else `false`. + * @see _.range, _.rangeRight * @example * - * _.some([null, 0, 'yes', false], Boolean); + * _.inRange(3, 2, 4); * // => true * - * var characters = [ - * { 'name': 'barney', 'age': 36, 'blocked': false }, - * { 'name': 'fred', 'age': 40, 'blocked': true } - * ]; + * _.inRange(4, 8); + * // => true + * + * _.inRange(4, 2); + * // => false + * + * _.inRange(2, 2); + * // => false * - * // using "_.pluck" callback shorthand - * _.some(characters, 'blocked'); + * _.inRange(1.2, 2); * // => true * - * // using "_.where" callback shorthand - * _.some(characters, { 'age': 1 }); + * _.inRange(5.2, 4); * // => false + * + * _.inRange(-3, -2, -6); + * // => true */ - function some(collection, callback, thisArg) { - var result; - callback = lodash.createCallback(callback, thisArg, 3); - - if (isArray(collection)) { - var index = -1, - length = collection.length; - - while (++index < length) { - if ((result = callback(collection[index], index, collection))) { - break; - } - } + function inRange(number, start, end) { + start = toFinite(start); + if (end === undefined) { + end = start; + start = 0; } else { - baseEach(collection, function(value, index, collection) { - return !(result = callback(value, index, collection)); - }); + end = toFinite(end); } - return !!result; + number = toNumber(number); + return baseInRange(number, start, end); } /** - * Creates an array of elements, sorted in ascending order by the results of - * running each element in a collection through the callback. This method - * performs a stable sort, that is, it will preserve the original sort order - * of equal elements. The callback is bound to `thisArg` and invoked with - * three arguments; (value, index|key, collection). + * Produces a random number between the inclusive `lower` and `upper` bounds. + * If only one argument is provided a number between `0` and the given number + * is returned. If `floating` is `true`, or either `lower` or `upper` are + * floats, a floating-point number is returned instead of an integer. * - * If a property name is provided for `callback` the created "_.pluck" style - * callback will return the property value of the given element. - * - * If an array of property names is provided for `callback` the collection - * will be sorted by each property value. - * - * If an object is provided for `callback` the created "_.where" style callback - * will return `true` for elements that have the properties of the given object, - * else `false`. + * **Note:** JavaScript follows the IEEE-754 standard for resolving + * floating-point values which can produce unexpected results. * * @static * @memberOf _ - * @category Collections - * @param {Array|Object|string} collection The collection to iterate over. - * @param {Array|Function|Object|string} [callback=identity] The function called - * per iteration. If a property name or object is provided it will be used - * to create a "_.pluck" or "_.where" style callback, respectively. - * @param {*} [thisArg] The `this` binding of `callback`. - * @returns {Array} Returns a new array of sorted elements. + * @since 0.7.0 + * @category Number + * @param {number} [lower=0] The lower bound. + * @param {number} [upper=1] The upper bound. + * @param {boolean} [floating] Specify returning a floating-point number. + * @returns {number} Returns the random number. * @example * - * _.sortBy([1, 2, 3], function(num) { return Math.sin(num); }); - * // => [3, 1, 2] - * - * _.sortBy([1, 2, 3], function(num) { return this.sin(num); }, Math); - * // => [3, 1, 2] + * _.random(0, 5); + * // => an integer between 0 and 5 * - * var characters = [ - * { 'name': 'barney', 'age': 36 }, - * { 'name': 'fred', 'age': 40 }, - * { 'name': 'barney', 'age': 26 }, - * { 'name': 'fred', 'age': 30 } - * ]; + * _.random(5); + * // => also an integer between 0 and 5 * - * // using "_.pluck" callback shorthand - * _.map(_.sortBy(characters, 'age'), _.values); - * // => [['barney', 26], ['fred', 30], ['barney', 36], ['fred', 40]] + * _.random(5, true); + * // => a floating-point number between 0 and 5 * - * // sorting by multiple properties - * _.map(_.sortBy(characters, ['name', 'age']), _.values); - * // = > [['barney', 26], ['barney', 36], ['fred', 30], ['fred', 40]] + * _.random(1.2, 5.2); + * // => a floating-point number between 1.2 and 5.2 */ - function sortBy(collection, callback, thisArg) { - var index = -1, - isArr = isArray(callback), - length = collection ? collection.length : 0, - result = Array(typeof length == 'number' ? length : 0); - - if (!isArr) { - callback = lodash.createCallback(callback, thisArg, 3); + function random(lower, upper, floating) { + if (floating && typeof floating != 'boolean' && isIterateeCall(lower, upper, floating)) { + upper = floating = undefined; } - forEach(collection, function(value, key, collection) { - var object = result[++index] = getObject(); - if (isArr) { - object.criteria = map(callback, function(key) { return value[key]; }); - } else { - (object.criteria = getArray())[0] = callback(value, key, collection); + if (floating === undefined) { + if (typeof upper == 'boolean') { + floating = upper; + upper = undefined; } - object.index = index; - object.value = value; - }); - - length = result.length; - result.sort(compareAscending); - while (length--) { - var object = result[length]; - result[length] = object.value; - if (!isArr) { - releaseArray(object.criteria); + else if (typeof lower == 'boolean') { + floating = lower; + lower = undefined; } - releaseObject(object); } - return result; - } - - /** - * Converts the `collection` to an array. - * - * @static - * @memberOf _ - * @category Collections - * @param {Array|Object|string} collection The collection to convert. - * @returns {Array} Returns the new converted array. - * @example - * - * (function() { return _.toArray(arguments).slice(1); })(1, 2, 3, 4); - * // => [2, 3, 4] - */ - function toArray(collection) { - if (collection && typeof collection.length == 'number') { - return (support.unindexedChars && isString(collection)) - ? collection.split('') - : slice(collection); + if (lower === undefined && upper === undefined) { + lower = 0; + upper = 1; + } + else { + lower = toFinite(lower); + if (upper === undefined) { + upper = lower; + lower = 0; + } else { + upper = toFinite(upper); + } } - return values(collection); + if (lower > upper) { + var temp = lower; + lower = upper; + upper = temp; + } + if (floating || lower % 1 || upper % 1) { + var rand = nativeRandom(); + return nativeMin(lower + (rand * (upper - lower + freeParseFloat('1e-' + ((rand + '').length - 1)))), upper); + } + return baseRandom(lower, upper); } + /*------------------------------------------------------------------------*/ + /** - * 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. + * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase). * * @static * @memberOf _ - * @type Function - * @category Collections - * @param {Array|Object|string} collection The collection to iterate over. - * @param {Object} props The object of property values to filter by. - * @returns {Array} Returns a new array of elements that have the given properties. + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the camel cased string. * @example * - * var characters = [ - * { 'name': 'barney', 'age': 36, 'pets': ['hoppy'] }, - * { 'name': 'fred', 'age': 40, 'pets': ['baby puss', 'dino'] } - * ]; + * _.camelCase('Foo Bar'); + * // => 'fooBar' * - * _.where(characters, { 'age': 36 }); - * // => [{ 'name': 'barney', 'age': 36, 'pets': ['hoppy'] }] + * _.camelCase('--foo-bar--'); + * // => 'fooBar' * - * _.where(characters, { 'pets': ['dino'] }); - * // => [{ 'name': 'fred', 'age': 40, 'pets': ['baby puss', 'dino'] }] + * _.camelCase('__FOO_BAR__'); + * // => 'fooBar' */ - var where = filter; - - /*--------------------------------------------------------------------------*/ + var camelCase = createCompounder(function(result, word, index) { + word = word.toLowerCase(); + return result + (index ? capitalize(word) : word); + }); /** - * Creates an array with all falsey values removed. The values `false`, `null`, - * `0`, `""`, `undefined`, and `NaN` are all falsey. + * Converts the first character of `string` to upper case and the remaining + * to lower case. * * @static * @memberOf _ - * @category Arrays - * @param {Array} array The array to compact. - * @returns {Array} Returns a new array of filtered values. + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to capitalize. + * @returns {string} Returns the capitalized string. * @example * - * _.compact([0, 1, false, 2, '', 3]); - * // => [1, 2, 3] + * _.capitalize('FRED'); + * // => 'Fred' */ - function compact(array) { - var index = -1, - length = array ? array.length : 0, - result = []; - - while (++index < length) { - var value = array[index]; - if (value) { - result.push(value); - } - } - return result; + function capitalize(string) { + return upperFirst(toString(string).toLowerCase()); } /** - * Creates an array excluding all values of the provided arrays using strict - * equality for comparisons, i.e. `===`. + * Deburrs `string` by converting + * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table) + * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A) + * letters to basic Latin letters and removing + * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks). * * @static * @memberOf _ - * @category Arrays - * @param {Array} array The array to process. - * @param {...Array} [values] The arrays of values to exclude. - * @returns {Array} Returns a new array of filtered values. + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to deburr. + * @returns {string} Returns the deburred string. * @example * - * _.difference([1, 2, 3, 4, 5], [5, 2, 10]); - * // => [1, 3, 4] + * _.deburr('déjà vu'); + * // => 'deja vu' */ - function difference(array) { - return baseDifference(array, baseFlatten(arguments, true, true, 1)); + function deburr(string) { + string = toString(string); + return string && string.replace(reLatin, deburrLetter).replace(reComboMark, ''); } /** - * 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. - * - * 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`. + * Checks if `string` ends with the given target string. * * @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`. + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to inspect. + * @param {string} [target] The string to search for. + * @param {number} [position=string.length] The position to search up to. + * @returns {boolean} Returns `true` if `string` ends with `target`, + * else `false`. * @example * - * var characters = [ - * { 'name': 'barney', 'age': 36, 'blocked': false }, - * { 'name': 'fred', 'age': 40, 'blocked': true }, - * { 'name': 'pebbles', 'age': 1, 'blocked': false } - * ]; - * - * _.findIndex(characters, function(chr) { - * return chr.age < 20; - * }); - * // => 2 + * _.endsWith('abc', 'c'); + * // => true * - * // using "_.where" callback shorthand - * _.findIndex(characters, { 'age': 36 }); - * // => 0 + * _.endsWith('abc', 'b'); + * // => false * - * // using "_.pluck" callback shorthand - * _.findIndex(characters, 'blocked'); - * // => 1 + * _.endsWith('abc', 'b', 2); + * // => true */ - function findIndex(array, callback, thisArg) { - var index = -1, - length = array ? array.length : 0; - - callback = lodash.createCallback(callback, thisArg, 3); - while (++index < length) { - if (callback(array[index], index, array)) { - return index; - } - } - return -1; + function endsWith(string, target, position) { + string = toString(string); + target = baseToString(target); + + var length = string.length; + position = position === undefined + ? length + : baseClamp(toInteger(position), 0, length); + + var end = position; + position -= target.length; + return position >= 0 && string.slice(position, end) == target; } /** - * This method is like `_.findIndex` except that it iterates over elements - * of a `collection` from right to left. - * - * 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 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 - * - * var characters = [ - * { 'name': 'barney', 'age': 36, 'blocked': true }, - * { 'name': 'fred', 'age': 40, 'blocked': false }, - * { 'name': 'pebbles', 'age': 1, 'blocked': true } - * ]; - * - * _.findLastIndex(characters, function(chr) { - * return chr.age > 30; - * }); - * // => 1 - * - * // using "_.where" callback shorthand - * _.findLastIndex(characters, { 'age': 36 }); - * // => 0 + * Converts the characters "&", "<", ">", '"', and "'" in `string` to their + * corresponding HTML entities. * - * // using "_.pluck" callback shorthand - * _.findLastIndex(characters, 'blocked'); - * // => 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). + * **Note:** No other characters are escaped. To escape additional + * characters use a third-party library like [_he_](https://mths.be/he). * - * If a property name is provided for `callback` the created "_.pluck" style - * callback will return the property value of the given element. + * Though the ">" character is escaped for symmetry, characters like + * ">" and "/" don't need escaping in HTML and have no special meaning + * unless they're part of a tag or unquoted attribute value. See + * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands) + * (under "semi-related fun fact") for more details. * - * 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`. + * When working with HTML you should always + * [quote attribute values](http://wonko.com/post/html-escaping) to reduce + * XSS vectors. * * @static + * @since 0.1.0 * @memberOf _ - * @alias head, take - * @category Arrays - * @param {Array} array The array to query. - * @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 provided it will be used to create a "_.pluck" or "_.where" - * style callback, respectively. - * @param {*} [thisArg] The `this` binding of `callback`. - * @returns {*} Returns the first element(s) of `array`. + * @category String + * @param {string} [string=''] The string to escape. + * @returns {string} Returns the escaped string. * @example * - * _.first([1, 2, 3]); - * // => 1 - * - * _.first([1, 2, 3], 2); - * // => [1, 2] - * - * _.first([1, 2, 3], function(num) { - * return num < 3; - * }); - * // => [1, 2] - * - * var characters = [ - * { 'name': 'barney', 'blocked': true, 'employer': 'slate' }, - * { 'name': 'fred', 'blocked': false, 'employer': 'slate' }, - * { 'name': 'pebbles', 'blocked': true, 'employer': 'na' } - * ]; - * - * // using "_.pluck" callback shorthand - * _.first(characters, 'blocked'); - * // => [{ 'name': 'barney', 'blocked': true, 'employer': 'slate' }] - * - * // using "_.where" callback shorthand - * _.pluck(_.first(characters, { 'employer': 'slate' }), 'name'); - * // => ['barney', 'fred'] + * _.escape('fred, barney, & pebbles'); + * // => 'fred, barney, & pebbles' */ - function first(array, callback, thisArg) { - var n = 0, - length = array ? array.length : 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)); + function escape(string) { + string = toString(string); + return (string && reHasUnescapedHtml.test(string)) + ? string.replace(reUnescapedHtml, escapeHtmlChar) + : string; } /** - * Flattens a nested array (the nesting can be to any depth). If `isShallow` - * 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 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`. + * Escapes the `RegExp` special characters "^", "$", "\", ".", "*", "+", + * "?", "(", ")", "[", "]", "{", "}", and "|" in `string`. * * @static * @memberOf _ - * @category Arrays - * @param {Array} array The array to flatten. - * @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. + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to escape. + * @returns {string} Returns the escaped string. * @example * - * _.flatten([1, [2], [3, [[4]]]]); - * // => [1, 2, 3, 4]; - * - * _.flatten([1, [2], [3, [[4]]]], true); - * // => [1, 2, 3, [[4]]]; - * - * var characters = [ - * { 'name': 'barney', 'age': 30, 'pets': ['hoppy'] }, - * { 'name': 'fred', 'age': 40, 'pets': ['baby puss', 'dino'] } - * ]; - * - * // using "_.pluck" callback shorthand - * _.flatten(characters, 'pets'); - * // => ['hoppy', 'baby puss', 'dino'] + * _.escapeRegExp('[lodash](https://lodash.com/)'); + * // => '\[lodash\]$https://lodash\.com/$' */ - function flatten(array, isShallow, callback, thisArg) { - // juggle arguments - if (typeof isShallow != 'boolean' && isShallow != null) { - thisArg = callback; - callback = (typeof isShallow != 'function' && thisArg && thisArg[isShallow] === array) ? null : isShallow; - isShallow = false; - } - if (callback != null) { - array = map(array, callback, thisArg); - } - return baseFlatten(array, isShallow); + function escapeRegExp(string) { + string = toString(string); + return (string && reHasRegExpChar.test(string)) + ? string.replace(reRegExpChar, '\\$&') + : string; } /** - * 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 - * providing `true` for `fromIndex` will run a faster binary search. + * Converts `string` to + * [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles). * * @static * @memberOf _ - * @category Arrays - * @param {Array} array The array to search. - * @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`. + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the kebab cased string. * @example * - * _.indexOf([1, 2, 3, 1, 2, 3], 2); - * // => 1 + * _.kebabCase('Foo Bar'); + * // => 'foo-bar' * - * _.indexOf([1, 2, 3, 1, 2, 3], 2, 3); - * // => 4 + * _.kebabCase('fooBar'); + * // => 'foo-bar' * - * _.indexOf([1, 1, 2, 2, 3, 3], 2, true); - * // => 2 + * _.kebabCase('__FOO_BAR__'); + * // => 'foo-bar' */ - function indexOf(array, value, fromIndex) { - if (typeof fromIndex == 'number') { - var length = array ? array.length : 0; - fromIndex = (fromIndex < 0 ? nativeMax(0, length + fromIndex) : fromIndex || 0); - } else if (fromIndex) { - var index = sortedIndex(array, value); - return array[index] === value ? index : -1; - } - return baseIndexOf(array, value, fromIndex); - } + var kebabCase = createCompounder(function(result, word, index) { + return result + (index ? '-' : '') + word.toLowerCase(); + }); /** - * 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 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`. + * Converts `string`, as space separated words, to lower case. * * @static * @memberOf _ - * @category Arrays - * @param {Array} array The array to query. - * @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 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 slice of `array`. + * @since 4.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the lower cased string. * @example * - * _.initial([1, 2, 3]); - * // => [1, 2] - * - * _.initial([1, 2, 3], 2); - * // => [1] - * - * _.initial([1, 2, 3], function(num) { - * return num > 1; - * }); - * // => [1] - * - * var characters = [ - * { 'name': 'barney', 'blocked': false, 'employer': 'slate' }, - * { 'name': 'fred', 'blocked': true, 'employer': 'slate' }, - * { 'name': 'pebbles', 'blocked': true, 'employer': 'na' } - * ]; + * _.lowerCase('--Foo-Bar--'); + * // => 'foo bar' * - * // using "_.pluck" callback shorthand - * _.initial(characters, 'blocked'); - * // => [{ 'name': 'barney', 'blocked': false, 'employer': 'slate' }] + * _.lowerCase('fooBar'); + * // => 'foo bar' * - * // using "_.where" callback shorthand - * _.pluck(_.initial(characters, { 'employer': 'na' }), 'name'); - * // => ['barney', 'fred'] + * _.lowerCase('__FOO_BAR__'); + * // => 'foo bar' */ - function initial(array, callback, thisArg) { - var n = 0, - length = array ? array.length : 0; - - 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 == null || thisArg) ? 1 : callback || n; - } - return slice(array, 0, nativeMin(nativeMax(0, length - n), length)); - } + var lowerCase = createCompounder(function(result, word, index) { + return result + (index ? ' ' : '') + word.toLowerCase(); + }); /** - * Creates an array of unique values present in all provided arrays using - * strict equality for comparisons, i.e. `===`. + * Converts the first character of `string` to lower case. * * @static * @memberOf _ - * @category Arrays - * @param {...Array} [array] The arrays to inspect. - * @returns {Array} Returns an array of shared values. + * @since 4.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the converted string. * @example * - * _.intersection([1, 2, 3], [5, 2, 1, 4], [2, 1]); - * // => [1, 2] + * _.lowerFirst('Fred'); + * // => 'fred' + * + * _.lowerFirst('FRED'); + * // => 'fRED' */ - function intersection() { - var args = [], - argsIndex = -1, - argsLength = arguments.length, - caches = getArray(), - indexOf = getIndexOf(), - trustIndexOf = indexOf === baseIndexOf, - seen = getArray(); - - while (++argsIndex < argsLength) { - var value = arguments[argsIndex]; - if (isArray(value) || isArguments(value)) { - args.push(value); - caches.push(trustIndexOf && value.length >= largeArraySize && - createCache(argsIndex ? args[argsIndex] : seen)); - } - } - var array = args[0], - index = -1, - length = array ? array.length : 0, - result = []; + var lowerFirst = createCaseFirst('toLowerCase'); - outer: - while (++index < length) { - var cache = caches[0]; - value = array[index]; - - if ((cache ? cacheIndexOf(cache, value) : indexOf(seen, value)) < 0) { - argsIndex = argsLength; - (cache || seen).push(value); - while (--argsIndex) { - cache = caches[argsIndex]; - if ((cache ? cacheIndexOf(cache, value) : indexOf(args[argsIndex], value)) < 0) { - continue outer; - } - } - result.push(value); - } - } - while (argsLength--) { - cache = caches[argsLength]; - if (cache) { - releaseObject(cache); - } - } - releaseArray(caches); - releaseArray(seen); - return result; - } - - /** - * 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 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`. + /** + * Pads `string` on the left and right sides if it's shorter than `length`. + * Padding characters are truncated if they can't be evenly divided by `length`. * * @static * @memberOf _ - * @category Arrays - * @param {Array} array The array to query. - * @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 provided it will be used to create a "_.pluck" or "_.where" - * style callback, respectively. - * @param {*} [thisArg] The `this` binding of `callback`. - * @returns {*} Returns the last element(s) of `array`. + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to pad. + * @param {number} [length=0] The padding length. + * @param {string} [chars=' '] The string used as padding. + * @returns {string} Returns the padded string. * @example * - * _.last([1, 2, 3]); - * // => 3 - * - * _.last([1, 2, 3], 2); - * // => [2, 3] - * - * _.last([1, 2, 3], function(num) { - * return num > 1; - * }); - * // => [2, 3] - * - * var characters = [ - * { 'name': 'barney', 'blocked': false, 'employer': 'slate' }, - * { 'name': 'fred', 'blocked': true, 'employer': 'slate' }, - * { 'name': 'pebbles', 'blocked': true, 'employer': 'na' } - * ]; + * _.pad('abc', 8); + * // => ' abc ' * - * // using "_.pluck" callback shorthand - * _.pluck(_.last(characters, 'blocked'), 'name'); - * // => ['fred', 'pebbles'] + * _.pad('abc', 8, '_-'); + * // => '_-abc_-_' * - * // using "_.where" callback shorthand - * _.last(characters, { 'employer': 'na' }); - * // => [{ 'name': 'pebbles', 'blocked': true, 'employer': 'na' }] + * _.pad('abc', 3); + * // => 'abc' */ - function last(array, callback, thisArg) { - var n = 0, - length = array ? array.length : 0; + function pad(string, length, chars) { + string = toString(string); + length = toInteger(length); - 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; - } + var strLength = length ? stringSize(string) : 0; + if (!length || strLength >= length) { + return string; } - return slice(array, nativeMax(0, length - n)); + var mid = (length - strLength) / 2; + return ( + createPadding(nativeFloor(mid), chars) + + string + + createPadding(nativeCeil(mid), chars) + ); } /** - * Gets the index at which the last occurrence of `value` is found using strict - * equality for comparisons, i.e. `===`. If `fromIndex` is negative, it is used - * as the offset from the end of the 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`. + * Pads `string` on the right side if it's shorter than `length`. Padding + * characters are truncated if they exceed `length`. * * @static * @memberOf _ - * @category Arrays - * @param {Array} array The array to search. - * @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`. + * @since 4.0.0 + * @category String + * @param {string} [string=''] The string to pad. + * @param {number} [length=0] The padding length. + * @param {string} [chars=' '] The string used as padding. + * @returns {string} Returns the padded string. * @example * - * _.lastIndexOf([1, 2, 3, 1, 2, 3], 2); - * // => 4 + * _.padEnd('abc', 6); + * // => 'abc ' * - * _.lastIndexOf([1, 2, 3, 1, 2, 3], 2, 3); - * // => 1 + * _.padEnd('abc', 6, '_-'); + * // => 'abc_-_' + * + * _.padEnd('abc', 3); + * // => 'abc' */ - function lastIndexOf(array, value, fromIndex) { - var index = array ? array.length : 0; - if (typeof fromIndex == 'number') { - index = (fromIndex < 0 ? nativeMax(0, index + fromIndex) : nativeMin(fromIndex, index - 1)) + 1; - } - while (index--) { - if (array[index] === value) { - return index; - } - } - return -1; + function padEnd(string, length, chars) { + string = toString(string); + length = toInteger(length); + + var strLength = length ? stringSize(string) : 0; + return (length && strLength < length) + ? (string + createPadding(length - strLength, chars)) + : string; } /** - * Removes all provided values from the given array using strict equality for - * comparisons, i.e. `===`. + * Pads `string` on the left side if it's shorter than `length`. Padding + * characters are truncated if they exceed `length`. * * @static * @memberOf _ - * @category Arrays - * @param {Array} array The array to modify. - * @param {...*} [value] The values to remove. - * @returns {Array} Returns `array`. + * @since 4.0.0 + * @category String + * @param {string} [string=''] The string to pad. + * @param {number} [length=0] The padding length. + * @param {string} [chars=' '] The string used as padding. + * @returns {string} Returns the padded string. * @example * - * var array = [1, 2, 3, 1, 2, 3]; - * _.pull(array, 2, 3); - * console.log(array); - * // => [1, 1] + * _.padStart('abc', 6); + * // => ' abc' + * + * _.padStart('abc', 6, '_-'); + * // => '_-_abc' + * + * _.padStart('abc', 3); + * // => 'abc' */ - 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; + function padStart(string, length, chars) { + string = toString(string); + length = toInteger(length); + + var strLength = length ? stringSize(string) : 0; + return (length && strLength < length) + ? (createPadding(length - strLength, chars) + string) + : string; } /** - * Creates an array of numbers (positive and/or negative) progressing from - * `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. + * Converts `string` to an integer of the specified radix. If `radix` is + * `undefined` or `0`, a `radix` of `10` is used unless `value` is a + * hexadecimal, in which case a `radix` of `16` is used. + * + * **Note:** This method aligns with the + * [ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`. * * @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. - * @returns {Array} Returns a new range array. + * @since 1.1.0 + * @category String + * @param {string} string The string to convert. + * @param {number} [radix=10] The radix to interpret `value` by. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {number} Returns the converted integer. * @example * - * _.range(4); - * // => [0, 1, 2, 3] + * _.parseInt('08'); + * // => 8 * - * _.range(1, 5); - * // => [1, 2, 3, 4] + * _.map(['6', '08', '10'], _.parseInt); + * // => [6, 8, 10] + */ + function parseInt(string, radix, guard) { + if (guard || radix == null) { + radix = 0; + } else if (radix) { + radix = +radix; + } + return nativeParseInt(toString(string).replace(reTrimStart, ''), radix || 0); + } + + /** + * Repeats the given string `n` times. * - * _.range(0, 20, 5); - * // => [0, 5, 10, 15] + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to repeat. + * @param {number} [n=1] The number of times to repeat the string. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {string} Returns the repeated string. + * @example * - * _.range(0, -4, -1); - * // => [0, -1, -2, -3] + * _.repeat('*', 3); + * // => '***' * - * _.range(1, 4, 0); - * // => [1, 1, 1] + * _.repeat('abc', 2); + * // => 'abcabc' * - * _.range(0); - * // => [] + * _.repeat('abc', 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; + function repeat(string, n, guard) { + if ((guard ? isIterateeCall(string, n, guard) : n === undefined)) { + n = 1; + } else { + n = toInteger(n); } - return result; + return baseRepeat(toString(string), n); } /** - * 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. + * Replaces matches for `pattern` in `string` with `replacement`. * - * 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`. + * **Note:** This method is based on + * [`String#replace`](https://mdn.io/String/replace). * * @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. + * @since 4.0.0 + * @category String + * @param {string} [string=''] The string to modify. + * @param {RegExp|string} pattern The pattern to replace. + * @param {Function|string} replacement The match replacement. + * @returns {string} Returns the modified string. * @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] - * - * console.log(evens); - * // => [2, 4, 6] + * _.replace('Hi Fred', 'Fred', 'Barney'); + * // => 'Hi Barney' */ - function remove(array, callback, thisArg) { - var index = -1, - length = array ? array.length : 0, - result = []; + function replace() { + var args = arguments, + string = toString(args[0]); - callback = lodash.createCallback(callback, thisArg, 3); - while (++index < length) { - var value = array[index]; - if (callback(value, index, array)) { - result.push(value); - splice.call(array, index--, 1); - length--; - } - } - return result; + return args.length < 3 ? string : string.replace(args[1], args[2]); } /** - * 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 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`. + * Converts `string` to + * [snake case](https://en.wikipedia.org/wiki/Snake_case). * * @static * @memberOf _ - * @alias drop, tail - * @category Arrays - * @param {Array} array The array to query. - * @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 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 slice of `array`. + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the snake cased string. * @example * - * _.rest([1, 2, 3]); - * // => [2, 3] + * _.snakeCase('Foo Bar'); + * // => 'foo_bar' * - * _.rest([1, 2, 3], 2); - * // => [3] + * _.snakeCase('fooBar'); + * // => 'foo_bar' * - * _.rest([1, 2, 3], function(num) { - * return num < 3; - * }); - * // => [3] + * _.snakeCase('--FOO-BAR--'); + * // => 'foo_bar' + */ + var snakeCase = createCompounder(function(result, word, index) { + return result + (index ? '_' : '') + word.toLowerCase(); + }); + + /** + * Splits `string` by `separator`. * - * var characters = [ - * { 'name': 'barney', 'blocked': true, 'employer': 'slate' }, - * { 'name': 'fred', 'blocked': false, 'employer': 'slate' }, - * { 'name': 'pebbles', 'blocked': true, 'employer': 'na' } - * ]; + * **Note:** This method is based on + * [`String#split`](https://mdn.io/String/split). * - * // using "_.pluck" callback shorthand - * _.pluck(_.rest(characters, 'blocked'), 'name'); - * // => ['fred', 'pebbles'] + * @static + * @memberOf _ + * @since 4.0.0 + * @category String + * @param {string} [string=''] The string to split. + * @param {RegExp|string} separator The separator pattern to split by. + * @param {number} [limit] The length to truncate results to. + * @returns {Array} Returns the string segments. + * @example * - * // using "_.where" callback shorthand - * _.rest(characters, { 'employer': 'slate' }); - * // => [{ 'name': 'pebbles', 'blocked': true, 'employer': 'na' }] + * _.split('a-b-c', '-', 2); + * // => ['a', 'b'] */ - function rest(array, callback, thisArg) { - if (typeof callback != 'number' && callback != null) { - var n = 0, - index = -1, - length = array ? array.length : 0; - - callback = lodash.createCallback(callback, thisArg, 3); - while (++index < length && callback(array[index], index, array)) { - n++; + function split(string, separator, limit) { + if (limit && typeof limit != 'number' && isIterateeCall(string, separator, limit)) { + separator = limit = undefined; + } + limit = limit === undefined ? MAX_ARRAY_LENGTH : limit >>> 0; + if (!limit) { + return []; + } + string = toString(string); + if (string && ( + typeof separator == 'string' || + (separator != null && !isRegExp(separator)) + )) { + separator = baseToString(separator); + if (!separator && hasUnicode(string)) { + return castSlice(stringToArray(string), 0, limit); } - } else { - n = (callback == null || thisArg) ? 1 : nativeMax(0, callback); } - return slice(array, n); + return string.split(separator, limit); } /** - * 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 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`. + * Converts `string` to + * [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage). * * @static * @memberOf _ - * @category Arrays - * @param {Array} array The array to inspect. - * @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`. + * @since 3.1.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the start cased string. * @example * - * _.sortedIndex([20, 30, 50], 40); - * // => 2 - * - * // using "_.pluck" callback shorthand - * _.sortedIndex([{ 'x': 20 }, { 'x': 30 }, { 'x': 50 }], { 'x': 40 }, 'x'); - * // => 2 - * - * var dict = { - * 'wordToNumber': { 'twenty': 20, 'thirty': 30, 'fourty': 40, 'fifty': 50 } - * }; + * _.startCase('--foo-bar--'); + * // => 'Foo Bar' * - * _.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) { - * return dict.wordToNumber[word]; - * }); - * // => 2 + * _.startCase('fooBar'); + * // => 'Foo Bar' * - * _.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) { - * return this.wordToNumber[word]; - * }, dict); - * // => 2 + * _.startCase('__FOO_BAR__'); + * // => 'FOO BAR' */ - function sortedIndex(array, value, callback, thisArg) { - var low = 0, - high = array ? array.length : low; - - // explicitly reference `identity` for better inlining in Firefox - callback = callback ? lodash.createCallback(callback, thisArg, 1) : identity; - value = callback(value); - - while (low < high) { - var mid = (low + high) >>> 1; - (callback(array[mid]) < value) - ? low = mid + 1 - : high = mid; - } - return low; - } + var startCase = createCompounder(function(result, word, index) { + return result + (index ? ' ' : '') + upperFirst(word); + }); /** - * Creates an array of unique values, in order, of the provided arrays using - * strict equality for comparisons, i.e. `===`. + * Checks if `string` starts with the given target string. * * @static * @memberOf _ - * @category Arrays - * @param {...Array} [array] The arrays to inspect. - * @returns {Array} Returns an array of combined values. + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to inspect. + * @param {string} [target] The string to search for. + * @param {number} [position=0] The position to search from. + * @returns {boolean} Returns `true` if `string` starts with `target`, + * else `false`. * @example * - * _.union([1, 2, 3], [5, 2, 1, 4], [2, 1]); - * // => [1, 2, 3, 5, 4] + * _.startsWith('abc', 'a'); + * // => true + * + * _.startsWith('abc', 'b'); + * // => false + * + * _.startsWith('abc', 'b', 1); + * // => true */ - function union() { - return baseUniq(baseFlatten(arguments, true, true)); + function startsWith(string, target, position) { + string = toString(string); + position = position == null + ? 0 + : baseClamp(toInteger(position), 0, string.length); + + target = baseToString(target); + return string.slice(position, position + target.length) == target; } /** - * 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). + * Creates a compiled template function that can interpolate data properties + * in "interpolate" delimiters, HTML-escape interpolated data properties in + * "escape" delimiters, and execute JavaScript in "evaluate" delimiters. Data + * properties may be accessed as free variables in the template. If a setting + * object is given, it takes precedence over `_.templateSettings` values. + * + * **Note:** In the development build `_.template` utilizes + * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl) + * for easier debugging. * - * If a property name is provided for `callback` the created "_.pluck" style - * callback will return the property value of the given element. + * For more information on precompiling templates see + * [lodash's custom builds documentation](https://lodash.com/custom-builds). * - * 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`. + * For more information on Chrome extension sandboxes see + * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval). * * @static + * @since 0.1.0 * @memberOf _ - * @alias unique - * @category Arrays - * @param {Array} array The array to process. - * @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. + * @category String + * @param {string} [string=''] The template string. + * @param {Object} [options={}] The options object. + * @param {RegExp} [options.escape=_.templateSettings.escape] + * The HTML "escape" delimiter. + * @param {RegExp} [options.evaluate=_.templateSettings.evaluate] + * The "evaluate" delimiter. + * @param {Object} [options.imports=_.templateSettings.imports] + * An object to import into the template as free variables. + * @param {RegExp} [options.interpolate=_.templateSettings.interpolate] + * The "interpolate" delimiter. + * @param {string} [options.sourceURL='lodash.templateSources[n]'] + * The sourceURL of the compiled template. + * @param {string} [options.variable='obj'] + * The data object variable name. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Function} Returns the compiled template function. * @example * - * _.uniq([1, 2, 1, 3, 1]); - * // => [1, 2, 3] + * // Use the "interpolate" delimiter to create a compiled template. + * var compiled = _.template('hello <%= user %>!'); + * compiled({ 'user': 'fred' }); + * // => 'hello fred!' * - * _.uniq([1, 1, 2, 2, 3], true); - * // => [1, 2, 3] + * // Use the HTML "escape" delimiter to escape data property values. + * var compiled = _.template('<%- value %>'); + * compiled({ 'value': ' - - - - - - - - - + + + + + + + + + - + window.onload = init; + }()); + + diff --git a/perf/perf.js b/perf/perf.js index 34d84eda2d..3588c7dc3a 100644 --- a/perf/perf.js +++ b/perf/perf.js @@ -1,94 +1,113 @@ -;(function(root) { +;(function() { + 'use strict'; - /** Use a single "load" function */ - var load = typeof require == 'function' ? require : root.load; - - /** The file path of the Lo-Dash file to test */ - var filePath = (function() { - var min = 0; - var result = root.phantom - ? phantom.args - : (root.system - ? (min = 1, system.args) - : (root.process ? (min = 2, process.argv) : (root.arguments || [])) - ); + /** Used to access the Firebug Lite panel (set by `run`). */ + var fbPanel; - var last = result[result.length - 1]; - result = (result.length > min && !/perf(?:\.js)?$/.test(last)) - ? last - : '../lodash.js'; + /** Used as a safe reference for `undefined` in pre ES5 environments. */ + var undefined; - try { - result = require('fs').realpathSync(result); - } catch(e) { } + /** Used as a reference to the global object. */ + var root = typeof global == 'object' && global || this; - return result; - }()); + /** Method and object shortcuts. */ + var phantom = root.phantom, + amd = root.define && define.amd, + argv = root.process && process.argv, + document = !phantom && root.document, + noop = function() {}, + params = root.arguments, + system = root.system; - /** Load Lo-Dash */ - var lodash = root.lodash || (root.lodash = ( - lodash = load(filePath) || root._, - lodash = lodash._ || lodash, - lodash.noConflict() - )); + /** Add `console.log()` support for Rhino and RingoJS. */ + var console = root.console || (root.console = { 'log': root.print }); - /** Load Benchmark.js */ - var Benchmark = root.Benchmark || (root.Benchmark = ( - Benchmark = load('../vendor/benchmark.js/benchmark.js') || root.Benchmark, - Benchmark = Benchmark.Benchmark || Benchmark, - Benchmark.runInContext(lodash.extend({}, root, { '_': lodash })) - )); + /** The file path of the lodash file to test. */ + var filePath = (function() { + var min = 0, + result = []; + + if (phantom) { + result = params = phantom.args; + } else if (system) { + min = 1; + result = params = system.args; + } else if (argv) { + min = 2; + result = params = argv; + } else if (params) { + result = params; + } + var last = result[result.length - 1]; + result = (result.length > min && !/perf(?:\.js)?$/.test(last)) ? last : '../lodash.js'; - /** Load Underscore */ - var _ = root._ || (root._ = ( - _ = load('../vendor/underscore/underscore.js') || root._, - _._ || _ - )); + if (!amd) { + try { + result = require('fs').realpathSync(result); + } catch (e) {} - /** Used to access the Firebug Lite panel (set by `run`) */ - var fbPanel; + try { + result = require.resolve(result); + } catch (e) {} + } + return result; + }()); - /** Used to match path separators */ + /** Used to match path separators. */ var rePathSeparator = /[\/\\]/; - /** Used to detect primitive types */ + /** Used to detect primitive types. */ var rePrimitive = /^(?:boolean|number|string|undefined)$/; - /** Used to match RegExp special characters */ + /** Used to match RegExp special characters. */ var reSpecialChars = /[.*+?^=!:${}()|[\]\/\\]/g; - /** Used to score performance */ - var score = { 'a': [], 'b': [] }; - - /** Used to queue benchmark suites */ - var suites = []; - - /** Used to resolve a value's internal [[Class]] */ - var toString = Object.prototype.toString; - - /** The `ui` object */ + /** The `ui` object. */ var ui = root.ui || (root.ui = { 'buildPath': basename(filePath, '.js'), 'otherPath': 'underscore' }); - /** The Lo-Dash build basename */ + /** The lodash build basename. */ var buildName = root.buildName = basename(ui.buildPath, '.js'); - /** The other library basename */ + /** The other library basename. */ var otherName = root.otherName = (function() { var result = basename(ui.otherPath, '.js'); return result + (result == buildName ? ' (2)' : ''); }()); - /** Detect if in a browser environment */ - var isBrowser = isHostType(root, 'document') && isHostType(root, 'navigator'); + /** Used to score performance. */ + var score = { 'a': [], 'b': [] }; - /** Detect Java environment */ - var isJava = !isBrowser && /Java/.test(toString.call(root.java)); + /** Used to queue benchmark suites. */ + var suites = []; - /** Add `console.log()` support for Narwhal, Rhino, and RingoJS */ - var console = root.console || (root.console = { 'log': root.print }); + /** Use a single "load" function. */ + var load = (typeof require == 'function' && !amd) + ? require + : noop; + + /** Load lodash. */ + var lodash = root.lodash || (root.lodash = ( + lodash = load(filePath) || root._, + lodash = lodash._ || lodash, + (lodash.runInContext ? lodash.runInContext(root) : lodash), + lodash.noConflict() + )); + + /** Load Underscore. */ + var _ = root.underscore || (root.underscore = ( + _ = load('../vendor/underscore/underscore.js') || root._, + _._ || _ + )); + + /** Load Benchmark.js. */ + var Benchmark = root.Benchmark || (root.Benchmark = ( + Benchmark = load('../node_modules/benchmark/benchmark.js') || root.Benchmark, + Benchmark = Benchmark.Benchmark || Benchmark, + Benchmark.runInContext(lodash.extend({}, root, { '_': lodash })) + )); /*--------------------------------------------------------------------------*/ @@ -162,7 +181,7 @@ function log(text) { console.log(text + ''); if (fbPanel) { - // scroll the Firebug Lite panel down + // Scroll the Firebug Lite panel down. fbPanel.scrollTop = fbPanel.scrollHeight; } } @@ -178,7 +197,7 @@ fbPanel.getElementById('fbPanel1'); log('\nSit back and relax, this may take a while.'); - suites[0].run({ 'async': !isJava }); + suites[0].run({ 'async': true }); } /*--------------------------------------------------------------------------*/ @@ -222,16 +241,16 @@ '% faster.' ); } - // add score adjusted for margin of error + // Add score adjusted for margin of error. score.a.push(aHz); score.b.push(bHz); } - // remove current suite from queue + // Remove current suite from queue. suites.shift(); if (suites.length) { - // run next suite - suites[0].run({ 'async': !isJava }); + // Run next suite. + suites[0].run({ 'async': true }); } else { var aMeanHz = getGeometricMean(score.a), @@ -242,7 +261,7 @@ percentFaster = formatNumber(Math.round((xFaster - 1) * 100)), message = 'is ' + percentFaster + '% ' + (xFaster == 1 ? '' : '(' + formatNumber(xFaster.toFixed(2)) + 'x) ') + 'faster than'; - // report results + // Report results. if (aMeanHz >= bMeanHz) { log('\n' + buildName + ' ' + message + ' ' + otherName + '.'); } else { @@ -257,13 +276,12 @@ lodash.extend(Benchmark.options, { 'async': true, 'setup': '\ - var _ = global._,\ + var _ = global.underscore,\ lodash = global.lodash,\ belt = this.name == buildName ? lodash : _;\ \ - var index,\ - date = new Date,\ - limit = 20,\ + var date = new Date,\ + limit = 50,\ regexp = /x/,\ object = {},\ objects = Array(limit),\ @@ -273,17 +291,22 @@ nestedObjects = [{}, [{}], [{}, [[{}]]]],\ twoNumbers = [12, 23];\ \ - for (index = 0; index < limit; index++) {\ + for (var index = 0; index < limit; index++) {\ numbers[index] = index;\ object["key" + index] = index;\ objects[index] = { "num": index };\ }\ + var strNumbers = numbers + "";\ \ + if (typeof assign != "undefined") {\ + var _assign = _.assign || _.extend,\ + lodashAssign = lodash.assign;\ + }\ if (typeof bind != "undefined") {\ var thisArg = { "name": "fred" };\ \ var func = function(greeting, punctuation) {\ - return greeting + " " + this.name + (punctuation || ".");\ + return (greeting || "hi") + " " + this.name + (punctuation || ".");\ };\ \ var _boundNormal = _.bind(func, thisArg),\ @@ -299,7 +322,6 @@ lodashBoundMultiple = lodash.bind(lodashBoundMultiple, { "name": "fred" + index });\ }\ }\ - \ if (typeof bindAll != "undefined") {\ var bindAllCount = -1,\ bindAllObjects = Array(this.count);\ @@ -308,7 +330,7 @@ return /^_/.test(funcName);\ });\ \ - // potentially expensive\n\ + // Potentially expensive.\n\ for (index = 0; index < this.count; index++) {\ bindAllObjects[index] = belt.reduce(funcNames, function(object, funcName) {\ object[funcName] = belt[funcName];\ @@ -317,8 +339,12 @@ }\ }\ if (typeof chaining != "undefined") {\ - var _chaining = _.chain ? _(numbers).chain() : _(numbers),\ - lodashChaining = lodash(numbers);\ + var even = function(v) { return v % 2 == 0; },\ + square = function(v) { return v * v; };\ + \ + var largeArray = belt.range(10000),\ + _chaining = _(largeArray).chain(),\ + lodashChaining = lodash(largeArray).chain();\ }\ if (typeof compact != "undefined") {\ var uncompacted = numbers.slice();\ @@ -326,7 +352,14 @@ uncompacted[6] = null;\ uncompacted[18] = "";\ }\ - \ + if (typeof flowRight != "undefined") {\ + var compAddOne = function(n) { return n + 1; },\ + compAddTwo = function(n) { return n + 2; },\ + compAddThree = function(n) { return n + 3; };\ + \ + var _composed = _.flowRight && _.flowRight(compAddThree, compAddTwo, compAddOne),\ + lodashComposed = lodash.flowRight && lodash.flowRight(compAddThree, compAddTwo, compAddOne);\ + }\ if (typeof countBy != "undefined" || typeof omit != "undefined") {\ var wordToNumber = {\ "one": 1,\ @@ -373,7 +406,10 @@ \ var words = belt.keys(wordToNumber).slice(0, limit);\ }\ - \ + if (typeof flatten != "undefined") {\ + var _flattenDeep = _.flatten([[1]])[0] !== 1,\ + lodashFlattenDeep = lodash.flatten([[1]])[0] !== 1;\ + }\ if (typeof isEqual != "undefined") {\ var objectOfPrimitives = {\ "boolean": true,\ @@ -387,101 +423,50 @@ "string": new String("a")\ };\ \ + var objectOfObjects2 = {\ + "boolean": new Boolean(true),\ + "number": new Number(1),\ + "string": new String("A")\ + };\ + \ var object2 = {},\ + object3 = {},\ objects2 = Array(limit),\ + objects3 = Array(limit),\ numbers2 = Array(limit),\ + numbers3 = Array(limit),\ nestedNumbers2 = [1, [2], [3, [[4]]]],\ - nestedNumbers3 = [1, [2], [5, [[6]]]],\ - simpleObject = { "a": 1 },\ - simpleObject2 = { "a": 2 },\ - simpleObjects = [simpleObject],\ - simpleObjects2 = [simpleObject2],\ - twoNumbers2 = [18, 27];\ + nestedNumbers3 = [1, [2], [3, [[6]]]];\ \ for (index = 0; index < limit; index++) {\ object2["key" + index] = index;\ + object3["key" + index] = index;\ objects2[index] = { "num": index };\ + objects3[index] = { "num": index };\ numbers2[index] = index;\ + numbers3[index] = index;\ }\ + object3["key" + (limit - 1)] = -1;\ + objects3[limit - 1].num = -1;\ + numbers3[limit - 1] = -1;\ }\ - \ - if (typeof multiArrays != "undefined") {\ - var twentyValues = Array(20),\ - twentyValues2 = Array(20),\ - twentyFiveValues = Array(25),\ - twentyFiveValues2 = Array(25),\ - thirtyValues = Array(30),\ - thirtyValues2 = Array(30),\ - fortyValues = Array(40),\ - fortyValues2 = Array(40),\ - fiftyValues = Array(50),\ - fiftyValues2 = Array(50),\ - seventyFiveValues = Array(75),\ - seventyFiveValues2 = Array(75),\ - oneHundredValues = Array(100),\ - oneHundredValues2 = Array(100),\ - twoHundredValues = Array(200),\ - twoHundredValues2 = Array(200),\ - lowerChars = "abcdefghijklmnopqrstuvwxyz".split(""),\ - upperChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("");\ + if (typeof matches != "undefined") {\ + var source = { "num": 9 };\ \ - for (index = 0; index < 200; index++) {\ - if (index < 15) {\ - twentyValues[index] = lowerChars[index];\ - twentyValues2[index] = upperChars[index];\ - }\ - if (index < 20) {\ - twentyValues[index] =\ - twentyValues2[index] = index;\ - \ - twentyFiveValues[index] = lowerChars[index];\ - twentyFiveValues2[index] = upperChars[index];\ - }\ - if (index < 25) {\ - twentyFiveValues[index] =\ - twentyFiveValues2[index] = index;\ - \ - thirtyValues[index] =\ - fortyValues[index] =\ - fiftyValues[index] =\ - seventyFiveValues[index] =\ - oneHundredValues[index] =\ - twoHundredValues[index] = lowerChars[index];\ - \ - thirtyValues2[index] =\ - fortyValues2[index] =\ - fiftyValues2[index] =\ - seventyFiveValues2[index] =\ - oneHundredValues2[index] =\ - twoHundredValues2[index] = upperChars[index];\ - }\ - else {\ - if (index < 30) {\ - thirtyValues[index] =\ - thirtyValues2[index] = index;\ - }\ - if (index < 40) {\ - fortyValues[index] =\ - fortyValues2[index] = index;\ - }\ - if (index < 50) {\ - fiftyValues[index] =\ - fiftyValues2[index] = index;\ - }\ - if (index < 75) {\ - seventyFiveValues[index] =\ - seventyFiveValues2[index] = index;\ - }\ - if (index < 100) {\ - oneHundredValues[index] =\ - oneHundredValues2[index] = index;\ - }\ - twoHundredValues[index] =\ - twoHundredValues2[index] = index;\ - }\ - }\ + var _matcher = (_.matches || _.noop)(source),\ + lodashMatcher = (lodash.matches || lodash.noop)(source);\ + }\ + if (typeof multiArrays != "undefined") {\ + var twentyValues = belt.shuffle(belt.range(20)),\ + fortyValues = belt.shuffle(belt.range(40)),\ + hundredSortedValues = belt.range(100),\ + hundredValues = belt.shuffle(hundredSortedValues),\ + hundredValues2 = belt.shuffle(hundredValues),\ + hundredTwentyValues = belt.shuffle(belt.range(120)),\ + hundredTwentyValues2 = belt.shuffle(hundredTwentyValues),\ + twoHundredValues = belt.shuffle(belt.range(200)),\ + twoHundredValues2 = belt.shuffle(twoHundredValues);\ }\ - \ if (typeof partial != "undefined") {\ var func = function(greeting, punctuation) {\ return greeting + " fred" + (punctuation || ".");\ @@ -490,7 +475,6 @@ var _partial = _.partial(func, "hi"),\ lodashPartial = lodash.partial(func, "hi");\ }\ - \ if (typeof template != "undefined") {\ var tplData = {\ "header1": "Header1",\ @@ -540,11 +524,6 @@ var lodashTpl = lodash.template(tpl),\ lodashTplVerbose = lodash.template(tplVerbose, null, settingsObject);\ }\ - if (typeof where != "undefined") {\ - var _findWhere = _.findWhere || _.find,\ - lodashFindWhere = lodash.findWhere || lodash.find,\ - whereObject = { "num": 9 };\ - }\ if (typeof wrap != "undefined") {\ var add = function(a, b) {\ return a + b;\ @@ -565,60 +544,53 @@ /*--------------------------------------------------------------------------*/ suites.push( - Benchmark.Suite('`_(...)` with a number') - .add(buildName, '\ - lodash(2)' - ) - .add(otherName, '\ - _(2)' - ) + Benchmark.Suite('`_(...).map(...).filter(...).take(...).value()`') + .add(buildName, { + 'fn': 'lodashChaining.map(square).filter(even).take(100).value()', + 'teardown': 'function chaining(){}' + }) + .add(otherName, { + 'fn': '_chaining.map(square).filter(even).take(100).value()', + 'teardown': 'function chaining(){}' + }) ); + /*--------------------------------------------------------------------------*/ + suites.push( - Benchmark.Suite('`_(...)` with an array') - .add(buildName, '\ - lodash(numbers)' - ) - .add(otherName, '\ - _(numbers)' - ) + Benchmark.Suite('`_.assign`') + .add(buildName, { + 'fn': 'lodashAssign({}, { "a": 1, "b": 2, "c": 3 })', + 'teardown': 'function assign(){}' + }) + .add(otherName, { + 'fn': '_assign({}, { "a": 1, "b": 2, "c": 3 })', + 'teardown': 'function assign(){}' + }) ); suites.push( - Benchmark.Suite('`_(...)` with an object') - .add(buildName, '\ - lodash(object)' - ) - .add(otherName, '\ - _(object)' - ) + Benchmark.Suite('`_.assign` with multiple sources') + .add(buildName, { + 'fn': 'lodashAssign({}, { "a": 1, "b": 2 }, { "c": 3, "d": 4 })', + 'teardown': 'function assign(){}' + }) + .add(otherName, { + 'fn': '_assign({}, { "a": 1, "b": 2 }, { "c": 3, "d": 4 })', + 'teardown': 'function assign(){}' + }) ); - // avoid Underscore induced `OutOfMemoryError` in Rhino, Narwhal, and Ringo - if (!isJava) { - suites.push( - Benchmark.Suite('`_(...).tap(...)`') - .add(buildName, { - 'fn': 'lodashChaining.tap(lodash.identity)', - 'teardown': 'function chaining(){}' - }) - .add(otherName, { - 'fn': '_chaining.tap(_.identity)', - 'teardown': 'function chaining(){}' - }) - ); - } - /*--------------------------------------------------------------------------*/ suites.push( - Benchmark.Suite('`_.bind`') + Benchmark.Suite('`_.bind` (slow path)') .add(buildName, { - 'fn': 'lodash.bind(func, { "name": "fred" })', + 'fn': 'lodash.bind(function() { return this.name; }, { "name": "fred" })', 'teardown': 'function bind(){}' }) .add(otherName, { - 'fn': '_.bind(func, { "name": "fred" })', + 'fn': '_.bind(function() { return this.name; }, { "name": "fred" })', 'teardown': 'function bind(){}' }) ); @@ -662,31 +634,29 @@ /*--------------------------------------------------------------------------*/ suites.push( - Benchmark.Suite('`_.bindAll` iterating arguments') + Benchmark.Suite('`_.bindAll`') .add(buildName, { - 'fn': 'lodash.bindAll.apply(lodash, [bindAllObjects[++bindAllCount]].concat(funcNames))', + 'fn': 'lodash.bindAll(bindAllObjects[++bindAllCount], funcNames)', 'teardown': 'function bindAll(){}' }) .add(otherName, { - 'fn': '_.bindAll.apply(_, [bindAllObjects[++bindAllCount]].concat(funcNames))', + 'fn': '_.bindAll(bindAllObjects[++bindAllCount], funcNames)', 'teardown': 'function bindAll(){}' }) ); + /*--------------------------------------------------------------------------*/ + suites.push( - Benchmark.Suite('`_.bindAll` iterating the `object`') - .add(buildName, { - 'fn': 'lodash.bindAll(bindAllObjects[++bindAllCount])', - 'teardown': 'function bindAll(){}' - }) - .add(otherName, { - 'fn': '_.bindAll(bindAllObjects[++bindAllCount])', - 'teardown': 'function bindAll(){}' - }) + Benchmark.Suite('`_.clone` with an array') + .add(buildName, '\ + lodash.clone(numbers)' + ) + .add(otherName, '\ + _.clone(numbers)' + ) ); - /*--------------------------------------------------------------------------*/ - suites.push( Benchmark.Suite('`_.clone` with an object') .add(buildName, '\ @@ -713,28 +683,6 @@ /*--------------------------------------------------------------------------*/ - suites.push( - Benchmark.Suite('`_.contains` iterating an array') - .add(buildName, '\ - lodash.contains(numbers, limit - 1)' - ) - .add(otherName, '\ - _.contains(numbers, limit - 1)' - ) - ); - - suites.push( - Benchmark.Suite('`_.contains` iterating an object') - .add(buildName, '\ - lodash.contains(object, limit - 1)' - ) - .add(otherName, '\ - _.contains(object, limit - 1)' - ) - ); - - /*--------------------------------------------------------------------------*/ - suites.push( Benchmark.Suite('`_.countBy` with `callback` iterating an array') .add(buildName, '\ @@ -794,13 +742,13 @@ ); suites.push( - Benchmark.Suite('`_.difference` iterating 75 elements') + Benchmark.Suite('`_.difference` iterating 20 and 40 elements') .add(buildName, { - 'fn': 'lodash.difference(seventyFiveValues, seventyFiveValues2)', + 'fn': 'lodash.difference(twentyValues, fortyValues)', 'teardown': 'function multiArrays(){}' }) .add(otherName, { - 'fn': '_.difference(seventyFiveValues, seventyFiveValues2)', + 'fn': '_.difference(twentyValues, fortyValues)', 'teardown': 'function multiArrays(){}' }) ); @@ -817,18 +765,6 @@ }) ); - suites.push( - Benchmark.Suite('`_.difference` iterating 20 and 40 elements') - .add(buildName, { - 'fn': 'lodash.difference(twentyValues, fortyValues2)', - 'teardown': 'function multiArrays(){}' - }) - .add(otherName, { - 'fn': '_.difference(twentyValues, fortyValues2)', - 'teardown': 'function multiArrays(){}' - }) - ); - /*--------------------------------------------------------------------------*/ suites.push( @@ -847,22 +783,6 @@ ) ); - suites.push( - Benchmark.Suite('`_.each` iterating an array with `thisArg` (slow path)') - .add(buildName, '\ - var result = [];\ - lodash.each(numbers, function(num, index) {\ - result.push(num + this["key" + index]);\ - }, object)' - ) - .add(otherName, '\ - var result = [];\ - _.each(numbers, function(num, index) {\ - result.push(num + this["key" + index]);\ - }, object)' - ) - ); - suites.push( Benchmark.Suite('`_.each` iterating an object') .add(buildName, '\ @@ -885,12 +805,12 @@ Benchmark.Suite('`_.every` iterating an array') .add(buildName, '\ lodash.every(numbers, function(num) {\ - return num + "";\ + return num < limit;\ })' ) .add(otherName, '\ _.every(numbers, function(num) {\ - return num + "";\ + return num < limit;\ })' ) ); @@ -899,30 +819,18 @@ Benchmark.Suite('`_.every` iterating an object') .add(buildName, '\ lodash.every(object, function(num) {\ - return num + "";\ + return num < limit;\ })' ) .add(otherName, '\ _.every(object, function(num) {\ - return num + "";\ + return num < limit;\ })' ) ); /*--------------------------------------------------------------------------*/ - suites.push( - Benchmark.Suite('`_.extend`') - .add(buildName, '\ - lodash.extend({}, object)' - ) - .add(otherName, '\ - _.extend({}, object)' - ) - ); - - /*--------------------------------------------------------------------------*/ - suites.push( Benchmark.Suite('`_.filter` iterating an array') .add(buildName, '\ @@ -937,20 +845,6 @@ ) ); - suites.push( - Benchmark.Suite('`_.filter` iterating an array with `thisArg` (slow path)') - .add(buildName, '\ - lodash.filter(numbers, function(num, index) {\ - return this["key" + index] % 2;\ - }, object)' - ) - .add(otherName, '\ - _.filter(numbers, function(num, index) {\ - return this["key" + index] % 2;\ - }, object)' - ) - ); - suites.push( Benchmark.Suite('`_.filter` iterating an object') .add(buildName, '\ @@ -965,6 +859,30 @@ ) ); + suites.push( + Benchmark.Suite('`_.filter` with `_.matches` shorthand') + .add(buildName, { + 'fn': 'lodash.filter(objects, source)', + 'teardown': 'function matches(){}' + }) + .add(otherName, { + 'fn': '_.filter(objects, source)', + 'teardown': 'function matches(){}' + }) + ); + + suites.push( + Benchmark.Suite('`_.filter` with `_.matches` predicate') + .add(buildName, { + 'fn': 'lodash.filter(objects, lodashMatcher)', + 'teardown': 'function matches(){}' + }) + .add(otherName, { + 'fn': '_.filter(objects, _matcher)', + 'teardown': 'function matches(){}' + }) + ); + /*--------------------------------------------------------------------------*/ suites.push( @@ -995,51 +913,83 @@ ) ); - // avoid Underscore induced `OutOfMemoryError` in Rhino, Narwhal, and Ringo - if (!isJava) { - suites.push( - Benchmark.Suite('`_.find` with `properties`') - .add(buildName, { - 'fn': 'lodashFindWhere(objects, whereObject)', - 'teardown': 'function where(){}' - }) - .add(otherName, { - 'fn': '_findWhere(objects, whereObject)', - 'teardown': 'function where(){}' - }) - ); - } + // Avoid Underscore induced `OutOfMemoryError` in Rhino and Ringo. + suites.push( + Benchmark.Suite('`_.find` with `_.matches` shorthand') + .add(buildName, { + 'fn': 'lodash.find(objects, source)', + 'teardown': 'function matches(){}' + }) + .add(otherName, { + 'fn': '_.find(objects, source)', + 'teardown': 'function matches(){}' + }) + ); /*--------------------------------------------------------------------------*/ suites.push( Benchmark.Suite('`_.flatten`') - .add(buildName, '\ - lodash.flatten(nestedNumbers)' - ) - .add(otherName, '\ - _.flatten(nestedNumbers)' - ) + .add(buildName, { + 'fn': 'lodash.flatten(nestedNumbers, !lodashFlattenDeep)', + 'teardown': 'function flatten(){}' + }) + .add(otherName, { + 'fn': '_.flatten(nestedNumbers, !_flattenDeep)', + 'teardown': 'function flatten(){}' + }) ); + /*--------------------------------------------------------------------------*/ + suites.push( - Benchmark.Suite('`_.flatten` with objects') - .add(buildName, '\ - lodash.flatten(nestedObjects)' - ) - .add(otherName, '\ - _.flatten(nestedObjects)' - ) + Benchmark.Suite('`_.flattenDeep` nested arrays of numbers') + .add(buildName, { + 'fn': 'lodash.flattenDeep(nestedNumbers)', + 'teardown': 'function flatten(){}' + }) + .add(otherName, { + 'fn': '_.flattenDeep(nestedNumbers)', + 'teardown': 'function flatten(){}' + }) ); suites.push( - Benchmark.Suite('`_.flatten` with `shallow`') - .add(buildName, '\ - lodash.flatten(nestedNumbers, true)' - ) - .add(otherName, '\ - _.flatten(nestedNumbers, true)' - ) + Benchmark.Suite('`_.flattenDeep` nest arrays of objects') + .add(buildName, { + 'fn': 'lodash.flattenDeep(nestedObjects)', + 'teardown': 'function flatten(){}' + }) + .add(otherName, { + 'fn': '_.flattenDeep(nestedObjects)', + 'teardown': 'function flatten(){}' + }) + ); + + /*--------------------------------------------------------------------------*/ + + suites.push( + Benchmark.Suite('`_.flowRight`') + .add(buildName, { + 'fn': 'lodash.flowRight(compAddThree, compAddTwo, compAddOne)', + 'teardown': 'function flowRight(){}' + }) + .add(otherName, { + 'fn': '_.flowRight(compAddThree, compAddTwo, compAddOne)', + 'teardown': 'function flowRight(){}' + }) + ); + + suites.push( + Benchmark.Suite('composed call') + .add(buildName, { + 'fn': 'lodashComposed(0)', + 'teardown': 'function flowRight(){}' + }) + .add(otherName, { + 'fn': '_composed(0)', + 'teardown': 'function flowRight(){}' + }) ); /*--------------------------------------------------------------------------*/ @@ -1093,49 +1043,47 @@ /*--------------------------------------------------------------------------*/ suites.push( - Benchmark.Suite('`_.indexBy` with `callback` iterating an array') + Benchmark.Suite('`_.includes` searching an array') .add(buildName, '\ - lodash.indexBy(numbers, function(num) { return num >> 1; })' + lodash.includes(numbers, limit - 1)' ) .add(otherName, '\ - _.indexBy(numbers, function(num) { return num >> 1; })' + _.includes(numbers, limit - 1)' ) ); suites.push( - Benchmark.Suite('`_.indexBy` with `property` name iterating an array') - .add(buildName, { - 'fn': 'lodash.indexBy(words, "length")', - 'teardown': 'function countBy(){}' - }) - .add(otherName, { - 'fn': '_.indexBy(words, "length")', - 'teardown': 'function countBy(){}' - }) + Benchmark.Suite('`_.includes` searching an object') + .add(buildName, '\ + lodash.includes(object, limit - 1)' + ) + .add(otherName, '\ + _.includes(object, limit - 1)' + ) ); - suites.push( - Benchmark.Suite('`_.indexBy` with `callback` iterating an object') - .add(buildName, { - 'fn': 'lodash.indexBy(wordToNumber, function(num) { return num >> 1; })', - 'teardown': 'function countBy(){}' - }) - .add(otherName, { - 'fn': '_.indexBy(wordToNumber, function(num) { return num >> 1; })', - 'teardown': 'function countBy(){}' - }) - ); + if (lodash.includes('ab', 'ab') && _.includes('ab', 'ab')) { + suites.push( + Benchmark.Suite('`_.includes` searching a string') + .add(buildName, '\ + lodash.includes(strNumbers, "," + (limit - 1))' + ) + .add(otherName, '\ + _.includes(strNumbers, "," + (limit - 1))' + ) + ); + } /*--------------------------------------------------------------------------*/ suites.push( Benchmark.Suite('`_.indexOf`') .add(buildName, { - 'fn': 'lodash.indexOf(twoHundredValues, 199)', + 'fn': 'lodash.indexOf(hundredSortedValues, 99)', 'teardown': 'function multiArrays(){}' }) .add(otherName, { - 'fn': '_.indexOf(twoHundredValues, 199)', + 'fn': '_.indexOf(hundredSortedValues, 99)', 'teardown': 'function multiArrays(){}' }) ); @@ -1153,25 +1101,13 @@ ); suites.push( - Benchmark.Suite('`_.intersection` iterating 75 elements') - .add(buildName, { - 'fn': 'lodash.intersection(seventyFiveValues, seventyFiveValues2)', - 'teardown': 'function multiArrays(){}' - }) - .add(otherName, { - 'fn': '_.intersection(seventyFiveValues, seventyFiveValues2)', - 'teardown': 'function multiArrays(){}' - }) - ); - - suites.push( - Benchmark.Suite('`_.intersection` iterating 200 elements') + Benchmark.Suite('`_.intersection` iterating 120 elements') .add(buildName, { - 'fn': 'lodash.intersection(twoHundredValues, twoHundredValues2)', + 'fn': 'lodash.intersection(hundredTwentyValues, hundredTwentyValues2)', 'teardown': 'function multiArrays(){}' }) .add(otherName, { - 'fn': '_.intersection(twoHundredValues, twoHundredValues2)', + 'fn': '_.intersection(hundredTwentyValues, hundredTwentyValues2)', 'teardown': 'function multiArrays(){}' }) ); @@ -1191,45 +1127,75 @@ /*--------------------------------------------------------------------------*/ suites.push( - Benchmark.Suite('`_.invoke` iterating an array') + Benchmark.Suite('`_.invokeMap` iterating an array') .add(buildName, '\ - lodash.invoke(numbers, "toFixed", "2")' + lodash.invokeMap(numbers, "toFixed")' ) .add(otherName, '\ - _.invoke(numbers, "toFixed", "2")' + _.invokeMap(numbers, "toFixed")' ) ); suites.push( - Benchmark.Suite('`_.invoke` with a function for `methodName` iterating an array') + Benchmark.Suite('`_.invokeMap` with arguments iterating an array') .add(buildName, '\ - lodash.invoke(numbers, String.prototype.split, "")' + lodash.invokeMap(numbers, "toFixed", 1)' ) .add(otherName, '\ - _.invoke(numbers, String.prototype.split, "")' + _.invokeMap(numbers, "toFixed", 1)' ) ); suites.push( - Benchmark.Suite('`_.invoke` iterating an object') + Benchmark.Suite('`_.invokeMap` with a function for `path` iterating an array') .add(buildName, '\ - lodash.invoke(object, "toFixed", "2")' + lodash.invokeMap(numbers, Number.prototype.toFixed, 1)' ) .add(otherName, '\ - _.invoke(object, "toFixed", "2")' + _.invokeMap(numbers, Number.prototype.toFixed, 1)' + ) + ); + + suites.push( + Benchmark.Suite('`_.invokeMap` iterating an object') + .add(buildName, '\ + lodash.invokeMap(object, "toFixed", 1)' + ) + .add(otherName, '\ + _.invokeMap(object, "toFixed", 1)' ) ); /*--------------------------------------------------------------------------*/ suites.push( - Benchmark.Suite('`_.isEqual` comparing primitives and objects (edge case)') + Benchmark.Suite('`_.isEqual` comparing primitives') + .add(buildName, { + 'fn': '\ + lodash.isEqual(1, "1");\ + lodash.isEqual(1, 1)', + 'teardown': 'function isEqual(){}' + }) + .add(otherName, { + 'fn': '\ + _.isEqual(1, "1");\ + _.isEqual(1, 1);', + 'teardown': 'function isEqual(){}' + }) + ); + + suites.push( + Benchmark.Suite('`_.isEqual` comparing primitives and their object counterparts (edge case)') .add(buildName, { - 'fn': 'lodash.isEqual(objectOfPrimitives, objectOfObjects)', + 'fn': '\ + lodash.isEqual(objectOfPrimitives, objectOfObjects);\ + lodash.isEqual(objectOfPrimitives, objectOfObjects2)', 'teardown': 'function isEqual(){}' }) .add(otherName, { - 'fn': '_.isEqual(objectOfPrimitives, objectOfObjects)', + 'fn': '\ + _.isEqual(objectOfPrimitives, objectOfObjects);\ + _.isEqual(objectOfPrimitives, objectOfObjects2)', 'teardown': 'function isEqual(){}' }) ); @@ -1239,13 +1205,13 @@ .add(buildName, { 'fn': '\ lodash.isEqual(numbers, numbers2);\ - lodash.isEqual(twoNumbers, twoNumbers2)', + lodash.isEqual(numbers2, numbers3)', 'teardown': 'function isEqual(){}' }) .add(otherName, { 'fn': '\ _.isEqual(numbers, numbers2);\ - _.isEqual(twoNumbers, twoNumbers2)', + _.isEqual(numbers2, numbers3)', 'teardown': 'function isEqual(){}' }) ); @@ -1271,13 +1237,13 @@ .add(buildName, { 'fn': '\ lodash.isEqual(objects, objects2);\ - lodash.isEqual(simpleObjects, simpleObjects2)', + lodash.isEqual(objects2, objects3)', 'teardown': 'function isEqual(){}' }) .add(otherName, { 'fn': '\ _.isEqual(objects, objects2);\ - _.isEqual(simpleObjects, simpleObjects2)', + _.isEqual(objects2, objects3)', 'teardown': 'function isEqual(){}' }) ); @@ -1287,13 +1253,13 @@ .add(buildName, { 'fn': '\ lodash.isEqual(object, object2);\ - lodash.isEqual(simpleObject, simpleObject2)', + lodash.isEqual(object2, object3)', 'teardown': 'function isEqual(){}' }) .add(otherName, { 'fn': '\ _.isEqual(object, object2);\ - _.isEqual(simpleObject, simpleObject2)', + _.isEqual(object2, object3)', 'teardown': 'function isEqual(){}' }) ); @@ -1348,12 +1314,14 @@ suites.push( Benchmark.Suite('`_.lastIndexOf`') - .add(buildName, '\ - lodash.lastIndexOf(numbers, 9)' - ) - .add(otherName, '\ - _.lastIndexOf(numbers, 9)' - ) + .add(buildName, { + 'fn': 'lodash.lastIndexOf(hundredSortedValues, 0)', + 'teardown': 'function multiArrays(){}' + }) + .add(otherName, { + 'fn': '_.lastIndexOf(hundredSortedValues, 0)', + 'teardown': 'function multiArrays(){}' + }) ); /*--------------------------------------------------------------------------*/ @@ -1372,20 +1340,6 @@ ) ); - suites.push( - Benchmark.Suite('`_.map` with `thisArg` iterating an array (slow path)') - .add(buildName, '\ - lodash.map(objects, function(value, index) {\ - return this["key" + index] + value.num;\ - }, object)' - ) - .add(otherName, '\ - _.map(objects, function(value, index) {\ - return this["key" + index] + value.num;\ - }, object)' - ) - ); - suites.push( Benchmark.Suite('`_.map` iterating an object') .add(buildName, '\ @@ -1400,6 +1354,16 @@ ) ); + suites.push( + Benchmark.Suite('`_.map` with `_.property` shorthand') + .add(buildName, '\ + lodash.map(objects, "num")' + ) + .add(otherName, '\ + _.map(objects, "num")' + ) + ); + /*--------------------------------------------------------------------------*/ suites.push( @@ -1451,25 +1415,13 @@ /*--------------------------------------------------------------------------*/ suites.push( - Benchmark.Suite('`_.pairs`') - .add(buildName, '\ - lodash.pairs(object)' - ) - .add(otherName, '\ - _.pairs(object)' - ) - ); - - /*--------------------------------------------------------------------------*/ - - suites.push( - Benchmark.Suite('`_.partial`') + Benchmark.Suite('`_.partial` (slow path)') .add(buildName, { - 'fn': 'lodash.partial(func, "hi")', + 'fn': 'lodash.partial(function(greeting) { return greeting + " " + this.name; }, "hi")', 'teardown': 'function partial(){}' }) .add(otherName, { - 'fn': '_.partial(func, "hi")', + 'fn': '_.partial(function(greeting) { return greeting + " " + this.name; }, "hi")', 'teardown': 'function partial(){}' }) ); @@ -1489,24 +1441,42 @@ /*--------------------------------------------------------------------------*/ suites.push( - Benchmark.Suite('`_.pick`') + Benchmark.Suite('`_.partition` iterating an array') .add(buildName, '\ - lodash.pick(object, "key6", "key13")' + lodash.partition(numbers, function(num) {\ + return num % 2;\ + })' ) .add(otherName, '\ - _.pick(object, "key6", "key13")' + _.partition(numbers, function(num) {\ + return num % 2;\ + })' + ) + ); + + suites.push( + Benchmark.Suite('`_.partition` iterating an object') + .add(buildName, '\ + lodash.partition(object, function(num) {\ + return num % 2;\ + })' + ) + .add(otherName, '\ + _.partition(object, function(num) {\ + return num % 2;\ + })' ) ); /*--------------------------------------------------------------------------*/ suites.push( - Benchmark.Suite('`_.pluck`') + Benchmark.Suite('`_.pick`') .add(buildName, '\ - lodash.pluck(objects, "num")' + lodash.pick(object, "key6", "key13")' ) .add(otherName, '\ - _.pluck(objects, "num")' + _.pick(object, "key6", "key13")' ) ); @@ -1594,30 +1564,16 @@ ) ); - suites.push( - Benchmark.Suite('`_.reject` iterating an array with `thisArg` (slow path)') - .add(buildName, '\ - lodash.reject(numbers, function(num, index) {\ - return this["key" + index] % 2;\ - }, object)' - ) - .add(otherName, '\ - _.reject(numbers, function(num, index) {\ - return this["key" + index] % 2;\ - }, object)' - ) - ); - suites.push( Benchmark.Suite('`_.reject` iterating an object') .add(buildName, '\ lodash.reject(object, function(num) {\ - return num % 2\ + return num % 2;\ })' ) .add(otherName, '\ _.reject(object, function(num) {\ - return num % 2\ + return num % 2;\ })' ) ); @@ -1625,12 +1581,12 @@ /*--------------------------------------------------------------------------*/ suites.push( - Benchmark.Suite('`_.sample` with an `n`') + Benchmark.Suite('`_.sampleSize`') .add(buildName, '\ - lodash.sample(numbers, limit / 2)' + lodash.sampleSize(numbers, limit / 2)' ) .add(otherName, '\ - _.sample(numbers, limit / 2)' + _.sampleSize(numbers, limit / 2)' ) ); @@ -1674,20 +1630,6 @@ ) ); - suites.push( - Benchmark.Suite('`_.some` with `thisArg` iterating an array (slow path)') - .add(buildName, '\ - lodash.some(objects, function(value, index) {\ - return this["key" + index] == (limit - 1);\ - }, object)' - ) - .add(otherName, '\ - _.some(objects, function(value, index) {\ - return this["key" + index] == (limit - 1);\ - }, object)' - ) - ); - suites.push( Benchmark.Suite('`_.some` iterating an object') .add(buildName, '\ @@ -1714,16 +1656,6 @@ ) ); - suites.push( - Benchmark.Suite('`_.sortBy` with `callback` and `thisArg` (slow path)') - .add(buildName, '\ - lodash.sortBy(numbers, function(num) { return this.sin(num); }, Math)' - ) - .add(otherName, '\ - _.sortBy(numbers, function(num) { return this.sin(num); }, Math)' - ) - ); - suites.push( Benchmark.Suite('`_.sortBy` with `property` name') .add(buildName, { @@ -1739,17 +1671,29 @@ /*--------------------------------------------------------------------------*/ suites.push( - Benchmark.Suite('`_.sortedIndex` with `callback`') + Benchmark.Suite('`_.sortedIndex`') + .add(buildName, '\ + lodash.sortedIndex(numbers, limit)' + ) + .add(otherName, '\ + _.sortedIndex(numbers, limit)' + ) + ); + + /*--------------------------------------------------------------------------*/ + + suites.push( + Benchmark.Suite('`_.sortedIndexBy`') .add(buildName, { 'fn': '\ - lodash.sortedIndex(words, "twenty-five", function(value) {\ + lodash.sortedIndexBy(words, "twenty-five", function(value) {\ return wordToNumber[value];\ })', 'teardown': 'function countBy(){}' }) .add(otherName, { 'fn': '\ - _.sortedIndex(words, "twenty-five", function(value) {\ + _.sortedIndexBy(words, "twenty-five", function(value) {\ return wordToNumber[value];\ })', 'teardown': 'function countBy(){}' @@ -1758,14 +1702,54 @@ /*--------------------------------------------------------------------------*/ + suites.push( + Benchmark.Suite('`_.sortedIndexOf`') + .add(buildName, { + 'fn': 'lodash.sortedIndexOf(hundredSortedValues, 99)', + 'teardown': 'function multiArrays(){}' + }) + .add(otherName, { + 'fn': '_.sortedIndexOf(hundredSortedValues, 99)', + 'teardown': 'function multiArrays(){}' + }) + ); + + /*--------------------------------------------------------------------------*/ + + suites.push( + Benchmark.Suite('`_.sortedLastIndexOf`') + .add(buildName, { + 'fn': 'lodash.sortedLastIndexOf(hundredSortedValues, 0)', + 'teardown': 'function multiArrays(){}' + }) + .add(otherName, { + 'fn': '_.sortedLastIndexOf(hundredSortedValues, 0)', + 'teardown': 'function multiArrays(){}' + }) + ); + + /*--------------------------------------------------------------------------*/ + + suites.push( + Benchmark.Suite('`_.sum`') + .add(buildName, '\ + lodash.sum(numbers)' + ) + .add(otherName, '\ + _.sum(numbers)' + ) + ); + + /*--------------------------------------------------------------------------*/ + suites.push( Benchmark.Suite('`_.template` (slow path)') .add(buildName, { - 'fn': 'lodash.template(tpl, tplData)', + 'fn': 'lodash.template(tpl)(tplData)', 'teardown': 'function template(){}' }) .add(otherName, { - 'fn': '_.template(tpl, tplData)', + 'fn': '_.template(tpl)(tplData)', 'teardown': 'function template(){}' }) ); @@ -1808,18 +1792,6 @@ ) ); - suites.push( - Benchmark.Suite('`_.times` with `thisArg`') - .add(buildName, '\ - var result = [];\ - lodash.times(limit, function(n) { result.push(this.sin(n)); }, Math)' - ) - .add(otherName, '\ - var result = [];\ - _.times(limit, function(n) { result.push(this.sin(n)); }, Math)' - ) - ); - /*--------------------------------------------------------------------------*/ suites.push( @@ -1845,85 +1817,81 @@ /*--------------------------------------------------------------------------*/ suites.push( - Benchmark.Suite('`_.union`') + Benchmark.Suite('`_.toPairs`') .add(buildName, '\ - lodash.union(numbers, twoNumbers, fourNumbers)' + lodash.toPairs(object)' ) .add(otherName, '\ - _.union(numbers, twoNumbers, fourNumbers)' + _.toPairs(object)' ) ); - suites.push( - Benchmark.Suite('`_.union` iterating an array of 75 elements') - .add(buildName, { - 'fn': 'lodash.union(twentyFiveValues, fiftyValues2)', - 'teardown': 'function multiArrays(){}' - }) - .add(otherName, { - 'fn': '_.union(twentyFiveValues, fiftyValues2)', - 'teardown': 'function multiArrays(){}' - }) - ); + /*--------------------------------------------------------------------------*/ suites.push( - Benchmark.Suite('`_.union` iterating an array of 200 elements') - .add(buildName, { - 'fn': 'lodash.union(oneHundredValues, oneHundredValues2)', - 'teardown': 'function multiArrays(){}' - }) - .add(otherName, { - 'fn': '_.union(oneHundredValues, oneHundredValues2)', - 'teardown': 'function multiArrays(){}' - }) + Benchmark.Suite('`_.unescape` string without html entities') + .add(buildName, '\ + lodash.unescape("`&`, `<`, `>`, `\\"`, and `\'`")' + ) + .add(otherName, '\ + _.unescape("`&`, `<`, `>`, `\\"`, and `\'`")' + ) ); - /*--------------------------------------------------------------------------*/ - suites.push( - Benchmark.Suite('`_.uniq`') + Benchmark.Suite('`_.unescape` string with html entities') .add(buildName, '\ - lodash.uniq(numbers.concat(twoNumbers, fourNumbers))' + lodash.unescape("`&`, `<`, `>`, `"`, and `'`")' ) .add(otherName, '\ - _.uniq(numbers.concat(twoNumbers, fourNumbers))' + _.unescape("`&`, `<`, `>`, `"`, and `'`")' ) ); + /*--------------------------------------------------------------------------*/ + suites.push( - Benchmark.Suite('`_.uniq` with `callback`') + Benchmark.Suite('`_.union`') .add(buildName, '\ - lodash.uniq(numbers.concat(twoNumbers, fourNumbers), function(num) {\ - return num % 2;\ - })' + lodash.union(numbers, twoNumbers, fourNumbers)' ) .add(otherName, '\ - _.uniq(numbers.concat(twoNumbers, fourNumbers), function(num) {\ - return num % 2;\ - })' + _.union(numbers, twoNumbers, fourNumbers)' ) ); suites.push( - Benchmark.Suite('`_.uniq` iterating an array of 75 elements') + Benchmark.Suite('`_.union` iterating an array of 200 elements') .add(buildName, { - 'fn': 'lodash.uniq(twentyFiveValues.concat(fiftyValues2))', + 'fn': 'lodash.union(hundredValues, hundredValues2)', 'teardown': 'function multiArrays(){}' }) .add(otherName, { - 'fn': '_.uniq(twentyFiveValues.concat(fiftyValues2))', + 'fn': '_.union(hundredValues, hundredValues2)', 'teardown': 'function multiArrays(){}' }) ); + /*--------------------------------------------------------------------------*/ + + suites.push( + Benchmark.Suite('`_.uniq`') + .add(buildName, '\ + lodash.uniq(numbers.concat(twoNumbers, fourNumbers))' + ) + .add(otherName, '\ + _.uniq(numbers.concat(twoNumbers, fourNumbers))' + ) + ); + suites.push( Benchmark.Suite('`_.uniq` iterating an array of 200 elements') .add(buildName, { - 'fn': 'lodash.uniq(oneHundredValues.concat(oneHundredValues2))', + 'fn': 'lodash.uniq(twoHundredValues)', 'teardown': 'function multiArrays(){}' }) .add(otherName, { - 'fn': '_.uniq(oneHundredValues.concat(oneHundredValues2))', + 'fn': '_.uniq(twoHundredValues)', 'teardown': 'function multiArrays(){}' }) ); @@ -1931,27 +1899,29 @@ /*--------------------------------------------------------------------------*/ suites.push( - Benchmark.Suite('`_.values`') + Benchmark.Suite('`_.uniqBy`') .add(buildName, '\ - lodash.values(object)' + lodash.uniqBy(numbers.concat(twoNumbers, fourNumbers), function(num) {\ + return num % 2;\ + })' ) .add(otherName, '\ - _.values(object)' + _.uniqBy(numbers.concat(twoNumbers, fourNumbers), function(num) {\ + return num % 2;\ + })' ) ); /*--------------------------------------------------------------------------*/ suites.push( - Benchmark.Suite('`_.where`') - .add(buildName, { - 'fn': 'lodash.where(objects, whereObject)', - 'teardown': 'function where(){}' - }) - .add(otherName, { - 'fn': '_.where(objects, whereObject)', - 'teardown': 'function where(){}' - }) + Benchmark.Suite('`_.values`') + .add(buildName, '\ + lodash.values(object)' + ) + .add(otherName, '\ + _.values(object)' + ) ); /*--------------------------------------------------------------------------*/ @@ -1999,10 +1969,10 @@ if (Benchmark.platform + '') { log(Benchmark.platform); } - // in the browser, expose `run` to be called later - if (root.document && !root.phantom) { + // Expose `run` to be called later when executing in a browser. + if (document) { root.run = run; } else { run(); } -}(typeof global == 'object' && global || this)); +}.call(this)); diff --git a/perf/run-perf.sh b/perf/run-perf.sh deleted file mode 100755 index b1406315b4..0000000000 --- a/perf/run-perf.sh +++ /dev/null @@ -1,14 +0,0 @@ -cd "$(dirname "$0")" - -echo "Running performance suite in node..." -node perf.js ../dist/lodash.js && node perf.js ../dist/lodash.min.js - -for cmd in rhino "rhino -require" narwhal ringo phantomjs; do - echo "" - echo "Running performance suite in $cmd..." - $cmd perf.js ../dist/lodash.compat.js && $cmd perf.js ../dist/lodash.compat.min.js -done - -echo "" -echo "Running performance suite in a browser..." -open index.html diff --git a/test/asset/test-ui.js b/test/asset/test-ui.js index ab5b03851d..968f0f8ec8 100644 --- a/test/asset/test-ui.js +++ b/test/asset/test-ui.js @@ -1,41 +1,22 @@ ;(function(window) { 'use strict'; - /** The base path of the builds */ + /** The base path of the lodash builds. */ var basePath = '../'; - /** The Lo-Dash build to load */ + /** The lodash build to load. */ var build = (build = /build=([^&]+)/.exec(location.search)) && decodeURIComponent(build[1]); - /** The module loader to use */ + /** The module loader to use. */ var loader = (loader = /loader=([^&]+)/.exec(location.search)) && decodeURIComponent(loader[1]); - /** The `ui` object */ + /** The `ui` object. */ var ui = {}; /*--------------------------------------------------------------------------*/ - /** - * Registers an event listener on an element. - * - * @private - * @param {Element} element The element. - * @param {string} eventName The name of the event. - * @param {Function} handler The event handler. - * @returns {Element} The element. - */ - function addListener(element, eventName, handler) { - if (typeof element.addEventListener != 'undefined') { - element.addEventListener(eventName, handler, false); - } else if (typeof element.attachEvent != 'undefined') { - element.attachEvent('on' + eventName, handler); - } - } - - /*--------------------------------------------------------------------------*/ - - // initialize controls - addListener(window, 'load', function() { + // Initialize controls. + addEventListener('load', function() { function eventHandler(event) { var buildIndex = buildList.selectedIndex, loaderIndex = loaderList.selectedIndex, @@ -55,63 +36,50 @@ function init() { var toolbar = document.getElementById('qunit-testrunner-toolbar'); - if (toolbar) { - toolbar.appendChild(span1); - toolbar.appendChild(span2); - - buildList.selectedIndex = (function() { - switch (build) { - case 'lodash-compat': return 1; - case 'lodash-modern-dev': return 2; - case 'lodash-modern': return 3; - case 'lodash-legacy': return 4; - case 'lodash-mobile': return 5; - case 'lodash-underscore': return 6; - case 'lodash-custom-dev': return 7; - case 'lodash-custom': return 8; - case 'lodash-compat-dev': - case null: return 0; - } - return -1; - }()); - - loaderList.selectedIndex = (function() { - switch (loader) { - case 'curl': return 1; - case 'dojo': return 2; - case 'requirejs': return 3; - case 'none': - case null: return 0; - } - return -1; - }()); - - addListener(buildList, 'change', eventHandler); - addListener(loaderList, 'change', eventHandler); - } - else { + if (!toolbar) { setTimeout(init, 15); + return; } + toolbar.insertBefore(span2, toolbar.lastChild); + toolbar.insertBefore(span1, span2); + + buildList.selectedIndex = (function() { + switch (build) { + case 'lodash': return 1; + case 'lodash-core-dev': return 2; + case 'lodash-core': return 3; + case 'lodash-dev': + case null: return 0; + } + return -1; + }()); + + loaderList.selectedIndex = (function() { + switch (loader) { + case 'curl': return 1; + case 'dojo': return 2; + case 'requirejs': return 3; + case 'none': + case null: return 0; + } + return -1; + }()); + + buildList.addEventListener('change', eventHandler); + loaderList.addEventListener('change', eventHandler); } var span1 = document.createElement('span'); - span1.style.cssText = 'float:right'; span1.innerHTML = 'Build: ' + ''; var span2 = document.createElement('span'); - span2.style.cssText = 'float:right'; span2.innerHTML = 'Loader: ' + ''; + span1.style.cssText = + span2.style.cssText = 'display:inline-block;float:right;line-height:2.1em;margin-left:1em;margin-top:0;'; + + span1.firstChild.style.cssText = + span2.firstChild.style.cssText = 'display:inline-block;margin-right:.5em;'; + var buildList = span1.lastChild, loaderList = span2.lastChild; + setTimeout(function() { + ui.timing.loadEventEnd = +new Date; + }, 1); + init(); }); - // expose Lo-Dash build file path + // The lodash build file path. ui.buildPath = (function() { var result; switch (build) { - case 'lodash-compat': result = 'dist/lodash.compat.min.js'; break; - case 'lodash-modern-dev': result = 'dist/lodash.js'; break; - case 'lodash-modern': result = 'dist/lodash.min.js'; break; - case 'lodash-legacy': result = 'dist/lodash.legacy.min.js'; break; - case 'lodash-mobile': result = 'dist/lodash.mobile.min.js'; break; - case 'lodash-underscore': result = 'dist/lodash.underscore.min.js'; break; - case 'lodash-custom-dev': result = 'lodash.custom.js'; break; - case 'lodash-custom': result = 'lodash.custom.min.js'; break; - case null: build = 'lodash-compat-dev'; - case 'lodash-compat-dev': result = 'lodash.js'; break; + case 'lodash': result = 'dist/lodash.min.js'; break; + case 'lodash-core-dev': result = 'dist/lodash.core.js'; break; + case 'lodash-core': result = 'dist/lodash.core.min.js'; break; + case null: build = 'lodash-dev'; + case 'lodash-dev': result = 'lodash.js'; break; default: return build; } return basePath + result; }()); - // expose module loader file path + // The module loader file path. ui.loaderPath = (function() { var result; switch (loader) { - case 'curl': result = 'vendor/curl/dist/curl-kitchen-sink/curl.js'; break; - case 'dojo': result = 'vendor/dojo/dojo.js'; break; - case 'requirejs': result = 'vendor/requirejs/require.js'; break; + case 'curl': result = 'node_modules/curl-amd/dist/curl-kitchen-sink/curl.js'; break; + case 'dojo': result = 'node_modules/dojo/dojo.js'; break; + case 'requirejs': result = 'node_modules/requirejs/require.js'; break; case null: loader = 'none'; return ''; default: return loader; } return basePath + result; }()); - // expose `ui.urlParams` properties - ui.urlParams = { - 'build': build, - 'loader': loader - }; + // Used to indicate testing a core build. + ui.isCore = /\bcore(\.min)?\.js\b/.test(ui.buildPath); + + // Used to indicate testing a foreign file. + ui.isForeign = RegExp('^(\\w+:)?//').test(build); + + // Used to indicate testing a modularized build. + ui.isModularize = /\b(?:amd|commonjs|es|node|npm|(index|main)\.js)\b/.test([location.pathname, location.search]); + + // Used to indicate testing in Sauce Labs' automated test cloud. + ui.isSauceLabs = location.port == '9001'; + + // Used to indicate that lodash is in strict mode. + ui.isStrict = /\bes\b/.test([location.pathname, location.search]); - // used to indicate testing a modularized build - ui.isModularize = /\b(?:commonjs|(index|main)\.js|lodash-(?:amd|node)|modularize|npm)\b/.test([location.pathname, location.search, ui.buildPath]); + ui.urlParams = { 'build': build, 'loader': loader }; + ui.timing = { 'loadEventEnd': 0 }; - // expose `ui` window.ui = ui; }(this)); diff --git a/test/asset/worker.js b/test/asset/worker.js index 75f21c9a58..a44463045c 100644 --- a/test/asset/worker.js +++ b/test/asset/worker.js @@ -1,6 +1,17 @@ +'use strict'; + +self.console || (self.console = { 'log': function() {} }); + addEventListener('message', function(e) { if (e.data) { - importScripts('../' + e.data); + try { + importScripts('../' + e.data); + } catch (e) { + var lineNumber = e.lineNumber, + message = (lineNumber == null ? '' : (lineNumber + ': ')) + e.message; + + self._ = { 'VERSION': message }; + } postMessage(_.VERSION); } -}, false); +}); diff --git a/test/backbone.html b/test/backbone.html index 4f7b03aa83..e338f2799f 100644 --- a/test/backbone.html +++ b/test/backbone.html @@ -1,76 +1,170 @@ - - - Backbone Test Suite - - - - -

Test

- - - - - - - - + + + + + + + - - - - - - - - - - - + lodash.forOwn(keyMap, function(realName, otherName) { + _[otherName] = lodash[realName]; + _.prototype[otherName] = lodash.prototype[realName]; + }); + lodash.forOwn(aliasToReal, function(realName, alias) { + _[alias] = _[realName]; + _.prototype[alias] = _.prototype[realName]; + }); + return _; + }; + }()); + + // Load prerequisite scripts. + document.write(ui.urlParams.loader == 'none' + ? ' + + + diff --git a/test/fp.html b/test/fp.html new file mode 100644 index 0000000000..712296664f --- /dev/null +++ b/test/fp.html @@ -0,0 +1,41 @@ + + + + + lodash-fp Test Suite + + + + + + + + + + + +

+ + + diff --git a/test/index.html b/test/index.html index f0057617b2..8d3f64f8f4 100644 --- a/test/index.html +++ b/test/index.html @@ -1,202 +1,341 @@ - - - Lo-Dash Test Suite - - - - - - - - -

- - - - + + + lodash Test Suite + + + + + + + + + + + +

+ + + + diff --git a/test/remove.js b/test/remove.js new file mode 100644 index 0000000000..bd5aaf9271 --- /dev/null +++ b/test/remove.js @@ -0,0 +1,27 @@ +#!/usr/bin/env node +'use strict'; + +var _ = require('../lodash'), + fs = require('fs'), + path = require('path'); + +var args = (args = process.argv) + .slice((args[0] === process.execPath || args[0] === 'node') ? 2 : 0); + +var filePath = path.resolve(args[1]), + reLine = /.*/gm; + +var pattern = (function() { + var result = args[0], + delimiter = result.charAt(0), + lastIndex = result.lastIndexOf(delimiter); + + return RegExp(result.slice(1, lastIndex), result.slice(lastIndex + 1)); +}()); + +/*----------------------------------------------------------------------------*/ + +fs.writeFileSync(filePath, fs.readFileSync(filePath, 'utf8').replace(pattern, function(match) { + var snippet = _.slice(arguments, -3, -2)[0]; + return match.replace(snippet, snippet.replace(reLine, '')); +})); diff --git a/test/run-test.sh b/test/run-test.sh deleted file mode 100644 index 70a41bc87c..0000000000 --- a/test/run-test.sh +++ /dev/null @@ -1,14 +0,0 @@ -cd "$(dirname "$0")" - -for cmd in rhino "rhino -require" narwhal ringo phantomjs; do - echo "Testing in $cmd..." - $cmd test.js ../dist/lodash.compat.js && $cmd test.js ../dist/lodash.compat.min.js - echo "" -done - -echo "Testing in node..." -node test.js ../dist/lodash.js && node test.js ../dist/lodash.min.js - -echo "" -echo "Testing in a browser..." -open index.html diff --git a/test/saucelabs.js b/test/saucelabs.js index ea80422834..5bc6f7bc3e 100644 --- a/test/saucelabs.js +++ b/test/saucelabs.js @@ -1,353 +1,908 @@ -;(function() { - 'use strict'; - - /** Environment shortcut */ - var env = process.env; - - if (isFinite(env.TRAVIS_PULL_REQUEST)) { - console.error('Testing skipped for pull requests'); - process.exit(0); - } - - /** Load Node.js modules */ - var http = require('http'), - path = require('path'), - url = require('url'); - - /** Load other modules */ - var _ = require('../lodash.js'), - ecstatic = require('ecstatic'), - request = require('request'), - SauceTunnel = require('sauce-tunnel'); - - /** Used by `logInline` to clear previously logged messages */ - var prevLine = ''; - - /** Used to display the wait throbber */ - var throbberId, - throbberDelay = 500, - waitCount = -1; - - /** Used as request `auth` and `options` values */ - var accessKey = env.SAUCE_ACCESS_KEY, - build = env.TRAVIS_COMMIT.slice(0, 10), - port = 9001, - tunnelId = 'lodash_' + env.TRAVIS_JOB_NUMBER, - username = env.SAUCE_USERNAME; - - var compatMode = process.argv.reduce(function(result, value) { - return optionToValue('compatMode', value) || result; - }, null); - - var runner = process.argv.reduce(function(result, value) { - value = optionToValue('runner', value); - return value == null - ? result - : '/' + value.replace(/^\W+/, ''); - }, '/test/index.html'); - - var sessionName = process.argv.reduce(function(result, value) { - return optionToValue('name', value) || result; - }, 'lodash tests'); - - var tags = process.argv.reduce(function(result, value) { - value = optionToArray('tags', value); - return value.length - ? _.union(result, value) - : result; - }, []); - - /** List of platforms to load the runner on */ - var platforms = [ - ['Windows 8.1', 'chrome', '31'], - ['Windows 8.1', 'chrome', '28'], - ['Windows 8.1', 'chrome', '26'], - ['OS X 10.6', 'firefox', '25'], - ['OS X 10.6', 'firefox', '20'], - ['OS X 10.6', 'firefox', '10'], - ['OS X 10.6', 'firefox', '6'], - ['OS X 10.6', 'firefox', '4'], - ['Windows 7', 'firefox', '3.6'], - ['Windows 8.1', 'internet explorer', '11'], +#!/usr/bin/env node +'use strict'; + +/** Environment shortcut. */ +var env = process.env; + +/** Load Node.js modules. */ +var EventEmitter = require('events').EventEmitter, + http = require('http'), + path = require('path'), + url = require('url'), + util = require('util'); + +/** Load other modules. */ +var _ = require('../lodash.js'), + chalk = require('chalk'), + ecstatic = require('ecstatic'), + request = require('request'), + SauceTunnel = require('sauce-tunnel'); + +/** Used for Sauce Labs credentials. */ +var accessKey = env.SAUCE_ACCESS_KEY, + username = env.SAUCE_USERNAME; + +/** Used as the default maximum number of times to retry a job and tunnel. */ +var maxJobRetries = 3, + maxTunnelRetries = 3; + +/** Used as the static file server middleware. */ +var mount = ecstatic({ + 'cache': 'no-cache', + 'root': process.cwd() +}); + +/** Used as the list of ports supported by Sauce Connect. */ +var ports = [ + 80, 443, 888, 2000, 2001, 2020, 2109, 2222, 2310, 3000, 3001, 3030, 3210, + 3333, 4000, 4001, 4040, 4321, 4502, 4503, 4567, 5000, 5001, 5050, 5555, 5432, + 6000, 6001, 6060, 6666, 6543, 7000, 7070, 7774, 7777, 8000, 8001, 8003, 8031, + 8080, 8081, 8765, 8777, 8888, 9000, 9001, 9080, 9090, 9876, 9877, 9999, 49221, + 55001 +]; + +/** Used by `logInline` to clear previously logged messages. */ +var prevLine = ''; + +/** Method shortcut. */ +var push = Array.prototype.push; + +/** Used to detect error messages. */ +var reError = /(?:\be|E)rror\b/; + +/** Used to detect valid job ids. */ +var reJobId = /^[a-z0-9]{32}$/; + +/** Used to display the wait throbber. */ +var throbberDelay = 500, + waitCount = -1; + +/** + * Used as Sauce Labs config values. + * See the [Sauce Labs documentation](https://docs.saucelabs.com/reference/test-configuration/) + * for more details. + */ +var advisor = getOption('advisor', false), + build = getOption('build', (env.TRAVIS_COMMIT || '').slice(0, 10)), + commandTimeout = getOption('commandTimeout', 90), + compatMode = getOption('compatMode', null), + customData = Function('return {' + getOption('customData', '').replace(/^\{|}$/g, '') + '}')(), + deviceOrientation = getOption('deviceOrientation', 'portrait'), + framework = getOption('framework', 'qunit'), + idleTimeout = getOption('idleTimeout', 60), + jobName = getOption('name', 'unit tests'), + maxDuration = getOption('maxDuration', 180), + port = ports[Math.min(_.sortedIndex(ports, getOption('port', 9001)), ports.length - 1)], + publicAccess = getOption('public', true), + queueTimeout = getOption('queueTimeout', 240), + recordVideo = getOption('recordVideo', true), + recordScreenshots = getOption('recordScreenshots', false), + runner = getOption('runner', 'test/index.html').replace(/^\W+/, ''), + runnerUrl = getOption('runnerUrl', 'http://localhost:' + port + '/' + runner), + statusInterval = getOption('statusInterval', 5), + tags = getOption('tags', []), + throttled = getOption('throttled', 10), + tunneled = getOption('tunneled', true), + tunnelId = getOption('tunnelId', 'tunnel_' + (env.TRAVIS_JOB_ID || 0)), + tunnelTimeout = getOption('tunnelTimeout', 120), + videoUploadOnPass = getOption('videoUploadOnPass', false); + +/** Used to convert Sauce Labs browser identifiers to their formal names. */ +var browserNameMap = { + 'googlechrome': 'Chrome', + 'iehta': 'Internet Explorer', + 'ipad': 'iPad', + 'iphone': 'iPhone', + 'microsoftedge': 'Edge' +}; + +/** List of platforms to load the runner on. */ +var platforms = [ + ['Linux', 'android', '5.1'], + ['Windows 10', 'chrome', '54'], + ['Windows 10', 'chrome', '53'], + ['Windows 10', 'firefox', '50'], + ['Windows 10', 'firefox', '49'], + ['Windows 10', 'microsoftedge', '14'], + ['Windows 10', 'internet explorer', '11'], + ['Windows 8', 'internet explorer', '10'], + ['Windows 7', 'internet explorer', '9'], + ['macOS 10.12', 'safari', '10'], + ['OS X 10.11', 'safari', '9'] +]; + +/** Used to tailor the `platforms` array. */ +var isAMD = _.includes(tags, 'amd'), + isBackbone = _.includes(tags, 'backbone'), + isModern = _.includes(tags, 'modern'); + +// The platforms to test IE compatibility modes. +if (compatMode) { + platforms = [ + ['Windows 10', 'internet explorer', '11'], ['Windows 8', 'internet explorer', '10'], ['Windows 7', 'internet explorer', '9'], - ['Windows 7', 'internet explorer', '8'], - ['Windows XP', 'internet explorer', '7'], - ['Windows XP', 'internet explorer', '6'], - //['Windows 7', 'opera', '12'], - //['Windows 7', 'opera', '11'], - ['OS X 10.8', 'safari', '6'], - ['Windows 7', 'safari', '5'], - ['Windows XP', 'safari', '4'] + ['Windows 7', 'internet explorer', '8'] ]; - - /** Used to tailor the `platforms` array */ - var runnerQuery = url.parse(runner, true).query, - isBackbone = /\bbackbone\b/i.test(runner), - isMobile = /\bmobile\b/i.test(runnerQuery.build), - isModern = /\bmodern\b/i.test(runnerQuery.build); - - // platforms to test IE compat mode - if (compatMode) { - platforms = [ - ['Windows 8.1', 'internet explorer', '11'], - ['Windows 8', 'internet explorer', '10'], - ['Windows 7', 'internet explorer', '9'], - ['Windows 7', 'internet explorer', '8'] - ]; +} +// The platforms for AMD tests. +if (isAMD) { + platforms = _.filter(platforms, function(platform) { + var browser = browserName(platform[1]), + version = +platform[2]; + + switch (browser) { + case 'Android': return version >= 4.4; + case 'Opera': return version >= 10; + } + return true; + }); +} +// The platforms for Backbone tests. +if (isBackbone) { + platforms = _.filter(platforms, function(platform) { + var browser = browserName(platform[1]), + version = +platform[2]; + + switch (browser) { + case 'Firefox': return version >= 4; + case 'Internet Explorer': return version >= 7; + case 'iPad': return version >= 5; + case 'Opera': return version >= 12; + } + return true; + }); +} +// The platforms for modern builds. +if (isModern) { + platforms = _.filter(platforms, function(platform) { + var browser = browserName(platform[1]), + version = +platform[2]; + + switch (browser) { + case 'Android': return version >= 4.1; + case 'Firefox': return version >= 10; + case 'Internet Explorer': return version >= 9; + case 'iPad': return version >= 6; + case 'Opera': return version >= 12; + case 'Safari': return version >= 6; + } + return true; + }); +} + +/** Used as the default `Job` options object. */ +var jobOptions = { + 'build': build, + 'command-timeout': commandTimeout, + 'custom-data': customData, + 'device-orientation': deviceOrientation, + 'framework': framework, + 'idle-timeout': idleTimeout, + 'max-duration': maxDuration, + 'name': jobName, + 'public': publicAccess, + 'platforms': platforms, + 'record-screenshots': recordScreenshots, + 'record-video': recordVideo, + 'sauce-advisor': advisor, + 'tags': tags, + 'url': runnerUrl, + 'video-upload-on-pass': videoUploadOnPass +}; + +if (publicAccess === true) { + jobOptions['public'] = 'public'; +} +if (tunneled) { + jobOptions['tunnel-identifier'] = tunnelId; +} + +/*----------------------------------------------------------------------------*/ + +/** + * Resolves the formal browser name for a given Sauce Labs browser identifier. + * + * @private + * @param {string} identifier The browser identifier. + * @returns {string} Returns the formal browser name. + */ +function browserName(identifier) { + return browserNameMap[identifier] || _.startCase(identifier); +} + +/** + * Gets the value for the given option name. If no value is available the + * `defaultValue` is returned. + * + * @private + * @param {string} name The name of the option. + * @param {*} defaultValue The default option value. + * @returns {*} Returns the option value. + */ +function getOption(name, defaultValue) { + var isArr = _.isArray(defaultValue); + return _.reduce(process.argv, function(result, value) { + if (isArr) { + value = optionToArray(name, value); + return _.isEmpty(value) ? result : value; + } + value = optionToValue(name, value); + + return value == null ? result : value; + }, defaultValue); +} + +/** + * Checks if `value` is a job ID. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a job ID, else `false`. + */ +function isJobId(value) { + return reJobId.test(value); +} + +/** + * Writes an inline message to standard output. + * + * @private + * @param {string} [text=''] The text to log. + */ +function logInline(text) { + var blankLine = _.repeat(' ', _.size(prevLine)); + prevLine = text = _.truncate(text, { 'length': 40 }); + process.stdout.write(text + blankLine.slice(text.length) + '\r'); +} + +/** + * Writes the wait throbber to standard output. + * + * @private + */ +function logThrobber() { + logInline('Please wait' + _.repeat('.', (++waitCount % 3) + 1)); +} + +/** + * Converts a comma separated option value into an array. + * + * @private + * @param {string} name The name of the option to inspect. + * @param {string} string The options string. + * @returns {Array} Returns the new converted array. + */ +function optionToArray(name, string) { + return _.compact(_.invokeMap((optionToValue(name, string) || '').split(/, */), 'trim')); +} + +/** + * Extracts the option value from an option string. + * + * @private + * @param {string} name The name of the option to inspect. + * @param {string} string The options string. + * @returns {string|undefined} Returns the option value, else `undefined`. + */ +function optionToValue(name, string) { + var result = string.match(RegExp('^' + name + '(?:=([\\s\\S]+))?$')); + if (result) { + result = _.get(result, 1); + result = result ? _.trim(result) : true; } - // platforms for Backbone tests - if (isBackbone) { - platforms = platforms.filter(function(platform) { - var browser = platform[1], - version = +platform[2]; - - switch (browser) { - case 'firefox': return version >= 4; - case 'opera': return version >= 12; - } - return true; - }); + if (result === 'false') { + return false; } - // platforms for mobile and modern builds - if (isMobile || isModern) { - platforms = platforms.filter(function(platform) { - var browser = platform[1], - version = +platform[2]; - - switch (browser) { - case 'firefox': return version >= 10; - case 'internet explorer': return version >= 9; - case 'opera': return version >= 12; - case 'safari': return version >= (isMobile ? 3 : 6); - } - return true; - }); + return result || undefined; +} + +/*----------------------------------------------------------------------------*/ + +/** + * The `Job#remove` and `Tunnel#stop` callback used by `Jobs#restart` + * and `Tunnel#restart` respectively. + * + * @private + */ +function onGenericRestart() { + this.restarting = false; + this.emit('restart'); + this.start(); +} + +/** + * The `request.put` and `SauceTunnel#stop` callback used by `Jobs#stop` + * and `Tunnel#stop` respectively. + * + * @private + * @param {Object} [error] The error object. + */ +function onGenericStop(error) { + this.running = this.stopping = false; + this.emit('stop', error); +} + +/** + * The `request.del` callback used by `Jobs#remove`. + * + * @private + */ +function onJobRemove(error, res, body) { + this.id = this.taskId = this.url = null; + this.removing = false; + this.emit('remove'); +} + +/** + * The `Job#remove` callback used by `Jobs#reset`. + * + * @private + */ +function onJobReset() { + this.attempts = 0; + this.failed = this.resetting = false; + this._pollerId = this.id = this.result = this.taskId = this.url = null; + this.emit('reset'); +} + +/** + * The `request.post` callback used by `Jobs#start`. + * + * @private + * @param {Object} [error] The error object. + * @param {Object} res The response data object. + * @param {Object} body The response body JSON object. + */ +function onJobStart(error, res, body) { + this.starting = false; + + if (this.stopping) { + return; } + var statusCode = _.get(res, 'statusCode'), + taskId = _.first(_.get(body, 'js tests')); - /*--------------------------------------------------------------------------*/ - - /** - * Writes an inline message to standard output. - * - * @private - * @param {string} text The text to log. - */ - function logInline(text) { - var blankLine = repeat(' ', prevLine.length); - if (text.length > 40) { - text = text.slice(0, 37) + '...'; + if (error || !taskId || statusCode != 200) { + if (this.attempts < this.retries) { + this.restart(); + return; + } + var na = 'unavailable', + bodyStr = _.isObject(body) ? '\n' + JSON.stringify(body) : na, + statusStr = _.isFinite(statusCode) ? statusCode : na; + + logInline(); + console.error('Failed to start job; status: %s, body: %s', statusStr, bodyStr); + if (error) { + console.error(error); } - prevLine = text; - process.stdout.write(text + blankLine.slice(text.length) + '\r'); + this.failed = true; + this.emit('complete'); + return; } - - /** - * Writes the wait throbber to standard output. - * - * @private - */ - function logThrobber() { - logInline('Please wait' + repeat('.', (++waitCount % 3) + 1)); + this.running = true; + this.taskId = taskId; + this.timestamp = _.now(); + this.emit('start'); + this.status(); +} + +/** + * The `request.post` callback used by `Job#status`. + * + * @private + * @param {Object} [error] The error object. + * @param {Object} res The response data object. + * @param {Object} body The response body JSON object. + */ +function onJobStatus(error, res, body) { + this.checking = false; + + if (!this.running || this.stopping) { + return; } - - /** - * Converts a comma separated option value into an array. - * - * @private - * @param {string} name The name of the option to inspect. - * @param {string} string The options string. - * @returns {Array} Returns the new converted array. - */ - function optionToArray(name, string) { - return _.compact(_.isArray(string) - ? string - : _.invoke((optionToValue(name, string) || '').split(/, */), 'trim') - ); + var completed = _.get(body, 'completed', false), + data = _.first(_.get(body, 'js tests')), + elapsed = (_.now() - this.timestamp) / 1000, + jobId = _.get(data, 'job_id', null), + jobResult = _.get(data, 'result', null), + jobStatus = _.get(data, 'status', ''), + jobUrl = _.get(data, 'url', null), + expired = (elapsed >= queueTimeout && !_.includes(jobStatus, 'in progress')), + options = this.options, + platform = options.platforms[0]; + + if (_.isObject(jobResult)) { + var message = _.get(jobResult, 'message'); + } else { + if (typeof jobResult == 'string') { + message = jobResult; + } + jobResult = null; } - - /** - * Extracts the option value from an option string. - * - * @private - * @param {string} name The name of the option to inspect. - * @param {string} string The options string. - * @returns {string|undefined} Returns the option value, else `undefined`. - */ - function optionToValue(name, string) { - var result = (result = string.match(RegExp('^' + name + '=([\\s\\S]+)$'))) && result[1].trim(); - return result || undefined; + if (isJobId(jobId)) { + this.id = jobId; + this.result = jobResult; + this.url = jobUrl; + } else { + completed = false; } + this.emit('status', jobStatus); - /** - * Creates a string with `text` repeated `n` number of times. - * - * @private - * @param {string} text The text to repeat. - * @param {number} n The number of times to repeat `text`. - * @returns {string} The created string. - */ - function repeat(text, n) { - return Array(n + 1).join(text); + if (!completed && !expired) { + this._pollerId = _.delay(_.bind(this.status, this), this.statusInterval * 1000); + return; } + var description = browserName(platform[1]) + ' ' + platform[2] + ' on ' + _.startCase(platform[0]), + errored = !jobResult || !jobResult.passed || reError.test(message) || reError.test(jobStatus), + failures = _.get(jobResult, 'failed'), + label = options.name + ':', + tunnel = this.tunnel; + + if (errored || failures) { + if (errored && this.attempts < this.retries) { + this.restart(); + return; + } + var details = 'See ' + jobUrl + ' for details.'; + this.failed = true; - /*--------------------------------------------------------------------------*/ - - /** - * Processes the result object of the test session. - * - * @private - * @param {Object} results The result object to process. - */ - function handleTestResults(results) { - var failingTests = results.filter(function(test) { - var result = test.result; - return !result || result.failed || /\berror\b/i.test(result.message); - }); - - var failingPlatforms = failingTests.map(function(test) { - return test.platform; - }); - - if (!failingTests.length) { - console.log('Tests passed'); + logInline(); + if (failures) { + console.error(label + ' %s ' + chalk.red('failed') + ' %d test' + (failures > 1 ? 's' : '') + '. %s', description, failures, details); + } + else if (tunnel.attempts < tunnel.retries) { + tunnel.restart(); + return; } else { - console.error('Tests failed on platforms: ' + JSON.stringify(failingPlatforms)); - - failingTests.forEach(function(test) { - var result = test.result || {}, - details = 'See ' + test.url + ' for details.', - failed = result.failed, - platform = JSON.stringify(test.platform); - - if (failed) { - console.error(failed + ' failures on ' + platform + '. ' + details); - } else { - var message = result.message || 'no results available. ' + details; - console.error('Testing on ' + platform + ' failed; ' + message); - } - }); + if (message === undefined) { + message = 'Results are unavailable. ' + details; + } + console.error(label, description, chalk.red('failed') + ';', message); + } + } + else { + logInline(); + console.log(label, description, chalk.green('passed')); + } + this.running = false; + this.emit('complete'); +} + +/** + * The `SauceTunnel#start` callback used by `Tunnel#start`. + * + * @private + * @param {boolean} success The connection success indicator. + */ +function onTunnelStart(success) { + this.starting = false; + + if (this._timeoutId) { + clearTimeout(this._timeoutId); + this._timeoutId = null; + } + if (!success) { + if (this.attempts < this.retries) { + this.restart(); + return; } + logInline(); + console.error('Failed to open Sauce Connect tunnel'); + process.exit(2); + } + logInline(); + console.log('Sauce Connect tunnel opened'); + + var jobs = this.jobs; + push.apply(jobs.queue, jobs.all); + + this.running = true; + this.emit('start'); + + console.log('Starting jobs...'); + this.dequeue(); +} + +/*----------------------------------------------------------------------------*/ + +/** + * The Job constructor. + * + * @private + * @param {Object} [properties] The properties to initialize a job with. + */ +function Job(properties) { + EventEmitter.call(this); + + this.options = {}; + _.merge(this, properties); + _.defaults(this.options, _.cloneDeep(jobOptions)); + + this.attempts = 0; + this.checking = this.failed = this.removing = this.resetting = this.restarting = this.running = this.starting = this.stopping = false; + this._pollerId = this.id = this.result = this.taskId = this.url = null; +} + +util.inherits(Job, EventEmitter); + +/** + * Removes the job. + * + * @memberOf Job + * @param {Function} callback The function called once the job is removed. + * @param {Object} Returns the job instance. + */ +Job.prototype.remove = function(callback) { + this.once('remove', _.iteratee(callback)); + if (this.removing) { + return this; + } + this.removing = true; + return this.stop(function() { + var onRemove = _.bind(onJobRemove, this); + if (!this.id) { + _.defer(onRemove); + return; + } + request.del(_.template('https://saucelabs.com/rest/v1/${user}/jobs/${id}')(this), { + 'auth': { 'user': this.user, 'pass': this.pass } + }, onRemove); + }); +}; + +/** + * Resets the job. + * + * @memberOf Job + * @param {Function} callback The function called once the job is reset. + * @param {Object} Returns the job instance. + */ +Job.prototype.reset = function(callback) { + this.once('reset', _.iteratee(callback)); + if (this.resetting) { + return this; + } + this.resetting = true; + return this.remove(onJobReset); +}; + +/** + * Restarts the job. + * + * @memberOf Job + * @param {Function} callback The function called once the job is restarted. + * @param {Object} Returns the job instance. + */ +Job.prototype.restart = function(callback) { + this.once('restart', _.iteratee(callback)); + if (this.restarting) { + return this; + } + this.restarting = true; + + var options = this.options, + platform = options.platforms[0], + description = browserName(platform[1]) + ' ' + platform[2] + ' on ' + _.startCase(platform[0]), + label = options.name + ':'; + + logInline(); + console.log('%s %s restart %d of %d', label, description, ++this.attempts, this.retries); + + return this.remove(onGenericRestart); +}; + +/** + * Starts the job. + * + * @memberOf Job + * @param {Function} callback The function called once the job is started. + * @param {Object} Returns the job instance. + */ +Job.prototype.start = function(callback) { + this.once('start', _.iteratee(callback)); + if (this.starting || this.running) { + return this; + } + this.starting = true; + request.post(_.template('https://saucelabs.com/rest/v1/${user}/js-tests')(this), { + 'auth': { 'user': this.user, 'pass': this.pass }, + 'json': this.options + }, _.bind(onJobStart, this)); + + return this; +}; + +/** + * Checks the status of a job. + * + * @memberOf Job + * @param {Function} callback The function called once the status is resolved. + * @param {Object} Returns the job instance. + */ +Job.prototype.status = function(callback) { + this.once('status', _.iteratee(callback)); + if (this.checking || this.removing || this.resetting || this.restarting || this.starting || this.stopping) { + return this; + } + this._pollerId = null; + this.checking = true; + request.post(_.template('https://saucelabs.com/rest/v1/${user}/js-tests/status')(this), { + 'auth': { 'user': this.user, 'pass': this.pass }, + 'json': { 'js tests': [this.taskId] } + }, _.bind(onJobStatus, this)); + + return this; +}; + +/** + * Stops the job. + * + * @memberOf Job + * @param {Function} callback The function called once the job is stopped. + * @param {Object} Returns the job instance. + */ +Job.prototype.stop = function(callback) { + this.once('stop', _.iteratee(callback)); + if (this.stopping) { + return this; + } + this.stopping = true; + if (this._pollerId) { + clearTimeout(this._pollerId); + this._pollerId = null; + this.checking = false; + } + var onStop = _.bind(onGenericStop, this); + if (!this.running || !this.id) { + _.defer(onStop); + return this; + } + request.put(_.template('https://saucelabs.com/rest/v1/${user}/jobs/${id}/stop')(this), { + 'auth': { 'user': this.user, 'pass': this.pass } + }, onStop); + + return this; +}; + +/*----------------------------------------------------------------------------*/ + +/** + * The Tunnel constructor. + * + * @private + * @param {Object} [properties] The properties to initialize the tunnel with. + */ +function Tunnel(properties) { + EventEmitter.call(this); + + _.merge(this, properties); + + var active = [], + queue = []; + + var all = _.map(this.platforms, _.bind(function(platform) { + return new Job(_.merge({ + 'user': this.user, + 'pass': this.pass, + 'tunnel': this, + 'options': { 'platforms': [platform] } + }, this.job)); + }, this)); + + var completed = 0, + restarted = [], + success = true, + total = all.length, + tunnel = this; + + _.invokeMap(all, 'on', 'complete', function() { + _.pull(active, this); + if (success) { + success = !this.failed; + } + if (++completed == total) { + tunnel.stop(_.partial(tunnel.emit, 'complete', success)); + return; + } + tunnel.dequeue(); + }); - clearInterval(throbberId); - console.log('Shutting down Sauce Connect tunnel...'); + _.invokeMap(all, 'on', 'restart', function() { + if (!_.includes(restarted, this)) { + restarted.push(this); + } + // Restart tunnel if all active jobs have restarted. + var threshold = Math.min(all.length, _.isFinite(throttled) ? throttled : 3); + if (tunnel.attempts < tunnel.retries && + active.length >= threshold && _.isEmpty(_.difference(active, restarted))) { + tunnel.restart(); + } + }); + + this.on('restart', function() { + completed = 0; + success = true; + restarted.length = 0; + }); - tunnel.stop(function() { - process.exit(failingTests.length ? 1 : 0); - }); + this._timeoutId = null; + this.attempts = 0; + this.restarting = this.running = this.starting = this.stopping = false; + this.jobs = { 'active': active, 'all': all, 'queue': queue }; + this.connection = new SauceTunnel(this.user, this.pass, this.id, this.tunneled, ['-P', '0']); +} + +util.inherits(Tunnel, EventEmitter); + +/** + * Restarts the tunnel. + * + * @memberOf Tunnel + * @param {Function} callback The function called once the tunnel is restarted. + */ +Tunnel.prototype.restart = function(callback) { + this.once('restart', _.iteratee(callback)); + if (this.restarting) { + return this; } + this.restarting = true; - /** - * Makes a request for Sauce Labs to start the test session. - * - * @private - */ - function runTests() { - var options = { - 'build': build, - 'framework': 'qunit', - 'idle-timeout': 300, - 'max-duration': 600, - 'name': sessionName, - 'public': 'public', - 'platforms': platforms, - 'record-screenshots': false, - 'tags': tags, - 'tunnel': 'tunnel-identifier:' + tunnelId, - 'url': 'http://localhost:' + port + runner, - 'video-upload-on-pass': false - }; - - console.log('Starting saucelabs tests: ' + JSON.stringify(options)); - - request.post('https://saucelabs.com/rest/v1/' + username + '/js-tests', { - 'auth': { 'user': username, 'pass': accessKey }, - 'json': options - }, function(error, response, body) { - var statusCode = response && response.statusCode; - if (statusCode == 200) { - waitForTestCompletion(body); - } else { - console.error('Failed to submit test to Sauce Labs; status: ' + statusCode + ', body:\n' + JSON.stringify(body)); - if (error) { - console.error(error); - } - process.exit(3); - } - }); + logInline(); + console.log('Tunnel %s: restart %d of %d', this.id, ++this.attempts, this.retries); - // initialize the wait throbber - if (!throbberId) { - throbberId = setInterval(logThrobber, throbberDelay); - logThrobber(); - } - } + var jobs = this.jobs, + active = jobs.active, + all = jobs.all; - /** - * Checks the status of the test session. If the session has completed it - * passes the result object to `handleTestResults`, else it checks the status - * again in five seconds. - * - * @private - * @param {Object} testIdentifier The object used to identify the session. - */ - function waitForTestCompletion(testIdentifier) { - request.post('https://saucelabs.com/rest/v1/' + username + '/js-tests/status', { - 'auth': { 'user': username, 'pass': accessKey }, - 'json': testIdentifier - }, function(error, response, body) { - var statusCode = response && response.statusCode; - if (statusCode == 200) { - if (body.completed) { - logInline(''); - handleTestResults(body['js tests']); - } - else { - setTimeout(function() { - waitForTestCompletion(testIdentifier); - }, 5000); - } - } else { - logInline(''); - console.error('Failed to check test status on Sauce Labs; status: ' + statusCode + ', body:\n' + JSON.stringify(body)); - if (error) { - console.error(error); - } - process.exit(4); - } - }); + var reset = _.after(all.length, _.bind(this.stop, this, onGenericRestart)), + stop = _.after(active.length, _.partial(_.invokeMap, all, 'reset', reset)); + + if (_.isEmpty(active)) { + _.defer(stop); + } + if (_.isEmpty(all)) { + _.defer(reset); } + _.invokeMap(active, 'stop', function() { + _.pull(active, this); + stop(); + }); - /*--------------------------------------------------------------------------*/ + if (this._timeoutId) { + clearTimeout(this._timeoutId); + this._timeoutId = null; + } + return this; +}; + +/** + * Starts the tunnel. + * + * @memberOf Tunnel + * @param {Function} callback The function called once the tunnel is started. + * @param {Object} Returns the tunnel instance. + */ +Tunnel.prototype.start = function(callback) { + this.once('start', _.iteratee(callback)); + if (this.starting || this.running) { + return this; + } + this.starting = true; - // create a web server for the local dir - var mount = ecstatic({ - 'cache': false, - 'root': process.cwd() - }); + logInline(); + console.log('Opening Sauce Connect tunnel...'); - http.createServer(function(req, res) { - // see http://msdn.microsoft.com/en-us/library/ff955275(v=vs.85).aspx - if (compatMode && path.extname(url.parse(req.url).pathname) == '.html') { - res.setHeader('X-UA-Compatible', 'IE=' + compatMode); - } - mount(req, res); - }).listen(port); + var onStart = _.bind(onTunnelStart, this); + if (this.timeout) { + this._timeoutId = _.delay(onStart, this.timeout * 1000, false); + } + this.connection.start(onStart); + return this; +}; + +/** + * Removes jobs from the queue and starts them. + * + * @memberOf Tunnel + * @param {Object} Returns the tunnel instance. + */ +Tunnel.prototype.dequeue = function() { + var count = 0, + jobs = this.jobs, + active = jobs.active, + queue = jobs.queue, + throttled = this.throttled; + + while (queue.length && (active.length < throttled)) { + var job = queue.shift(); + active.push(job); + _.delay(_.bind(job.start, job), ++count * 1000); + } + return this; +}; + +/** + * Stops the tunnel. + * + * @memberOf Tunnel + * @param {Function} callback The function called once the tunnel is stopped. + * @param {Object} Returns the tunnel instance. + */ +Tunnel.prototype.stop = function(callback) { + this.once('stop', _.iteratee(callback)); + if (this.stopping) { + return this; + } + this.stopping = true; - // set up Sauce Connect so we can use this server from Sauce Labs - var tunnelTimeout = 10000, - tunnel = new SauceTunnel(username, accessKey, tunnelId, true, tunnelTimeout); + logInline(); + console.log('Shutting down Sauce Connect tunnel...'); - console.log('Opening Sauce Connect tunnel...'); + var jobs = this.jobs, + active = jobs.active; - tunnel.start(function(success) { - if (success) { - console.log('Sauce Connect tunnel opened'); - runTests(); + var stop = _.after(active.length, _.bind(function() { + var onStop = _.bind(onGenericStop, this); + if (this.running) { + this.connection.stop(onStop); } else { - console.error('Failed to open Sauce Connect tunnel'); - process.exit(2); + onStop(); } + }, this)); + + jobs.queue.length = 0; + if (_.isEmpty(active)) { + _.defer(stop); + } + _.invokeMap(active, 'stop', function() { + _.pull(active, this); + stop(); }); -}()); + + if (this._timeoutId) { + clearTimeout(this._timeoutId); + this._timeoutId = null; + } + return this; +}; + +/*----------------------------------------------------------------------------*/ + +// Cleanup any inline logs when exited via `ctrl+c`. +process.on('SIGINT', function() { + logInline(); + process.exit(); +}); + +// Create a web server for the current working directory. +http.createServer(function(req, res) { + // See http://msdn.microsoft.com/en-us/library/ff955275(v=vs.85).aspx. + if (compatMode && path.extname(url.parse(req.url).pathname) == '.html') { + res.setHeader('X-UA-Compatible', 'IE=' + compatMode); + } + mount(req, res); +}).listen(port); + +// Setup Sauce Connect so we can use this server from Sauce Labs. +var tunnel = new Tunnel({ + 'user': username, + 'pass': accessKey, + 'id': tunnelId, + 'job': { 'retries': maxJobRetries, 'statusInterval': statusInterval }, + 'platforms': platforms, + 'retries': maxTunnelRetries, + 'throttled': throttled, + 'tunneled': tunneled, + 'timeout': tunnelTimeout +}); + +tunnel.on('complete', function(success) { + process.exit(success ? 0 : 1); +}); + +tunnel.start(); + +setInterval(logThrobber, throbberDelay); diff --git a/test/test-fp.js b/test/test-fp.js new file mode 100644 index 0000000000..f14adfa3a1 --- /dev/null +++ b/test/test-fp.js @@ -0,0 +1,2322 @@ +;(function() { + 'use strict'; + + /** Used as a safe reference for `undefined` in pre-ES5 environments. */ + var undefined; + + /** Used as the size to cover large array optimizations. */ + var LARGE_ARRAY_SIZE = 200; + + /** Used as a reference to the global object. */ + var root = (typeof global == 'object' && global) || this; + + /** Used for native method references. */ + var arrayProto = Array.prototype; + + /** Method and object shortcuts. */ + var phantom = root.phantom, + argv = root.process && process.argv, + document = !phantom && root.document, + slice = arrayProto.slice, + WeakMap = root.WeakMap; + + /** Math helpers. */ + var add = function(x, y) { return x + y; }, + isEven = function(n) { return n % 2 == 0; }, + isEvenIndex = function(n, index) { return isEven(index); }, + square = function(n) { return n * n; }; + + // Leak to avoid sporadic `noglobals` fails on Edge in Sauce Labs. + root.msWDfn = undefined; + + /*--------------------------------------------------------------------------*/ + + /** Load QUnit and extras. */ + var QUnit = root.QUnit || require('qunit-extras'); + + /** Load stable Lodash. */ + var _ = root._ || require('../lodash.js'); + + var convert = (function() { + var baseConvert = root.fp || require('../fp/_baseConvert.js'); + if (!root.fp) { + return function(name, func, options) { + return baseConvert(_, name, func, options); + }; + } + return function(name, func, options) { + if (typeof name == 'function') { + options = func; + func = name; + name = undefined; + } + return name === undefined + ? baseConvert(func, options) + : baseConvert(_.runInContext(), options)[name]; + }; + }()); + + var allFalseOptions = { + 'cap': false, + 'curry': false, + 'fixed': false, + 'immutable': false, + 'rearg': false + }; + + var fp = root.fp + ? (fp = _.noConflict(), _ = root._, fp) + : convert(_.runInContext()); + + var mapping = root.mapping || require('../fp/_mapping.js'); + + /*--------------------------------------------------------------------------*/ + + /** + * Skips a given number of tests with a passing result. + * + * @private + * @param {Object} assert The QUnit assert object. + * @param {number} [count=1] The number of tests to skip. + */ + function skipAssert(assert, count) { + count || (count = 1); + while (count--) { + assert.ok(true, 'test skipped'); + } + } + + /*--------------------------------------------------------------------------*/ + + if (argv) { + console.log('Running lodash/fp tests.'); + } + + QUnit.module('convert module'); + + (function() { + QUnit.test('should work with `name` and `func`', function(assert) { + assert.expect(2); + + var array = [1, 2, 3, 4], + remove = convert('remove', _.remove), + actual = remove(isEven)(array); + + assert.deepEqual(array, [1, 2, 3, 4]); + assert.deepEqual(actual, [1, 3]); + }); + + QUnit.test('should work with `name`, `func`, and `options`', function(assert) { + assert.expect(3); + + var array = [1, 2, 3, 4], + remove = convert('remove', _.remove, allFalseOptions); + + var actual = remove(array, function(n, index) { + return isEven(index); + }); + + assert.deepEqual(array, [2, 4]); + assert.deepEqual(actual, [1, 3]); + assert.deepEqual(remove(), []); + }); + + QUnit.test('should work with an object', function(assert) { + assert.expect(2); + + if (!document) { + var array = [1, 2, 3, 4], + lodash = convert({ 'remove': _.remove }), + actual = lodash.remove(isEven)(array); + + assert.deepEqual(array, [1, 2, 3, 4]); + assert.deepEqual(actual, [1, 3]); + } + else { + skipAssert(assert, 2); + } + }); + + QUnit.test('should work with an object and `options`', function(assert) { + assert.expect(3); + + if (!document) { + var array = [1, 2, 3, 4], + lodash = convert({ 'remove': _.remove }, allFalseOptions), + actual = lodash.remove(array, isEvenIndex); + + assert.deepEqual(array, [2, 4]); + assert.deepEqual(actual, [1, 3]); + assert.deepEqual(lodash.remove(), []); + } + else { + skipAssert(assert, 3); + } + }); + + QUnit.test('should work with lodash and `options`', function(assert) { + assert.expect(3); + + var array = [1, 2, 3, 4], + lodash = convert(_.runInContext(), allFalseOptions), + actual = lodash.remove(array, isEvenIndex); + + assert.deepEqual(array, [2, 4]); + assert.deepEqual(actual, [1, 3]); + assert.deepEqual(lodash.remove(), []); + }); + + QUnit.test('should work with `runInContext` and `options`', function(assert) { + assert.expect(3); + + var array = [1, 2, 3, 4], + runInContext = convert('runInContext', _.runInContext, allFalseOptions), + lodash = runInContext(), + actual = lodash.remove(array, isEvenIndex); + + assert.deepEqual(array, [2, 4]); + assert.deepEqual(actual, [1, 3]); + assert.deepEqual(lodash.remove(), []); + }); + + QUnit.test('should accept a variety of options', function(assert) { + assert.expect(8); + + var array = [1, 2, 3, 4], + value = _.clone(array), + remove = convert('remove', _.remove, { 'cap': false }), + actual = remove(isEvenIndex)(value); + + assert.deepEqual(value, [1, 2, 3, 4]); + assert.deepEqual(actual, [2, 4]); + + remove = convert('remove', _.remove, { 'curry': false }); + actual = remove(isEven); + + assert.deepEqual(actual, []); + + var trim = convert('trim', _.trim, { 'fixed': false }); + assert.strictEqual(trim('_-abc-_', '_-'), 'abc'); + + value = _.clone(array); + remove = convert('remove', _.remove, { 'immutable': false }); + actual = remove(isEven)(value); + + assert.deepEqual(value, [1, 3]); + assert.deepEqual(actual, [2, 4]); + + value = _.clone(array); + remove = convert('remove', _.remove, { 'rearg': false }); + actual = remove(value)(isEven); + + assert.deepEqual(value, [1, 2, 3, 4]); + assert.deepEqual(actual, [1, 3]); + }); + + QUnit.test('should respect the `cap` option', function(assert) { + assert.expect(1); + + var iteratee = convert('iteratee', _.iteratee, { 'cap': false }); + + var func = iteratee(function(a, b, c) { + return [a, b, c]; + }, 3); + + assert.deepEqual(func(1, 2, 3), [1, 2, 3]); + }); + + QUnit.test('should respect the `rearg` option', function(assert) { + assert.expect(1); + + var add = convert('add', _.add, { 'rearg': true }); + + assert.strictEqual(add('2')('1'), '12'); + }); + + QUnit.test('should add a `placeholder` property', function(assert) { + assert.expect(2); + + if (!document) { + var lodash = convert({ 'add': _.add }); + + assert.strictEqual(lodash.placeholder, lodash); + assert.strictEqual(lodash.add.placeholder, lodash); + } + else { + skipAssert(assert, 2); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('method.convert'); + + (function() { + QUnit.test('should exist on unconverted methods', function(assert) { + assert.expect(2); + + var array = [], + isArray = fp.isArray.convert({ 'curry': true }); + + assert.strictEqual(fp.isArray(array), true); + assert.strictEqual(isArray()(array), true); + }); + + QUnit.test('should convert method aliases', function(assert) { + assert.expect(1); + + var all = fp.all.convert({ 'rearg': false }), + actual = all([0])(_.identity); + + assert.strictEqual(actual, false); + }); + + QUnit.test('should convert remapped methods', function(assert) { + assert.expect(1); + + var extendAll = fp.extendAll.convert({ 'immutable': false }), + object = {}; + + extendAll([object, { 'a': 1 }, { 'b': 2 }]); + assert.deepEqual(object, { 'a': 1, 'b': 2 }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('convert methods'); + + _.each(['fp.convert', 'method.convert'], function(methodName) { + var isFp = methodName == 'fp.convert', + func = isFp ? fp.convert : fp.remove.convert; + + QUnit.test('`' + methodName + '` should work with an object', function(assert) { + assert.expect(3); + + var array = [1, 2, 3, 4], + lodash = func(allFalseOptions), + remove = isFp ? lodash.remove : lodash, + actual = remove(array, isEvenIndex); + + assert.deepEqual(array, [2, 4]); + assert.deepEqual(actual, [1, 3]); + assert.deepEqual(remove(), []); + }); + + QUnit.test('`' + methodName + '` should extend existing configs', function(assert) { + assert.expect(2); + + var array = [1, 2, 3, 4], + lodash = func({ 'cap': false }), + remove = (isFp ? lodash.remove : lodash).convert({ 'rearg': false }), + actual = remove(array)(isEvenIndex); + + assert.deepEqual(array, [1, 2, 3, 4]); + assert.deepEqual(actual, [2, 4]); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('method arity checks'); + + (function() { + QUnit.test('should wrap methods with an arity > `1`', function(assert) { + assert.expect(1); + + var methodNames = _.filter(_.functions(fp), function(methodName) { + return fp[methodName].length > 1; + }); + + assert.deepEqual(methodNames, []); + }); + + QUnit.test('should have >= arity of `aryMethod` designation', function(assert) { + assert.expect(4); + + _.times(4, function(index) { + var aryCap = index + 1; + + var methodNames = _.filter(mapping.aryMethod[aryCap], function(methodName) { + var key = _.get(mapping.remap, methodName, methodName), + arity = _[key].length; + + return arity != 0 && arity < aryCap; + }); + + assert.deepEqual(methodNames, [], '`aryMethod[' + aryCap + ']`'); + }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('method aliases'); + + (function() { + QUnit.test('should have correct aliases', function(assert) { + assert.expect(1); + + var actual = _.transform(mapping.aliasToReal, function(result, realName, alias) { + result.push([alias, fp[alias] === fp[realName]]); + }, []); + + assert.deepEqual(_.reject(actual, 1), []); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('method ary caps'); + + (function() { + QUnit.test('should have a cap of 1', function(assert) { + assert.expect(1); + + var funcMethods = [ + 'curry', 'iteratee', 'memoize', 'over', 'overEvery', 'overSome', + 'method', 'methodOf', 'rest', 'runInContext' + ]; + + var exceptions = funcMethods.concat('mixin', 'nthArg', 'template'), + expected = _.map(mapping.aryMethod[1], _.constant(true)); + + var actual = _.map(mapping.aryMethod[1], function(methodName) { + var arg = _.includes(funcMethods, methodName) ? _.noop : 1, + result = _.attempt(function() { return fp[methodName](arg); }); + + if (_.includes(exceptions, methodName) + ? typeof result == 'function' + : typeof result != 'function' + ) { + return true; + } + console.log(methodName, result); + return false; + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should have a cap of 2', function(assert) { + assert.expect(1); + + var funcMethods = [ + 'after', 'ary', 'before', 'bind', 'bindKey', 'curryN', 'debounce', + 'delay', 'overArgs', 'partial', 'partialRight', 'rearg', 'throttle', + 'wrap' + ]; + + var exceptions = _.without(funcMethods.concat('matchesProperty'), 'delay'), + expected = _.map(mapping.aryMethod[2], _.constant(true)); + + var actual = _.map(mapping.aryMethod[2], function(methodName) { + var args = _.includes(funcMethods, methodName) ? [methodName == 'curryN' ? 1 : _.noop, _.noop] : [1, []], + result = _.attempt(function() { return fp[methodName](args[0])(args[1]); }); + + if (_.includes(exceptions, methodName) + ? typeof result == 'function' + : typeof result != 'function' + ) { + return true; + } + console.log(methodName, result); + return false; + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should have a cap of 3', function(assert) { + assert.expect(1); + + var funcMethods = [ + 'assignWith', 'extendWith', 'isEqualWith', 'isMatchWith', 'reduce', + 'reduceRight', 'transform', 'zipWith' + ]; + + var expected = _.map(mapping.aryMethod[3], _.constant(true)); + + var actual = _.map(mapping.aryMethod[3], function(methodName) { + var args = _.includes(funcMethods, methodName) ? [_.noop, 0, 1] : [0, 1, []], + result = _.attempt(function() { return fp[methodName](args[0])(args[1])(args[2]); }); + + if (typeof result != 'function') { + return true; + } + console.log(methodName, result); + return false; + }); + + assert.deepEqual(actual, expected); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('methods that use `indexOf`'); + + (function() { + QUnit.test('should work with `fp.indexOf`', function(assert) { + assert.expect(10); + + var array = ['a', 'b', 'c'], + other = ['b', 'd', 'b'], + object = { 'a': 1, 'b': 2, 'c': 2 }, + actual = fp.difference(array)(other); + + assert.deepEqual(actual, ['a', 'c'], 'fp.difference'); + + actual = fp.includes('b')(array); + assert.strictEqual(actual, true, 'fp.includes'); + + actual = fp.intersection(other)(array); + assert.deepEqual(actual, ['b'], 'fp.intersection'); + + actual = fp.omit(other)(object); + assert.deepEqual(actual, { 'a': 1, 'c': 2 }, 'fp.omit'); + + actual = fp.union(other)(array); + assert.deepEqual(actual, ['a', 'b', 'c', 'd'], 'fp.union'); + + actual = fp.uniq(other); + assert.deepEqual(actual, ['b', 'd'], 'fp.uniq'); + + actual = fp.uniqBy(_.identity, other); + assert.deepEqual(actual, ['b', 'd'], 'fp.uniqBy'); + + actual = fp.without(other)(array); + assert.deepEqual(actual, ['a', 'c'], 'fp.without'); + + actual = fp.xor(other)(array); + assert.deepEqual(actual, ['a', 'c', 'd'], 'fp.xor'); + + actual = fp.pull('b')(array); + assert.deepEqual(actual, ['a', 'c'], 'fp.pull'); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('cherry-picked methods'); + + (function() { + QUnit.test('should provide the correct `iteratee` arguments', function(assert) { + assert.expect(4); + + var args, + array = [1, 2, 3], + object = { 'a': 1, 'b': 2 }, + isFIFO = _.keys(object)[0] == 'a', + map = convert('map', _.map), + reduce = convert('reduce', _.reduce); + + map(function() { + args || (args = slice.call(arguments)); + })(array); + + assert.deepEqual(args, [1]); + + args = undefined; + map(function() { + args || (args = slice.call(arguments)); + })(object); + + assert.deepEqual(args, isFIFO ? [1] : [2]); + + args = undefined; + reduce(function() { + args || (args = slice.call(arguments)); + })(0)(array); + + assert.deepEqual(args, [0, 1]); + + args = undefined; + reduce(function() { + args || (args = slice.call(arguments)); + })(0)(object); + + assert.deepEqual(args, isFIFO ? [0, 1] : [0, 2]); + }); + + QUnit.test('should not support shortcut fusion', function(assert) { + assert.expect(3); + + var array = fp.range(0, LARGE_ARRAY_SIZE), + filterCount = 0, + mapCount = 0; + + var iteratee = function(value) { + mapCount++; + return value * value; + }; + + var predicate = function(value) { + filterCount++; + return isEven(value); + }; + + var map1 = convert('map', _.map), + filter1 = convert('filter', _.filter), + take1 = convert('take', _.take); + + var filter2 = filter1(predicate), + map2 = map1(iteratee), + take2 = take1(2); + + var combined = fp.flow(map2, filter2, fp.compact, take2); + + assert.deepEqual(combined(array), [4, 16]); + assert.strictEqual(filterCount, 200, 'filterCount'); + assert.strictEqual(mapCount, 200, 'mapCount'); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('iteratee shorthands'); + + (function() { + var objects = [{ 'a': 1, 'b': 2 }, { 'a': 3, 'b': 4 }]; + + QUnit.test('should work with "_.matches" shorthands', function(assert) { + assert.expect(1); + + assert.deepEqual(fp.filter({ 'a': 3 })(objects), [objects[1]]); + }); + + QUnit.test('should work with "_.matchesProperty" shorthands', function(assert) { + assert.expect(1); + + assert.deepEqual(fp.filter(['a', 3])(objects), [objects[1]]); + }); + + QUnit.test('should work with "_.property" shorthands', function(assert) { + assert.expect(1); + + assert.deepEqual(fp.map('a')(objects), [1, 3]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('placeholder methods'); + + (function() { + QUnit.test('should use `fp` as the default placeholder', function(assert) { + assert.expect(3); + + var actual = fp.add(fp, 'b')('a'); + assert.strictEqual(actual, 'ab'); + + actual = fp.fill(fp, 2)(1, '*')([1, 2, 3]); + assert.deepEqual(actual, [1, '*', 3]); + + actual = fp.slice(fp, 2)(1)(['a', 'b', 'c']); + assert.deepEqual(actual, ['b']); + }); + + QUnit.test('should support `fp.placeholder`', function(assert) { + assert.expect(6); + + _.each([[], fp.__], function(ph) { + fp.placeholder = ph; + + var actual = fp.add(ph, 'b')('a'); + assert.strictEqual(actual, 'ab'); + + actual = fp.fill(ph, 2)(1, '*')([1, 2, 3]); + assert.deepEqual(actual, [1, '*', 3]); + + actual = fp.slice(ph, 2)(1)(['a', 'b', 'c']); + assert.deepEqual(actual, ['b']); + }); + }); + + var methodNames = [ + 'bind', + 'bindKey', + 'curry', + 'curryRight', + 'partial', + 'partialRight' + ]; + + _.each(methodNames, function(methodName) { + var func = fp[methodName]; + + QUnit.test('fp.' + methodName + '` should have a `placeholder` property', function(assert) { + assert.expect(2); + + assert.ok(_.isObject(func.placeholder)); + assert.strictEqual(func.placeholder, fp.__); + }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('setter methods'); + + (function() { + QUnit.test('should only clone objects in `path`', function(assert) { + assert.expect(11); + + var object = { 'a': { 'b': 2, 'c': 3 }, 'd': { 'e': 4 } }, + value = _.cloneDeep(object), + actual = fp.set('a.b.c.d', 5, value); + + assert.ok(_.isObject(actual.a.b), 'fp.set'); + assert.ok(_.isNumber(actual.a.b), 'fp.set'); + + assert.strictEqual(actual.a.b.c.d, 5, 'fp.set'); + assert.strictEqual(actual.d, value.d, 'fp.set'); + + value = _.cloneDeep(object); + actual = fp.setWith(Object)('[0][1]')('a')(value); + + assert.deepEqual(actual[0], { '1': 'a' }, 'fp.setWith'); + + value = _.cloneDeep(object); + actual = fp.unset('a.b')(value); + + assert.notOk('b' in actual.a, 'fp.unset'); + assert.strictEqual(actual.a.c, value.a.c, 'fp.unset'); + + value = _.cloneDeep(object); + actual = fp.update('a.b')(square)(value); + + assert.strictEqual(actual.a.b, 4, 'fp.update'); + assert.strictEqual(actual.d, value.d, 'fp.update'); + + value = _.cloneDeep(object); + actual = fp.updateWith(Object)('[0][1]')(_.constant('a'))(value); + + assert.deepEqual(actual[0], { '1': 'a' }, 'fp.updateWith'); + assert.strictEqual(actual.d, value.d, 'fp.updateWith'); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.add and fp.subtract'); + + _.each(['add', 'subtract'], function(methodName) { + var func = fp[methodName], + isAdd = methodName == 'add'; + + QUnit.test('`fp.' + methodName + '` should not have `rearg` applied', function(assert) { + assert.expect(1); + + assert.strictEqual(func('1')('2'), isAdd ? '12' : -1); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('object assignments'); + + _.each(['assign', 'assignIn', 'defaults', 'defaultsDeep', 'merge'], function(methodName) { + var func = fp[methodName]; + + QUnit.test('`fp.' + methodName + '` should not mutate values', function(assert) { + assert.expect(2); + + var object = { 'a': 1 }, + actual = func(object)({ 'b': 2 }); + + assert.deepEqual(object, { 'a': 1 }); + assert.deepEqual(actual, { 'a': 1, 'b': 2 }); + }); + }); + + _.each(['assignAll', 'assignInAll', 'defaultsAll', 'defaultsDeepAll', 'mergeAll'], function(methodName) { + var func = fp[methodName]; + + QUnit.test('`fp.' + methodName + '` should not mutate values', function(assert) { + assert.expect(2); + + var objects = [{ 'a': 1 }, { 'b': 2 }], + actual = func(objects); + + assert.deepEqual(objects[0], { 'a': 1 }); + assert.deepEqual(actual, { 'a': 1, 'b': 2 }); + }); + }); + + _.each(['assignWith', 'assignInWith', 'extendWith'], function(methodName) { + var func = fp[methodName]; + + QUnit.test('`fp.' + methodName + '` should provide the correct `customizer` arguments', function(assert) { + assert.expect(1); + + var args; + + func(function() { + args || (args = _.map(arguments, _.cloneDeep)); + })({ 'a': 1 })({ 'b': 2 }); + + assert.deepEqual(args, [undefined, 2, 'b', { 'a': 1 }, { 'b': 2 }]); + }); + }); + + _.each(['assignAllWith', 'assignInAllWith', 'extendAllWith', 'mergeAllWith'], function(methodName) { + var func = fp[methodName]; + + QUnit.test('`fp.' + methodName + '` should not mutate values', function(assert) { + assert.expect(2); + + var objects = [{ 'a': 1 }, { 'b': 2 }], + actual = func(_.noop)(objects); + + assert.deepEqual(objects[0], { 'a': 1 }); + assert.deepEqual(actual, { 'a': 1, 'b': 2 }); + }); + + QUnit.test('`fp.' + methodName + '` should work with more than two sources', function(assert) { + assert.expect(2); + + var pass = false, + objects = [{ 'a': 1 }, { 'b': 2 }, { 'c': 3 }], + actual = func(function() { pass = true; })(objects); + + assert.ok(pass); + assert.deepEqual(actual, { 'a': 1, 'b': 2, 'c': 3 }); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.castArray'); + + (function() { + QUnit.test('should shallow clone array values', function(assert) { + assert.expect(2); + + var array = [1], + actual = fp.castArray(array); + + assert.deepEqual(actual, array); + assert.notStrictEqual(actual, array); + }); + + QUnit.test('should not shallow clone non-array values', function(assert) { + assert.expect(2); + + var object = { 'a': 1 }, + actual = fp.castArray(object); + + assert.deepEqual(actual, [object]); + assert.strictEqual(actual[0], object); + }); + + QUnit.test('should convert by name', function(assert) { + assert.expect(4); + + var array = [1], + object = { 'a': 1 }, + castArray = convert('castArray', _.castArray), + actual = castArray(array); + + assert.deepEqual(actual, array); + assert.notStrictEqual(actual, array); + + actual = castArray(object); + assert.deepEqual(actual, [object]); + assert.strictEqual(actual[0], object); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('curry methods'); + + _.each(['curry', 'curryRight'], function(methodName) { + var func = fp[methodName]; + + QUnit.test('fp.' + methodName + '` should only accept a `func` param', function(assert) { + assert.expect(1); + + assert.raises(function() { func(1, _.noop); }, TypeError); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('curryN methods'); + + _.each(['curryN', 'curryRightN'], function(methodName) { + var func = fp[methodName]; + + QUnit.test('fp.' + methodName + '` should accept an `arity` param', function(assert) { + assert.expect(1); + + var actual = func(1)(function(a, b) { return [a, b]; })('a'); + assert.deepEqual(actual, ['a', undefined]); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.defaultTo'); + + (function() { + QUnit.test('should have an argument order of `defaultValue` then `value`', function(assert) { + assert.expect(2); + + assert.strictEqual(fp.defaultTo(1)(0), 0); + assert.strictEqual(fp.defaultTo(1)(undefined), 1); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.difference'); + + (function() { + QUnit.test('should return the elements of the first array not included in the second array', function(assert) { + assert.expect(1); + + var actual = fp.difference([2, 1], [2, 3]); + assert.deepEqual(actual, [1]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.differenceBy'); + + (function() { + QUnit.test('should have an argument order of `iteratee`, `array`, then `values`', function(assert) { + assert.expect(1); + + var actual = fp.differenceBy(Math.floor, [2.1, 1.2], [2.3, 3.4]); + assert.deepEqual(actual, [1.2]); + }); + + QUnit.test('should provide the correct `iteratee` arguments', function(assert) { + assert.expect(1); + + var args; + + fp.differenceBy(function() { + args || (args = slice.call(arguments)); + })([2.1, 1.2], [2.3, 3.4]); + + assert.deepEqual(args, [2.3]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.differenceWith'); + + (function() { + QUnit.test('should have an argument order of `comparator`, `array`, then `values`', function(assert) { + assert.expect(1); + + var actual = fp.differenceWith(fp.eq)([2, 1])([2, 3]); + assert.deepEqual(actual, [1]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.divide and fp.multiply'); + + _.each(['divide', 'multiply'], function(methodName) { + var func = fp[methodName], + isDivide = methodName == 'divide'; + + QUnit.test('`fp.' + methodName + '` should not have `rearg` applied', function(assert) { + assert.expect(1); + + assert.strictEqual(func('2')('4'), isDivide ? 0.5 : 8); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.extend'); + + (function() { + QUnit.test('should convert by name', function(assert) { + assert.expect(2); + + function Foo() {} + Foo.prototype = { 'b': 2 }; + + var object = { 'a': 1 }, + extend = convert('extend', _.extend), + actual = extend(object)(new Foo); + + assert.deepEqual(object, { 'a': 1 }); + assert.deepEqual(actual, { 'a': 1, 'b': 2 }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.fill'); + + (function() { + QUnit.test('should have an argument order of `start`, `end`, then `value`', function(assert) { + assert.expect(1); + + var array = [1, 2, 3]; + assert.deepEqual(fp.fill(1)(2)('*')(array), [1, '*', 3]); + }); + + QUnit.test('should not mutate values', function(assert) { + assert.expect(2); + + var array = [1, 2, 3], + actual = fp.fill(1)(2)('*')(array); + + assert.deepEqual(array, [1, 2, 3]); + assert.deepEqual(actual, [1, '*', 3]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.findFrom methods'); + + _.each(['findFrom', 'findIndexFrom', 'findLastFrom', 'findLastIndexFrom'], function(methodName) { + var func = fp[methodName]; + + QUnit.test('fp.' + methodName + '` should provide the correct `predicate` arguments', function(assert) { + assert.expect(1); + + var args; + + func(function() { + args || (args = slice.call(arguments)); + })(1)([1, 2, 3]); + + assert.deepEqual(args, [2]); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.findFrom'); + + (function() { + function resolve(value) { + return fp.flow(fp.property('a'), fp.eq(value)); + } + + QUnit.test('should have an argument order of `value`, `fromIndex`, then `array`', function(assert) { + assert.expect(2); + + var objects = [{ 'a': 1 }, { 'a': 2 }, { 'a': 1 }, { 'a': 2 }]; + + assert.strictEqual(fp.findFrom(resolve(1))(1)(objects), objects[2]); + assert.strictEqual(fp.findFrom(resolve(2))(-2)(objects), objects[3]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.findLastFrom'); + + (function() { + function resolve(value) { + return fp.flow(fp.property('a'), fp.eq(value)); + } + + QUnit.test('should have an argument order of `value`, `fromIndex`, then `array`', function(assert) { + assert.expect(2); + + var objects = [{ 'a': 1 }, { 'a': 2 }, { 'a': 1 }, { 'a': 2 }]; + + assert.strictEqual(fp.findLastFrom(resolve(1))(1)(objects), objects[0]); + assert.strictEqual(fp.findLastFrom(resolve(2))(-2)(objects), objects[1]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.findIndexFrom and fp.indexOfFrom'); + + _.each(['findIndexFrom', 'indexOfFrom'], function(methodName) { + var func = fp[methodName], + resolve = methodName == 'findIndexFrom' ? fp.eq : _.identity; + + QUnit.test('fp.' + methodName + '` should have an argument order of `value`, `fromIndex`, then `array`', function(assert) { + assert.expect(2); + + var array = [1, 2, 3, 1, 2, 3]; + + assert.strictEqual(func(resolve(1))(2)(array), 3); + assert.strictEqual(func(resolve(2))(-3)(array), 4); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.findLastIndexFrom and fp.lastIndexOfFrom'); + + _.each(['findLastIndexFrom', 'lastIndexOfFrom'], function(methodName) { + var func = fp[methodName], + resolve = methodName == 'findLastIndexFrom' ? fp.eq : _.identity; + + QUnit.test('fp.' + methodName + '` should have an argument order of `value`, `fromIndex`, then `array`', function(assert) { + assert.expect(2); + + var array = [1, 2, 3, 1, 2, 3]; + + assert.strictEqual(func(resolve(2))(3)(array), 1); + assert.strictEqual(func(resolve(3))(-3)(array), 2); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.flatMapDepth'); + + (function() { + QUnit.test('should have an argument order of `iteratee`, `depth`, then `collection`', function(assert) { + assert.expect(2); + + function duplicate(n) { + return [[[n, n]]]; + } + + var array = [1, 2], + object = { 'a': 1, 'b': 2 }, + expected = [[1, 1], [2, 2]]; + + assert.deepEqual(fp.flatMapDepth(duplicate)(2)(array), expected); + assert.deepEqual(fp.flatMapDepth(duplicate)(2)(object), expected); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('flow methods'); + + _.each(['flow', 'flowRight'], function(methodName) { + var func = fp[methodName], + isFlow = methodName == 'flow'; + + QUnit.test('`fp.' + methodName + '` should support shortcut fusion', function(assert) { + assert.expect(6); + + var filterCount, + mapCount, + array = fp.range(0, LARGE_ARRAY_SIZE); + + var iteratee = function(value) { + mapCount++; + return square(value); + }; + + var predicate = function(value) { + filterCount++; + return isEven(value); + }; + + var filter = fp.filter(predicate), + map = fp.map(iteratee), + take = fp.take(2); + + _.times(2, function(index) { + var combined = isFlow + ? func(map, filter, fp.compact, take) + : func(take, fp.compact, filter, map); + + filterCount = mapCount = 0; + + if (WeakMap && WeakMap.name) { + assert.deepEqual(combined(array), [4, 16]); + assert.strictEqual(filterCount, 5, 'filterCount'); + assert.strictEqual(mapCount, 5, 'mapCount'); + } + else { + skipAssert(assert, 3); + } + }); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('forEach methods'); + + _.each(['forEach', 'forEachRight', 'forIn', 'forInRight', 'forOwn', 'forOwnRight'], function(methodName) { + var func = fp[methodName]; + + QUnit.test('`fp.' + methodName + '` should provide `value` to `iteratee`', function(assert) { + assert.expect(2); + + var args; + + func(function() { + args || (args = slice.call(arguments)); + })(['a']); + + assert.deepEqual(args, ['a']); + + args = undefined; + + func(function() { + args || (args = slice.call(arguments)); + })({ 'a': 1 }); + + assert.deepEqual(args, [1]); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.getOr'); + + (function() { + QUnit.test('should accept a `defaultValue` param', function(assert) { + assert.expect(1); + + var actual = fp.getOr('default')('path')({}); + assert.strictEqual(actual, 'default'); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.gt and fp.gte'); + + _.each(['gt', 'gte'], function(methodName) { + var func = fp[methodName]; + + QUnit.test('`fp.' + methodName + '` should have `rearg` applied', function(assert) { + assert.expect(1); + + assert.strictEqual(func(2)(1), true); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.inRange'); + + (function() { + QUnit.test('should have an argument order of `start`, `end`, then `value`', function(assert) { + assert.expect(2); + + assert.strictEqual(fp.inRange(2)(4)(3), true); + assert.strictEqual(fp.inRange(-2)(-6)(-3), true); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.intersectionBy'); + + (function() { + QUnit.test('should have an argument order of `iteratee`, `array`, then `values`', function(assert) { + assert.expect(1); + + var actual = fp.intersectionBy(Math.floor, [2.1, 1.2], [2.3, 3.4]); + assert.deepEqual(actual, [2.1]); + }); + + QUnit.test('should provide the correct `iteratee` arguments', function(assert) { + assert.expect(1); + + var args; + + fp.intersectionBy(function() { + args || (args = slice.call(arguments)); + })([2.1, 1.2], [2.3, 3.4]); + + assert.deepEqual(args, [2.3]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.intersectionWith'); + + (function() { + QUnit.test('should have an argument order of `comparator`, `array`, then `values`', function(assert) { + assert.expect(1); + + var actual = fp.intersectionWith(fp.eq)([2, 1])([2, 3]); + assert.deepEqual(actual, [2]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.invoke'); + + (function() { + QUnit.test('should not accept an `args` param', function(assert) { + assert.expect(1); + + var actual = fp.invoke('toUpperCase')('a'); + assert.strictEqual(actual, 'A'); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.invokeMap'); + + (function() { + QUnit.test('should not accept an `args` param', function(assert) { + assert.expect(1); + + var actual = fp.invokeMap('toUpperCase')(['a', 'b']); + assert.deepEqual(actual, ['A', 'B']); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.invokeArgs'); + + (function() { + QUnit.test('should accept an `args` param', function(assert) { + assert.expect(1); + + var actual = fp.invokeArgs('concat')(['b', 'c'])('a'); + assert.strictEqual(actual, 'abc'); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.invokeArgsMap'); + + (function() { + QUnit.test('should accept an `args` param', function(assert) { + assert.expect(1); + + var actual = fp.invokeArgsMap('concat')(['b', 'c'])(['a', 'A']); + assert.deepEqual(actual, ['abc', 'Abc']); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.isEqualWith'); + + (function() { + QUnit.test('should provide the correct `customizer` arguments', function(assert) { + assert.expect(1); + + var args, + iteration = 0, + objects = [{ 'a': 1 }, { 'a': 2 }], + stack = { '__data__': { '__data__': [objects, objects.slice().reverse()], 'size': 2 }, 'size': 2 }, + expected = [1, 2, 'a', objects[0], objects[1], stack]; + + fp.isEqualWith(function() { + if (++iteration == 2) { + args = _.map(arguments, _.cloneDeep); + } + })(objects[0])(objects[1]); + + args[5] = _.omitBy(args[5], _.isFunction); + args[5].__data__ = _.omitBy(args[5].__data__, _.isFunction); + + assert.deepEqual(args, expected); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.isMatchWith'); + + (function() { + QUnit.test('should provide the correct `customizer` arguments', function(assert) { + assert.expect(1); + + var args, + objects = [{ 'a': 1 }, { 'a': 2 }], + stack = { '__data__': { '__data__': [], 'size': 0 }, 'size': 0 }, + expected = [2, 1, 'a', objects[1], objects[0], stack]; + + fp.isMatchWith(function() { + args || (args = _.map(arguments, _.cloneDeep)); + })(objects[0])(objects[1]); + + args[5] = _.omitBy(args[5], _.isFunction); + args[5].__data__ = _.omitBy(args[5].__data__, _.isFunction); + + assert.deepEqual(args, expected); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.iteratee'); + + (function() { + QUnit.test('should return a iteratee with capped params', function(assert) { + assert.expect(1); + + var func = fp.iteratee(function(a, b, c) { return [a, b, c]; }, 3); + assert.deepEqual(func(1, 2, 3), [1, undefined, undefined]); + }); + + QUnit.test('should convert by name', function(assert) { + assert.expect(1); + + var iteratee = convert('iteratee', _.iteratee), + func = iteratee(function(a, b, c) { return [a, b, c]; }, 3); + + assert.deepEqual(func(1, 2, 3), [1, undefined, undefined]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.lt and fp.lte'); + + _.each(['lt', 'lte'], function(methodName) { + var func = fp[methodName]; + + QUnit.test('`fp.' + methodName + '` should have `rearg` applied', function(assert) { + assert.expect(1); + + assert.strictEqual(func(1)(2), true); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.mapKeys'); + + (function() { + QUnit.test('should only provide `key` to `iteratee`', function(assert) { + assert.expect(1); + + var args; + + fp.mapKeys(function() { + args || (args = slice.call(arguments)); + }, { 'a': 1 }); + + assert.deepEqual(args, ['a']); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.maxBy and fp.minBy'); + + _.each(['maxBy', 'minBy'], function(methodName) { + var array = [1, 2, 3], + func = fp[methodName], + isMax = methodName == 'maxBy'; + + QUnit.test('`fp.' + methodName + '` should work with an `iteratee` argument', function(assert) { + assert.expect(1); + + var actual = func(function(num) { + return -num; + })(array); + + assert.strictEqual(actual, isMax ? 1 : 3); + }); + + QUnit.test('`fp.' + methodName + '` should provide the correct `iteratee` arguments', function(assert) { + assert.expect(1); + + var args; + + func(function() { + args || (args = slice.call(arguments)); + })(array); + + assert.deepEqual(args, [1]); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.mergeWith'); + + (function() { + QUnit.test('should provide the correct `customizer` arguments', function(assert) { + assert.expect(1); + + var args, + stack = { '__data__': { '__data__': [], 'size': 0 }, 'size': 0 }, + expected = [[1, 2], [3], 'a', { 'a': [1, 2] }, { 'a': [3] }, stack]; + + fp.mergeWith(function() { + args || (args = _.map(arguments, _.cloneDeep)); + })({ 'a': [1, 2] })({ 'a': [3] }); + + args[5] = _.omitBy(args[5], _.isFunction); + args[5].__data__ = _.omitBy(args[5].__data__, _.isFunction); + + assert.deepEqual(args, expected); + }); + + QUnit.test('should not mutate values', function(assert) { + assert.expect(2); + + var objects = [{ 'a': [1, 2] }, { 'a': [3] }], + actual = fp.mergeWith(_.noop, objects[0], objects[1]); + + assert.deepEqual(objects[0], { 'a': [1, 2] }); + assert.deepEqual(actual, { 'a': [3, 2] }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.mergeAllWith'); + + (function() { + QUnit.test('should provide the correct `customizer` arguments', function(assert) { + assert.expect(1); + + var args, + objects = [{ 'a': [1, 2] }, { 'a': [3] }], + stack = { '__data__': { '__data__': [], 'size': 0 }, 'size': 0 }, + expected = [[1, 2], [3], 'a', { 'a': [1, 2] }, { 'a': [3] }, stack]; + + fp.mergeAllWith(function() { + args || (args = _.map(arguments, _.cloneDeep)); + })(objects); + + args[5] = _.omitBy(args[5], _.isFunction); + args[5].__data__ = _.omitBy(args[5].__data__, _.isFunction); + + assert.deepEqual(args, expected); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.mixin'); + + (function() { + var source = { 'a': _.noop }; + + QUnit.test('should mixin static methods but not prototype methods', function(assert) { + assert.expect(2); + + fp.mixin(source); + + assert.strictEqual(typeof fp.a, 'function'); + assert.notOk('a' in fp.prototype); + + delete fp.a; + delete fp.prototype.a; + }); + + QUnit.test('should not assign inherited `source` methods', function(assert) { + assert.expect(2); + + function Foo() {} + Foo.prototype.a = _.noop; + fp.mixin(new Foo); + + assert.notOk('a' in fp); + assert.notOk('a' in fp.prototype); + + delete fp.a; + delete fp.prototype.a; + }); + + QUnit.test('should not remove existing prototype methods', function(assert) { + assert.expect(2); + + var each1 = fp.each, + each2 = fp.prototype.each; + + fp.mixin({ 'each': source.a }); + + assert.strictEqual(fp.each, source.a); + assert.strictEqual(fp.prototype.each, each2); + + fp.each = each1; + fp.prototype.each = each2; + }); + + QUnit.test('should not export to the global when `source` is not an object', function(assert) { + assert.expect(2); + + var props = _.without(_.keys(_), '_'); + + _.times(2, function(index) { + fp.mixin.apply(fp, index ? [1] : []); + + assert.ok(_.every(props, function(key) { + return root[key] !== fp[key]; + })); + + _.each(props, function(key) { + if (root[key] === fp[key]) { + delete root[key]; + } + }); + }); + }); + + QUnit.test('should convert by name', function(assert) { + assert.expect(3); + + var object = { 'mixin': convert('mixin', _.mixin) }; + + function Foo() {} + Foo.mixin = object.mixin; + Foo.mixin(source); + + assert.ok('a' in Foo); + assert.notOk('a' in Foo.prototype); + + object.mixin(source); + assert.ok('a' in object); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.nthArg'); + + (function() { + QUnit.test('should return a curried function', function(assert) { + assert.expect(2); + + var func = fp.nthArg(1); + assert.strictEqual(func(1)(2), 2); + + func = fp.nthArg(-1); + assert.strictEqual(func(1), 1); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.over'); + + (function() { + QUnit.test('should not cap iteratee args', function(assert) { + assert.expect(2); + + _.each([fp.over, convert('over', _.over)], function(func) { + var over = func([Math.max, Math.min]); + assert.deepEqual(over(1, 2, 3, 4), [4, 1]); + }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.omitBy and fp.pickBy'); + + _.each(['omitBy', 'pickBy'], function(methodName) { + var func = fp[methodName]; + + QUnit.test('`fp.' + methodName + '` should provide `value` and `key` to `iteratee`', function(assert) { + assert.expect(1); + + var args; + + func(function() { + args || (args = slice.call(arguments)); + })({ 'a': 1 }); + + assert.deepEqual(args, [1, 'a']); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('padChars methods'); + + _.each(['padChars', 'padCharsStart', 'padCharsEnd'], function(methodName) { + var func = fp[methodName], + isPad = methodName == 'padChars', + isStart = methodName == 'padCharsStart'; + + QUnit.test('fp.' + methodName + '` should truncate pad characters to fit the pad length', function(assert) { + assert.expect(1); + + if (isPad) { + assert.strictEqual(func('_-')(8)('abc'), '_-abc_-_'); + } else { + assert.strictEqual(func('_-')(6)('abc'), isStart ? '_-_abc' : 'abc_-_'); + } + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('partial methods'); + + _.each(['partial', 'partialRight'], function(methodName) { + var func = fp[methodName], + isPartial = methodName == 'partial'; + + QUnit.test('fp.' + methodName + '` should accept an `args` param', function(assert) { + assert.expect(1); + + var expected = isPartial ? [1, 2, 3] : [0, 1, 2]; + + var actual = func(function(a, b, c) { + return [a, b, c]; + })([1, 2])(isPartial ? 3 : 0); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('fp.' + methodName + '` should convert by name', function(assert) { + assert.expect(2); + + var expected = isPartial ? [1, 2, 3] : [0, 1, 2], + par = convert(methodName, _[methodName]), + ph = par.placeholder; + + var actual = par(function(a, b, c) { + return [a, b, c]; + })([1, 2])(isPartial ? 3 : 0); + + assert.deepEqual(actual, expected); + + actual = par(function(a, b, c) { + return [a, b, c]; + })([ph, 2])(isPartial ? 1 : 0, isPartial ? 3 : 1); + + assert.deepEqual(actual, expected); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.propertyOf'); + + (function() { + QUnit.test('should be curried', function(assert) { + assert.expect(2); + + var object = { 'a': 1 }; + + assert.strictEqual(fp.propertyOf(object, 'a'), 1); + assert.strictEqual(fp.propertyOf(object)('a'), 1); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.pull'); + + (function() { + QUnit.test('should not mutate values', function(assert) { + assert.expect(2); + + var array = [1, 2, 3], + actual = fp.pull(2)(array); + + assert.deepEqual(array, [1, 2, 3]); + assert.deepEqual(actual, [1, 3]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.pullAll'); + + (function() { + QUnit.test('should not mutate values', function(assert) { + assert.expect(2); + + var array = [1, 2, 3], + actual = fp.pullAll([1, 3])(array); + + assert.deepEqual(array, [1, 2, 3]); + assert.deepEqual(actual, [2]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.pullAt'); + + (function() { + QUnit.test('should not mutate values', function(assert) { + assert.expect(2); + + var array = [1, 2, 3], + actual = fp.pullAt([0, 2])(array); + + assert.deepEqual(array, [1, 2, 3]); + assert.deepEqual(actual, [2]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.random'); + + (function() { + var array = Array(1000); + + QUnit.test('should support a `min` and `max` argument', function(assert) { + assert.expect(1); + + var min = 5, + max = 10; + + assert.ok(_.some(array, function() { + var result = fp.random(min)(max); + return result >= min && result <= max; + })); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('range methods'); + + _.each(['range', 'rangeRight'], function(methodName) { + var func = fp[methodName], + isRange = methodName == 'range'; + + QUnit.test('fp.' + methodName + '` should have an argument order of `start` then `end`', function(assert) { + assert.expect(1); + + assert.deepEqual(func(1)(4), isRange ? [1, 2, 3] : [3, 2, 1]); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('rangeStep methods'); + + _.each(['rangeStep', 'rangeStepRight'], function(methodName) { + var func = fp[methodName], + isRange = methodName == 'rangeStep'; + + QUnit.test('fp.' + methodName + '` should have an argument order of `step`, `start`, then `end`', function(assert) { + assert.expect(1); + + assert.deepEqual(func(2)(1)(4), isRange ? [1, 3] : [3, 1]); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.rearg'); + + (function() { + function fn(a, b, c) { + return [a, b, c]; + } + + QUnit.test('should be curried', function(assert) { + assert.expect(1); + + var rearged = fp.rearg([1, 2, 0])(fn); + assert.deepEqual(rearged('c', 'a', 'b'), ['a', 'b', 'c']); + }); + + QUnit.test('should return a curried function', function(assert) { + assert.expect(1); + + var rearged = fp.rearg([1, 2, 0], fn); + assert.deepEqual(rearged('c')('a')('b'), ['a', 'b', 'c']); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('reduce methods'); + + _.each(['reduce', 'reduceRight'], function(methodName) { + var func = fp[methodName], + isReduce = methodName == 'reduce'; + + QUnit.test('`fp.' + methodName + '` should provide the correct `iteratee` arguments when iterating an array', function(assert) { + assert.expect(1); + + var args; + + func(function() { + args || (args = slice.call(arguments)); + })(0)([1, 2, 3]); + + assert.deepEqual(args, isReduce ? [0, 1] : [3, 0]); + }); + + QUnit.test('`fp.' + methodName + '` should provide the correct `iteratee` arguments when iterating an object', function(assert) { + assert.expect(1); + + var args, + object = { 'a': 1, 'b': 2 }, + isFIFO = _.keys(object)[0] == 'a'; + + var expected = isFIFO + ? (isReduce ? [0, 1] : [2, 0]) + : (isReduce ? [0, 2] : [1, 0]); + + func(function() { + args || (args = slice.call(arguments)); + })(0)(object); + + assert.deepEqual(args, expected); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.remove'); + + (function() { + QUnit.test('should not mutate values', function(assert) { + assert.expect(2); + + var array = [1, 2, 3], + actual = fp.remove(fp.eq(2))(array); + + assert.deepEqual(array, [1, 2, 3]); + assert.deepEqual(actual, [1, 3]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.restFrom'); + + (function() { + QUnit.test('should accept a `start` param', function(assert) { + assert.expect(1); + + var actual = fp.restFrom(2)(function() { + return slice.call(arguments); + })('a', 'b', 'c', 'd'); + + assert.deepEqual(actual, ['a', 'b', ['c', 'd']]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.reverse'); + + (function() { + QUnit.test('should not mutate values', function(assert) { + assert.expect(2); + + var array = [1, 2, 3], + actual = fp.reverse(array); + + assert.deepEqual(array, [1, 2, 3]); + assert.deepEqual(actual, [3, 2, 1]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.runInContext'); + + (function() { + QUnit.test('should return a converted lodash instance', function(assert) { + assert.expect(1); + + assert.strictEqual(typeof fp.runInContext({}).curryN, 'function'); + }); + + QUnit.test('should convert by name', function(assert) { + assert.expect(1); + + var runInContext = convert('runInContext', _.runInContext); + assert.strictEqual(typeof runInContext({}).curryN, 'function'); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.set'); + + (function() { + QUnit.test('should not mutate values', function(assert) { + assert.expect(2); + + var object = { 'a': { 'b': 2, 'c': 3 } }, + actual = fp.set('a.b')(3)(object); + + assert.deepEqual(object, { 'a': { 'b': 2, 'c': 3 } }); + assert.deepEqual(actual, { 'a': { 'b': 3, 'c': 3 } }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.setWith'); + + (function() { + QUnit.test('should provide the correct `customizer` arguments', function(assert) { + assert.expect(1); + + var args; + + fp.setWith(function() { + args || (args = _.map(arguments, _.cloneDeep)); + })('b.c')(2)({ 'a': 1 }); + + assert.deepEqual(args, [undefined, 'b', { 'a': 1 }]); + }); + + QUnit.test('should not mutate values', function(assert) { + assert.expect(2); + + var object = { 'a': { 'b': 2, 'c': 3 } }, + actual = fp.setWith(Object)('d.e')(4)(object); + + assert.deepEqual(object, { 'a': { 'b': 2, 'c': 3 } }); + assert.deepEqual(actual, { 'a': { 'b': 2, 'c': 3 }, 'd': { 'e': 4 } }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.spreadFrom'); + + (function() { + QUnit.test('should accept a `start` param', function(assert) { + assert.expect(1); + + var actual = fp.spreadFrom(2)(function() { + return slice.call(arguments); + })('a', 'b', ['c', 'd']); + + assert.deepEqual(actual, ['a', 'b', 'c', 'd']); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('trimChars methods'); + + _.each(['trimChars', 'trimCharsStart', 'trimCharsEnd'], function(methodName, index) { + var func = fp[methodName], + parts = []; + + if (index != 2) { + parts.push('leading'); + } + if (index != 1) { + parts.push('trailing'); + } + parts = parts.join(' and '); + + QUnit.test('`fp.' + methodName + '` should remove ' + parts + ' `chars`', function(assert) { + assert.expect(1); + + var string = '-_-a-b-c-_-', + expected = (index == 2 ? '-_-' : '') + 'a-b-c' + (index == 1 ? '-_-' : ''); + + assert.strictEqual(func('_-')(string), expected); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.unionBy'); + + (function() { + QUnit.test('should have an argument order of `iteratee`, `array`, then `other`', function(assert) { + assert.expect(1); + + var actual = fp.unionBy(Math.floor, [2.1], [1.2, 2.3]); + assert.deepEqual(actual, [2.1, 1.2]); + }); + + QUnit.test('should provide the correct `iteratee` arguments', function(assert) { + assert.expect(1); + + var args; + + fp.unionBy(function() { + args || (args = slice.call(arguments)); + })([2.1], [1.2, 2.3]); + + assert.deepEqual(args, [2.1]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.unionWith'); + + (function() { + QUnit.test('should have an argument order of `comparator`, `array`, then `values`', function(assert) { + assert.expect(1); + + var actual = fp.unionWith(fp.eq)([2, 1])([2, 3]); + assert.deepEqual(actual, [2, 1, 3]); + }); + + QUnit.test('should provide the correct `comparator` arguments', function(assert) { + assert.expect(1); + + var args; + + fp.unionWith(function() { + args || (args = slice.call(arguments)); + })([2, 1])([2, 3]); + + assert.deepEqual(args, [1, 2]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.uniqBy'); + + (function() { + var objects = [{ 'a': 2 }, { 'a': 3 }, { 'a': 1 }, { 'a': 2 }, { 'a': 3 }, { 'a': 1 }]; + + QUnit.test('should work with an `iteratee` argument', function(assert) { + assert.expect(1); + + var expected = objects.slice(0, 3), + actual = fp.uniqBy(_.property('a'))(objects); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should provide the correct `iteratee` arguments', function(assert) { + assert.expect(1); + + var args; + + fp.uniqBy(function() { + args || (args = slice.call(arguments)); + })(objects); + + assert.deepEqual(args, [objects[0]]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.uniqWith'); + + (function() { + QUnit.test('should have an argument order of `comparator`, `array`, then `values`', function(assert) { + assert.expect(1); + + var actual = fp.uniqWith(fp.eq)([2, 1, 2]); + assert.deepEqual(actual, [2, 1]); + }); + + QUnit.test('should provide the correct `comparator` arguments', function(assert) { + assert.expect(1); + + var args; + + fp.uniqWith(function() { + args || (args = slice.call(arguments)); + })([2, 1, 2]); + + assert.deepEqual(args, [1, 2]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.update'); + + (function() { + QUnit.test('should not convert end of `path` to an object', function(assert) { + assert.expect(1); + + var actual = fp.update('a.b')(_.identity)({ 'a': { 'b': 1 } }); + assert.strictEqual(typeof actual.a.b, 'number'); + }); + + QUnit.test('should not convert uncloneables to objects', function(assert) { + assert.expect(2); + + var object = { 'a': { 'b': _.constant(true) } }, + actual = fp.update('a.b')(_.identity)(object); + + assert.strictEqual(typeof object.a.b, 'function'); + assert.strictEqual(object.a.b, actual.a.b); + }); + + QUnit.test('should not mutate values', function(assert) { + assert.expect(2); + + var object = { 'a': { 'b': 2, 'c': 3 } }, + actual = fp.update('a.b')(square)(object); + + assert.deepEqual(object, { 'a': { 'b': 2, 'c': 3 } }); + assert.deepEqual(actual, { 'a': { 'b': 4, 'c': 3 } }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.updateWith'); + + (function() { + QUnit.test('should provide the correct `customizer` arguments', function(assert) { + var args; + + fp.updateWith(function() { + args || (args = _.map(arguments, _.cloneDeep)); + })('b.c')(_.constant(2))({ 'a': 1 }); + + assert.deepEqual(args, [undefined, 'b', { 'a': 1 }]); + }); + + QUnit.test('should not mutate values', function(assert) { + assert.expect(2); + + var object = { 'a': { 'b': 2, 'c': 3 } }, + actual = fp.updateWith(Object)('d.e')(_.constant(4))(object); + + assert.deepEqual(object, { 'a': { 'b': 2, 'c': 3 } }); + assert.deepEqual(actual, { 'a': { 'b': 2, 'c': 3 }, 'd': { 'e': 4 } }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.unset'); + + (function() { + QUnit.test('should not mutate values', function(assert) { + assert.expect(2); + + var object = { 'a': { 'b': 2, 'c': 3 } }, + actual = fp.unset('a.b')(object); + + assert.deepEqual(object, { 'a': { 'b': 2, 'c': 3 } }); + assert.deepEqual(actual, { 'a': { 'c': 3 } }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.xorBy'); + + (function() { + QUnit.test('should have an argument order of `iteratee`, `array`, then `other`', function(assert) { + assert.expect(1); + + var actual = fp.xorBy(Math.floor, [2.1, 1.2], [2.3, 3.4]); + assert.deepEqual(actual, [1.2, 3.4]); + }); + + QUnit.test('should provide the correct `iteratee` arguments', function(assert) { + assert.expect(1); + + var args; + + fp.xorBy(function() { + args || (args = slice.call(arguments)); + })([2.1, 1.2], [2.3, 3.4]); + + assert.deepEqual(args, [2.3]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.xorWith'); + + (function() { + QUnit.test('should have an argument order of `comparator`, `array`, then `values`', function(assert) { + assert.expect(1); + + var actual = fp.xorWith(fp.eq)([2, 1])([2, 3]); + assert.deepEqual(actual, [1, 3]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('with methods'); + + _.each(['differenceWith', 'intersectionWith', 'xorWith'], function(methodName) { + var func = fp[methodName]; + + QUnit.test('`fp.' + methodName + '` should provide the correct `comparator` arguments', function(assert) { + assert.expect(1); + + var args; + + func(function() { + args || (args = slice.call(arguments)); + })([2, 1])([2, 3]); + + assert.deepEqual(args, [2, 2]); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.zip'); + + (function() { + QUnit.test('should zip together two arrays', function(assert) { + assert.expect(1); + + assert.deepEqual(fp.zip([1, 2])([3, 4]), [[1, 3], [2, 4]]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.zipAll'); + + (function() { + QUnit.test('should zip together an array of arrays', function(assert) { + assert.expect(1); + + assert.deepEqual(fp.zipAll([[1, 2], [3, 4], [5, 6]]), [[1, 3, 5], [2, 4, 6]]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.zipObject'); + + (function() { + QUnit.test('should zip together key/value arrays into an object', function(assert) { + assert.expect(1); + + assert.deepEqual(fp.zipObject(['a', 'b'])([1, 2]), { 'a': 1, 'b': 2 }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('fp.zipWith'); + + (function() { + QUnit.test('should zip arrays combining grouped elements with `iteratee`', function(assert) { + assert.expect(1); + + var array1 = [1, 2, 3], + array2 = [4, 5, 6], + actual = fp.zipWith(add)(array1)(array2); + + assert.deepEqual(actual, [5, 7, 9]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.config.asyncRetries = 10; + QUnit.config.hidepassed = true; + + if (!document) { + QUnit.config.noglobals = true; + QUnit.load(); + QUnit.start(); + } +}.call(this)); diff --git a/test/test.js b/test/test.js index f7d722665e..fcb3a168ed 100644 --- a/test/test.js +++ b/test/test.js @@ -1,111 +1,282 @@ -;(function(root, undefined) { - 'use strict'; +;(function() { - /** Used to store Lo-Dash to test for bad shim detection */ - var lodashBadShim = root.lodashBadShim; + /** Used as a safe reference for `undefined` in pre-ES5 environments. */ + var undefined; - /** Method and object shortcuts */ + /** Used to detect when a function becomes hot. */ + var HOT_COUNT = 150; + + /** Used as the size to cover large array optimizations. */ + var LARGE_ARRAY_SIZE = 200; + + /** Used as the `TypeError` message for "Functions" methods. */ + var FUNC_ERROR_TEXT = 'Expected a function'; + + /** Used as the maximum memoize cache size. */ + var MAX_MEMOIZE_SIZE = 500; + + /** Used as references for various `Number` constants. */ + var MAX_SAFE_INTEGER = 9007199254740991, + MAX_INTEGER = 1.7976931348623157e+308; + + /** Used as references for the maximum length and index of an array. */ + var MAX_ARRAY_LENGTH = 4294967295, + MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1; + + /** `Object#toString` result references. */ + var funcTag = '[object Function]', + numberTag = '[object Number]', + objectTag = '[object Object]'; + + /** Used as a reference to the global object. */ + var root = (typeof global == 'object' && global) || this; + + /** Used to store lodash to test for bad extensions/shims. */ + var lodashBizarro = root.lodashBizarro; + + /** Used for native method references. */ + var arrayProto = Array.prototype, + funcProto = Function.prototype, + objectProto = Object.prototype, + numberProto = Number.prototype, + stringProto = String.prototype; + + /** Method and object shortcuts. */ var phantom = root.phantom, - amd = root.define && define.amd, - argv = root.process && process.argv, - document = !phantom && root.document, - body = document && document.body, + process = root.process, + amd = root.define ? define.amd : undefined, + args = toArgs([1, 2, 3]), + argv = process ? process.argv : undefined, + defineProperty = Object.defineProperty, + document = phantom ? undefined : root.document, + body = root.document ? root.document.body : undefined, create = Object.create, + fnToString = funcProto.toString, freeze = Object.freeze, + getSymbols = Object.getOwnPropertySymbols, + identity = function(value) { return value; }, noop = function() {}, - params = root.arguments, - push = Array.prototype.push, - slice = Array.prototype.slice, - system = root.system, - toString = Object.prototype.toString, - Worker = document && root.Worker; - - /** The file path of the Lo-Dash file to test */ + objToString = objectProto.toString, + params = argv, + push = arrayProto.push, + realm = {}, + slice = arrayProto.slice, + strictArgs = (function() { 'use strict'; return arguments; }(1, 2, 3)); + + var ArrayBuffer = root.ArrayBuffer, + Buffer = root.Buffer, + Map = root.Map, + Promise = root.Promise, + Proxy = root.Proxy, + Set = root.Set, + Symbol = root.Symbol, + Uint8Array = root.Uint8Array, + WeakMap = root.WeakMap, + WeakSet = root.WeakSet; + + var arrayBuffer = ArrayBuffer ? new ArrayBuffer(2) : undefined, + map = Map ? new Map : undefined, + promise = Promise ? Promise.resolve(1) : undefined, + set = Set ? new Set : undefined, + symbol = Symbol ? Symbol('a') : undefined, + weakMap = WeakMap ? new WeakMap : undefined, + weakSet = WeakSet ? new WeakSet : undefined; + + /** Math helpers. */ + var add = function(x, y) { return x + y; }, + doubled = function(n) { return n * 2; }, + isEven = function(n) { return n % 2 == 0; }, + square = function(n) { return n * n; }; + + /** Stub functions. */ + var stubA = function() { return 'a'; }, + stubB = function() { return 'b'; }, + stubC = function() { return 'c'; }; + + var stubTrue = function() { return true; }, + stubFalse = function() { return false; }; + + var stubNaN = function() { return NaN; }, + stubNull = function() { return null; }; + + var stubZero = function() { return 0; }, + stubOne = function() { return 1; }, + stubTwo = function() { return 2; }, + stubThree = function() { return 3; }, + stubFour = function() { return 4; }; + + var stubArray = function() { return []; }, + stubObject = function() { return {}; }, + stubString = function() { return ''; }; + + /** List of Latin Unicode letters. */ + var burredLetters = [ + // Latin-1 Supplement letters. + '\xc0', '\xc1', '\xc2', '\xc3', '\xc4', '\xc5', '\xc6', '\xc7', '\xc8', '\xc9', '\xca', '\xcb', '\xcc', '\xcd', '\xce', '\xcf', + '\xd0', '\xd1', '\xd2', '\xd3', '\xd4', '\xd5', '\xd6', '\xd8', '\xd9', '\xda', '\xdb', '\xdc', '\xdd', '\xde', '\xdf', + '\xe0', '\xe1', '\xe2', '\xe3', '\xe4', '\xe5', '\xe6', '\xe7', '\xe8', '\xe9', '\xea', '\xeb', '\xec', '\xed', '\xee', '\xef', + '\xf0', '\xf1', '\xf2', '\xf3', '\xf4', '\xf5', '\xf6', '\xf8', '\xf9', '\xfa', '\xfb', '\xfc', '\xfd', '\xfe', '\xff', + // Latin Extended-A letters. + '\u0100', '\u0101', '\u0102', '\u0103', '\u0104', '\u0105', '\u0106', '\u0107', '\u0108', '\u0109', '\u010a', '\u010b', '\u010c', '\u010d', '\u010e', '\u010f', + '\u0110', '\u0111', '\u0112', '\u0113', '\u0114', '\u0115', '\u0116', '\u0117', '\u0118', '\u0119', '\u011a', '\u011b', '\u011c', '\u011d', '\u011e', '\u011f', + '\u0120', '\u0121', '\u0122', '\u0123', '\u0124', '\u0125', '\u0126', '\u0127', '\u0128', '\u0129', '\u012a', '\u012b', '\u012c', '\u012d', '\u012e', '\u012f', + '\u0130', '\u0131', '\u0132', '\u0133', '\u0134', '\u0135', '\u0136', '\u0137', '\u0138', '\u0139', '\u013a', '\u013b', '\u013c', '\u013d', '\u013e', '\u013f', + '\u0140', '\u0141', '\u0142', '\u0143', '\u0144', '\u0145', '\u0146', '\u0147', '\u0148', '\u0149', '\u014a', '\u014b', '\u014c', '\u014d', '\u014e', '\u014f', + '\u0150', '\u0151', '\u0152', '\u0153', '\u0154', '\u0155', '\u0156', '\u0157', '\u0158', '\u0159', '\u015a', '\u015b', '\u015c', '\u015d', '\u015e', '\u015f', + '\u0160', '\u0161', '\u0162', '\u0163', '\u0164', '\u0165', '\u0166', '\u0167', '\u0168', '\u0169', '\u016a', '\u016b', '\u016c', '\u016d', '\u016e', '\u016f', + '\u0170', '\u0171', '\u0172', '\u0173', '\u0174', '\u0175', '\u0176', '\u0177', '\u0178', '\u0179', '\u017a', '\u017b', '\u017c', '\u017d', '\u017e', '\u017f' + ]; + + /** List of combining diacritical marks. */ + var comboMarks = [ + '\u0300', '\u0301', '\u0302', '\u0303', '\u0304', '\u0305', '\u0306', '\u0307', '\u0308', '\u0309', '\u030a', '\u030b', '\u030c', '\u030d', '\u030e', '\u030f', + '\u0310', '\u0311', '\u0312', '\u0313', '\u0314', '\u0315', '\u0316', '\u0317', '\u0318', '\u0319', '\u031a', '\u031b', '\u031c', '\u031d', '\u031e', '\u031f', + '\u0320', '\u0321', '\u0322', '\u0323', '\u0324', '\u0325', '\u0326', '\u0327', '\u0328', '\u0329', '\u032a', '\u032b', '\u032c', '\u032d', '\u032e', '\u032f', + '\u0330', '\u0331', '\u0332', '\u0333', '\u0334', '\u0335', '\u0336', '\u0337', '\u0338', '\u0339', '\u033a', '\u033b', '\u033c', '\u033d', '\u033e', '\u033f', + '\u0340', '\u0341', '\u0342', '\u0343', '\u0344', '\u0345', '\u0346', '\u0347', '\u0348', '\u0349', '\u034a', '\u034b', '\u034c', '\u034d', '\u034e', '\u034f', + '\u0350', '\u0351', '\u0352', '\u0353', '\u0354', '\u0355', '\u0356', '\u0357', '\u0358', '\u0359', '\u035a', '\u035b', '\u035c', '\u035d', '\u035e', '\u035f', + '\u0360', '\u0361', '\u0362', '\u0363', '\u0364', '\u0365', '\u0366', '\u0367', '\u0368', '\u0369', '\u036a', '\u036b', '\u036c', '\u036d', '\u036e', '\u036f', + '\ufe20', '\ufe21', '\ufe22', '\ufe23' + ]; + + /** List of converted Latin Unicode letters. */ + var deburredLetters = [ + // Converted Latin-1 Supplement letters. + 'A', 'A', 'A', 'A', 'A', 'A', 'Ae', 'C', 'E', 'E', 'E', 'E', 'I', 'I', 'I', + 'I', 'D', 'N', 'O', 'O', 'O', 'O', 'O', 'O', 'U', 'U', 'U', 'U', 'Y', 'Th', + 'ss', 'a', 'a', 'a', 'a', 'a', 'a', 'ae', 'c', 'e', 'e', 'e', 'e', 'i', 'i', 'i', + 'i', 'd', 'n', 'o', 'o', 'o', 'o', 'o', 'o', 'u', 'u', 'u', 'u', 'y', 'th', 'y', + // Converted Latin Extended-A letters. + 'A', 'a', 'A', 'a', 'A', 'a', 'C', 'c', 'C', 'c', 'C', 'c', 'C', 'c', + 'D', 'd', 'D', 'd', 'E', 'e', 'E', 'e', 'E', 'e', 'E', 'e', 'E', 'e', + 'G', 'g', 'G', 'g', 'G', 'g', 'G', 'g', 'H', 'h', 'H', 'h', + 'I', 'i', 'I', 'i', 'I', 'i', 'I', 'i', 'I', 'i', 'IJ', 'ij', 'J', 'j', + 'K', 'k', 'k', 'L', 'l', 'L', 'l', 'L', 'l', 'L', 'l', 'L', 'l', + 'N', 'n', 'N', 'n', 'N', 'n', "'n", 'N', 'n', + 'O', 'o', 'O', 'o', 'O', 'o', 'Oe', 'oe', + 'R', 'r', 'R', 'r', 'R', 'r', 'S', 's', 'S', 's', 'S', 's', 'S', 's', + 'T', 't', 'T', 't', 'T', 't', + 'U', 'u', 'U', 'u', 'U', 'u', 'U', 'u', 'U', 'u', 'U', 'u', + 'W', 'w', 'Y', 'y', 'Y', 'Z', 'z', 'Z', 'z', 'Z', 'z', 's' + ]; + + /** Used to provide falsey values to methods. */ + var falsey = [, null, undefined, false, 0, NaN, '']; + + /** Used to specify the emoji style glyph variant of characters. */ + var emojiVar = '\ufe0f'; + + /** Used to provide empty values to methods. */ + var empties = [[], {}].concat(falsey.slice(1)); + + /** Used to test error objects. */ + var errors = [ + new Error, + new EvalError, + new RangeError, + new ReferenceError, + new SyntaxError, + new TypeError, + new URIError + ]; + + /** List of fitzpatrick modifiers. */ + var fitzModifiers = [ + '\ud83c\udffb', + '\ud83c\udffc', + '\ud83c\udffd', + '\ud83c\udffe', + '\ud83c\udfff' + ]; + + /** Used to provide primitive values to methods. */ + var primitives = [null, undefined, false, true, 1, NaN, 'a']; + + /** Used to check whether methods support typed arrays. */ + var typedArrays = [ + 'Float32Array', + 'Float64Array', + 'Int8Array', + 'Int16Array', + 'Int32Array', + 'Uint8Array', + 'Uint8ClampedArray', + 'Uint16Array', + 'Uint32Array' + ]; + + /** Used to check whether methods support array views. */ + var arrayViews = typedArrays.concat('DataView'); + + /** The file path of the lodash file to test. */ var filePath = (function() { - var min = 0, - result = []; + var min = 2, + result = params || []; if (phantom) { - result = params = phantom.args; - } else if (system) { - min = 1; - result = params = system.args; - } else if (argv) { - min = 2; - result = params = argv; - } else if (params) { - result = params; + min = 0; + result = params = phantom.args || require('system').args; } var last = result[result.length - 1]; result = (result.length > min && !/test(?:\.js)?$/.test(last)) ? last : '../lodash.js'; if (!amd) { try { - return require('fs').realpathSync(result); - } catch(e) { } + result = require('fs').realpathSync(result); + } catch (e) {} + + try { + result = require.resolve(result); + } catch (e) {} } return result; }()); - /** The `ui` object */ + /** The `ui` object. */ var ui = root.ui || (root.ui = { 'buildPath': filePath, 'loaderPath': '', + 'isModularize': /\b(?:amd|commonjs|es|node|npm|(index|main)\.js)\b/.test(filePath), + 'isStrict': /\bes\b/.test(filePath) || 'default' in require(filePath), 'urlParams': {} }); - /** The basename of the Lo-Dash file to test */ + /** The basename of the lodash file to test. */ var basename = /[\w.-]+$/.exec(filePath)[0]; - /** Used to indicate testing a modularized build */ - var isModularize = ui.isModularize || /\b(?:commonjs|(index|main)\.js|lodash-(?:amd|node)|modularize|npm)\b/.test([ui.buildPath, ui.urlParams.build, basename]); + /** Used to indicate testing a modularized build. */ + var isModularize = ui.isModularize; - /** Detect if testing `npm` modules */ + /** Detect if testing `npm` modules. */ var isNpm = isModularize && /\bnpm\b/.test([ui.buildPath, ui.urlParams.build]); - /** Detect if running in Java */ - var isJava = !document && !!root.java; - - /** Detects if running in a PhantomJS web page */ - var isPhantomPage = typeof callPhantom == 'function'; + /** Detect if running in PhantomJS. */ + var isPhantom = phantom || (typeof callPhantom == 'function'); - /** Detect if running in Rhino */ - var isRhino = isJava && typeof global == 'function' && global().Array === root.Array; + /** Detect if lodash is in strict mode. */ + var isStrict = ui.isStrict; - /** Use a single "load" function */ - var load = (typeof require == 'function' && !amd) - ? require - : (isJava && root.load); + /*--------------------------------------------------------------------------*/ - /** The unit testing framework */ - var QUnit = (function() { - return root.QUnit || ( - root.addEventListener || (root.addEventListener = noop), - root.setTimeout || (root.setTimeout = noop), - root.QUnit = load('../vendor/qunit/qunit/qunit.js') || root.QUnit, - (load('../vendor/qunit-extras/qunit-extras.js') || { 'runInContext': noop }).runInContext(root), - addEventListener === noop && delete root.addEventListener, - root.QUnit - ); - }()); + // Leak to avoid sporadic `noglobals` fails on Edge in Sauce Labs. + root.msWDfn = undefined; - /*--------------------------------------------------------------------------*/ + // Assign `setTimeout` to itself to avoid being flagged as a leak. + setProperty(root, 'setTimeout', setTimeout); - // log params passed to `test.js` - if (params) { - console.log('test.js invoked with arguments: ' + JSON.stringify(slice.call(params))); - } - // exit early if going to run tests in a PhantomJS web page + // Exit early if going to run tests in a PhantomJS web page. if (phantom && isModularize) { var page = require('webpage').create(); - page.open(filePath, function(status) { - if (status != 'success') { - console.log('PhantomJS failed to load page: ' + filePath); - phantom.exit(1); - } - }); page.onCallback = function(details) { + var coverage = details.coverage; + if (coverage) { + var fs = require('fs'), + cwd = fs.workingDirectory, + sep = fs.separator; + + fs.write([cwd, 'coverage', 'coverage.json'].join(sep), JSON.stringify(coverage)); + } phantom.exit(details.failed ? 1 : 0); }; @@ -116,223 +287,521 @@ page.onInitialized = function() { page.evaluate(function() { document.addEventListener('DOMContentLoaded', function() { - QUnit.done(callPhantom); + QUnit.done(function(details) { + details.coverage = window.__coverage__; + callPhantom(details); + }); }); }); }; + page.open(filePath, function(status) { + if (status != 'success') { + console.log('PhantomJS failed to load page: ' + filePath); + phantom.exit(1); + } + }); + + console.log('test.js invoked with arguments: ' + JSON.stringify(slice.call(params))); return; } /*--------------------------------------------------------------------------*/ - /** The `lodash` function to test */ - var _ = root._ || (root._ = ( - _ = load(filePath) || root._, - _ = _._ || _, - (_.runInContext ? _.runInContext(root) : _) - )); + /** Used to test Web Workers. */ + var Worker = !(ui.isForeign || ui.isSauceLabs || isModularize) && + (document && document.origin != 'null') && root.Worker; - /** Used to pass falsey values to methods */ - var falsey = [, '', 0, false, NaN, null, undefined]; + /** Used to test host objects in IE. */ + try { + var xml = new ActiveXObject('Microsoft.XMLDOM'); + } catch (e) {} - /** Used to pass empty values to methods */ - var empties = [[], {}].concat(falsey.slice(1)); + /** Poison the free variable `root` in Node.js */ + try { + defineProperty(global.root, 'root', { + 'configurable': false, + 'enumerable': false, + 'get': function() { throw new ReferenceError; } + }); + } catch (e) {} - /** Used as the size when optimizations are enabled for large arrays */ - var largeArraySize = 75; + /** Load QUnit and extras. */ + var QUnit = root.QUnit || require('qunit-extras'); - /** Used to set property descriptors */ - var defineProperty = (function() { + /** Load stable Lodash. */ + var lodashStable = root.lodashStable; + if (!lodashStable) { try { - var o = {}, - func = Object.defineProperty, - result = func(o, o, o) && func; - } catch(e) { } + lodashStable = interopRequire('../node_modules/lodash/lodash.js'); + } catch (e) { + console.log('Error: The stable lodash dev dependency should be at least a version behind master branch.'); + return; + } + lodashStable = lodashStable.noConflict(); + } + + /** The `lodash` function to test. */ + var _ = root._ || (root._ = interopRequire(filePath)); + + /** Used to test pseudo private map caches. */ + var mapCaches = (function() { + var MapCache = (_.memoize || lodashStable.memoize).Cache; + var result = { + 'Hash': new MapCache().__data__.hash.constructor, + 'MapCache': MapCache + }; + (_.isMatchWith || lodashStable.isMatchWith)({ 'a': 1 }, { 'a': 1 }, function() { + var stack = lodashStable.last(arguments); + result.ListCache = stack.__data__.constructor; + result.Stack = stack.constructor; + }); return result; }()); - /** Used to check problem JScript properties (a.k.a. the [[DontEnum]] bug) */ - var shadowedProps = [ - 'constructor', - 'hasOwnProperty', - 'isPrototypeOf', - 'propertyIsEnumerable', - 'toLocaleString', - 'toString', - 'valueOf' - ]; + /** Used to detect instrumented istanbul code coverage runs. */ + var coverage = root.__coverage__ || root[lodashStable.find(lodashStable.keys(root), function(key) { + return /^(?:\$\$cov_\d+\$\$)$/.test(key); + })]; + + /** Used to test async functions. */ + var asyncFunc = lodashStable.attempt(function() { + return Function('return async () => {}'); + }); + + /** Used to test generator functions. */ + var genFunc = lodashStable.attempt(function() { + return Function('return function*(){}'); + }); + + /** Used to restore the `_` reference. */ + var oldDash = root._; + + /** + * Used to check for problems removing whitespace. For a whitespace reference, + * see [V8's unit test](https://code.google.com/p/v8/source/browse/branches/bleeding_edge/test/mjsunit/whitespaces.js). + */ + var whitespace = lodashStable.filter([ + // Basic whitespace characters. + ' ', '\t', '\x0b', '\f', '\xa0', '\ufeff', + + // Line terminators. + '\n', '\r', '\u2028', '\u2029', - /** Used to check problem JScript properties too */ - var shadowedObject = _.invert(shadowedProps); + // Unicode category "Zs" space separators. + '\u1680', '\u180e', '\u2000', '\u2001', '\u2002', '\u2003', '\u2004', '\u2005', + '\u2006', '\u2007', '\u2008', '\u2009', '\u200a', '\u202f', '\u205f', '\u3000' + ], + function(chr) { return /\s/.exec(chr); }) + .join(''); + + /** + * Creates a custom error object. + * + * @private + * @constructor + * @param {string} message The error message. + */ + function CustomError(message) { + this.name = 'CustomError'; + this.message = message; + } + + CustomError.prototype = lodashStable.create(Error.prototype, { + 'constructor': CustomError + }); /** - * Removes all own enumerable properties from a given object. + * Removes all own enumerable string keyed properties from a given object. * * @private * @param {Object} object The object to empty. */ function emptyObject(object) { - _.forOwn(object, function(value, key, object) { + lodashStable.forOwn(object, function(value, key, object) { delete object[key]; }); } + /** + * Extracts the unwrapped value from its wrapper. + * + * @private + * @param {Object} wrapper The wrapper to unwrap. + * @returns {*} Returns the unwrapped value. + */ + function getUnwrappedValue(wrapper) { + var index = -1, + actions = wrapper.__actions__, + length = actions.length, + result = wrapper.__wrapped__; + + while (++index < length) { + var args = [result], + action = actions[index]; + + push.apply(args, action.args); + result = action.func.apply(action.thisArg, args); + } + return result; + } + + /** + * Loads the module of `id`. If the module has an `exports.default`, the + * exported default value is returned as the resolved module. + * + * @private + * @param {string} id The identifier of the module to resolve. + * @returns {*} Returns the resolved module. + */ + function interopRequire(id) { + var result = require(id); + return 'default' in result ? result['default'] : result; + } + + /** + * Sets a non-enumerable property value on `object`. + * + * Note: This function is used to avoid a bug in older versions of V8 where + * overwriting non-enumerable built-ins makes them enumerable. + * See https://code.google.com/p/v8/issues/detail?id=1623 + * + * @private + * @param {Object} object The object modify. + * @param {string} key The name of the property to set. + * @param {*} value The property value. + */ + function setProperty(object, key, value) { + try { + defineProperty(object, key, { + 'configurable': true, + 'enumerable': false, + 'writable': true, + 'value': value + }); + } catch (e) { + object[key] = value; + } + return object; + } + /** * Skips a given number of tests with a passing result. * * @private + * @param {Object} assert The QUnit assert object. * @param {number} [count=1] The number of tests to skip. */ - function skipTest(count) { + function skipAssert(assert, count) { count || (count = 1); while (count--) { - ok(true, 'test skipped'); + assert.ok(true, 'test skipped'); } } + /** + * Converts `array` to an `arguments` object. + * + * @private + * @param {Array} array The array to convert. + * @returns {Object} Returns the converted `arguments` object. + */ + function toArgs(array) { + return (function() { return arguments; }.apply(undefined, array)); + } + /*--------------------------------------------------------------------------*/ - // add values from other realms + // Add bizarro values. (function() { - if (!amd) { - try { - emptyObject(require.cache); + if (document || (typeof require != 'function')) { + return; + } + var nativeString = fnToString.call(toString), + reToString = /toString/g; - _.extend(_, require('vm').runInNewContext([ - '({', - "'_arguments': (function() { return arguments; }(1, 2, 3)),", - "'_array': [1, 2, 3],", - "'_boolean': new Boolean(false),", - "'_date': new Date,", - "'_function': function() {},", - "'_nan': NaN,", - "'_null': null,", - "'_number': new Number(0),", - "'_object': { 'a': 1, 'b': 2, 'c': 3 },", - "'_regexp': /x/,", - "'_string': new String('a'),", - "'_undefined': undefined,", - '})' - ].join('\n'))); - - // set bad shims - Array._isArray = Array.isArray; - Array.isArray = function() {}; - - Date._now = Date.now; - Date.now = function() {}; - - Function.prototype._bind = Function.prototype.bind; - Function.prototype.bind = function() { return function() {}; }; - - Object._create = Object.create; - Object.create = function() {}; - - Object._defineProperty = Object.defineProperty; - Object.defineProperty = function() {}; - - Object._getPrototypeOf = Object.getPrototypeOf; - Object.getPrototypeOf = function() {}; - - Object._keys = Object.keys; - Object.keys = function() {}; - - // load Lo-Dash and expose it to the bad shims - lodashBadShim = (lodashBadShim = require(filePath))._ || lodashBadShim; - - // restore native methods - Array.isArray = Array._isArray; - Date.now = Date._now; - Function.prototype.bind = Function.prototype._bind; - Object.create = Object._create; - Object.defineProperty = Object._defineProperty; - Object.getPrototypeOf = Object._getPrototypeOf; - Object.keys = Object._keys; - - delete Array._isArray; - delete Date._now; - delete Function.prototype._bind; - delete Object._create; - delete Object._defineProperty; - delete Object._getPrototypeOf; - delete Object._keys; - } catch(e) { } + function createToString(funcName) { + return lodashStable.constant(nativeString.replace(reToString, funcName)); } - if (!_._object && document) { - var iframe = document.createElement('iframe'); - iframe.frameBorder = iframe.height = iframe.width = 0; - body.appendChild(iframe); - - var idoc = (idoc = iframe.contentDocument || iframe.contentWindow).document || idoc; - idoc.write([ - '', + '', + '' + ].join('\n')); + + idoc.close(); + delete _._realm; + }); + + // Add a web worker. + lodashStable.attempt(function() { var worker = new Worker('./asset/worker.js?t=' + (+new Date)); worker.addEventListener('message', function(e) { _._VERSION = e.data || ''; }, false); worker.postMessage(ui.buildPath); - }()); + }); + + // Expose internal modules for better code coverage. + lodashStable.attempt(function() { + var path = require('path'), + basePath = path.dirname(filePath); + + if (isModularize && !(amd || isNpm)) { + lodashStable.each([ + 'baseEach', + 'isIndex', + 'isIterateeCall', + 'memoizeCapped' + ], function(funcName) { + _['_' + funcName] = interopRequire(path.join(basePath, '_' + funcName)); + }); + } + }); /*--------------------------------------------------------------------------*/ - // explicitly call `QUnit.module()` instead of `module()` - // in case we are in a CLI environment + if (params) { + console.log('Running lodash tests.'); + console.log('test.js invoked with arguments: ' + JSON.stringify(slice.call(params))); + } + QUnit.module(basename); (function() { - test('supports loading ' + basename + ' as the "lodash" module', 1, function() { + QUnit.test('should support loading ' + basename + ' as the "lodash" module', function(assert) { + assert.expect(1); + if (amd) { - equal((lodashModule || {}).moduleName, 'lodash'); - } else { - skipTest(); + assert.strictEqual((lodashModule || {}).moduleName, 'lodash'); + } + else { + skipAssert(assert); } }); - test('supports loading ' + basename + ' with the Require.js "shim" configuration option', 1, function() { - if (amd && /requirejs/.test(ui.loaderPath)) { - equal((shimmedModule || {}).moduleName, 'shimmed'); + QUnit.test('should support loading ' + basename + ' with the Require.js "shim" configuration option', function(assert) { + assert.expect(1); + + if (amd && lodashStable.includes(ui.loaderPath, 'requirejs')) { + assert.strictEqual((shimmedModule || {}).moduleName, 'shimmed'); } else { - skipTest(); + skipAssert(assert); } }); - test('supports loading ' + basename + ' as the "underscore" module', 1, function() { - if (amd && !/dojo/.test(ui.loaderPath)) { - equal((underscoreModule || {}).moduleName, 'underscore'); - } else { - skipTest(); + QUnit.test('should support loading ' + basename + ' as the "underscore" module', function(assert) { + assert.expect(1); + + if (amd) { + assert.strictEqual((underscoreModule || {}).moduleName, 'underscore'); + } + else { + skipAssert(assert); } }); - asyncTest('supports loading ' + basename + ' in a web worker', 1, function() { - if (Worker && !isModularize) { - var limit = 15000, + QUnit.test('should support loading ' + basename + ' in a web worker', function(assert) { + assert.expect(1); + + var done = assert.async(); + + if (Worker) { + var limit = 30000 / QUnit.config.asyncRetries, start = +new Date; var attempt = function() { @@ -341,7945 +810,25725 @@ setTimeout(attempt, 16); return; } - equal(actual, _.VERSION); - QUnit.start(); + assert.strictEqual(actual, _.VERSION); + done(); }; attempt(); } else { - skipTest(); - QUnit.start(); + skipAssert(assert); + done(); } }); - test('avoids overwritten native methods', 7, function() { - function Foo() {} + QUnit.test('should not add `Function.prototype` extensions to lodash', function(assert) { + assert.expect(1); - function message(methodName) { - return '`_.' + methodName + '` should avoid overwritten native methods'; + if (lodashBizarro) { + assert.notOk('_method' in lodashBizarro); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should avoid non-native built-ins', function(assert) { + assert.expect(6); + + function message(lodashMethod, nativeMethod) { + return '`' + lodashMethod + '` should avoid overwritten native `' + nativeMethod + '`'; + } + + function Foo() { + this.a = 1; } - var object = { 'a': true }; + Foo.prototype.b = 2; + + var object = { 'a': 1 }, + otherObject = { 'b': 2 }, + largeArray = lodashStable.times(LARGE_ARRAY_SIZE, lodashStable.constant(object)); - if (lodashBadShim) { + if (lodashBizarro) { try { - actual = [lodashBadShim.isArray([]), lodashBadShim.isArray({ 'length': 0 })]; - } catch(e) { + var actual = lodashBizarro.create(Foo.prototype); + } catch (e) { actual = null; } - deepEqual(actual, [true, false], message('Array.isArray')); + var label = message('_.create', 'Object.create'); + assert.ok(actual instanceof Foo, label); try { - actual = lodashBadShim.now(); - } catch(e) { + actual = [ + lodashBizarro.difference([object, otherObject], largeArray), + lodashBizarro.intersection(largeArray, [object]), + lodashBizarro.uniq(largeArray) + ]; + } catch (e) { actual = null; } - ok(typeof actual == 'number', message('Date.now')); + label = message('_.difference`, `_.intersection`, and `_.uniq', 'Map'); + assert.deepEqual(actual, [[otherObject], [object], [object]], label); try { - actual = [lodashBadShim.create(Foo.prototype, object), lodashBadShim.create()]; - } catch(e) { + if (Symbol) { + object[symbol] = {}; + } + actual = [ + lodashBizarro.clone(object), + lodashBizarro.cloneDeep(object) + ]; + } catch (e) { actual = null; } - ok(actual[0] instanceof Foo, message('Object.create')); - deepEqual(actual[1], {}, message('Object.create')); + label = message('_.clone` and `_.cloneDeep', 'Object.getOwnPropertySymbols'); + assert.deepEqual(actual, [object, object], label); try { - var actual = lodashBadShim.bind(function() { return this.a; }, object)(); - } catch(e) { + // Avoid buggy symbol detection in Babel's `_typeof` helper. + var symObject = setProperty(Object(symbol), 'constructor', Object); + actual = [ + Symbol ? lodashBizarro.clone(symObject) : {}, + Symbol ? lodashBizarro.isEqual(symObject, Object(symbol)) : false, + Symbol ? lodashBizarro.toString(symObject) : '' + ]; + } catch (e) { actual = null; } - ok(actual, message('Object.defineProperty')); + label = message('_.clone`, `_.isEqual`, and `_.toString', 'Symbol'); + assert.deepEqual(actual, [{}, false, ''], label); try { - actual = [lodashBadShim.isPlainObject({}), lodashBadShim.isPlainObject([])]; - } catch(e) { + var map = new lodashBizarro.memoize.Cache; + actual = map.set('a', 1).get('a'); + } catch (e) { actual = null; } - deepEqual(actual, [true, false], message('Object.getPrototypeOf')); + label = message('_.memoize.Cache', 'Map'); + assert.deepEqual(actual, 1, label); try { - actual = [lodashBadShim.keys(object), lodashBadShim.keys()]; - } catch(e) { + map = new (Map || Object); + if (Symbol && Symbol.iterator) { + map[Symbol.iterator] = null; + } + actual = lodashBizarro.toArray(map); + } catch (e) { actual = null; } - deepEqual(actual, [['a'], []], message('Object.keys')); + label = message('_.toArray', 'Map'); + assert.deepEqual(actual, [], label); } else { - skipTest(7); + skipAssert(assert, 6); } }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash constructor'); + QUnit.module('isIndex'); (function() { - test('creates a new instance when called without the `new` operator', 1, function() { - ok(_() instanceof _); - }); + var func = _._isIndex; - test('should return provided `lodash` instances', 1,function() { - var wrapped = _(false); - equal(_(wrapped), wrapped); - }); - }()); + QUnit.test('should return `true` for indexes', function(assert) { + assert.expect(1); - /*--------------------------------------------------------------------------*/ + if (func) { + var values = [[0], ['0'], ['1'], [3, 4], [MAX_SAFE_INTEGER - 1]], + expected = lodashStable.map(values, stubTrue); - QUnit.module('lodash.after'); + var actual = lodashStable.map(values, function(args) { + return func.apply(undefined, args); + }); - (function() { - test('should create a function that executes `func` after `n` calls', 4, function() { - function after(n, times) { - var count = 0; - _.times(times, _.after(n, function() { count++; })); - return count; + assert.deepEqual(actual, expected); } + else { + skipAssert(assert); + } + }); + + QUnit.test('should return `false` for non-indexes', function(assert) { + assert.expect(1); - strictEqual(after(5, 5), 1, 'after(n) should execute `func` after being called `n` times'); - strictEqual(after(5, 4), 0, 'after(n) should not execute `func` unless called `n` times'); - strictEqual(after(0, 0), 0, 'after(0) should not execute `func` immediately'); - strictEqual(after(0, 1), 1, 'after(0) should execute `func` when called once'); + if (func) { + var values = [['1abc'], ['07'], ['0001'], [-1], [3, 3], [1.1], [MAX_SAFE_INTEGER]], + expected = lodashStable.map(values, stubFalse); + + var actual = lodashStable.map(values, function(args) { + return func.apply(undefined, args); + }); + + assert.deepEqual(actual, expected); + } + else { + skipAssert(assert); + } }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.assign'); + QUnit.module('isIterateeCall'); (function() { - test('should assign properties of a source object to the destination object', 1, function() { - deepEqual(_.assign({ 'a': 1 }, { 'b': 2 }), { 'a': 1, 'b': 2 }); - }); + var array = [1], + func = _._isIterateeCall, + object = { 'a': 1 }; - test('should assign own source properties', 1, function() { - function Foo() { - this.a = 1; - this.c = 3; - } + QUnit.test('should return `true` for iteratee calls', function(assert) { + assert.expect(3); - Foo.prototype.b = 2; - deepEqual(_.assign({}, new Foo), { 'a': 1, 'c': 3 }); - }); + function Foo() {} + Foo.prototype.a = 1; - test('should accept multiple source objects', 2, function() { - var expected = { 'a': 1, 'b': 2, 'c': 3 }; - deepEqual(_.assign({ 'a': 1 }, { 'b': 2 }, { 'c': 3 }), expected); - deepEqual(_.assign({ 'a': 1 }, { 'b': 2, 'c': 2 }, { 'c': 3 }), expected); + if (func) { + assert.strictEqual(func(1, 0, array), true); + assert.strictEqual(func(1, 'a', object), true); + assert.strictEqual(func(1, 'a', new Foo), true); + } + else { + skipAssert(assert, 3); + } }); - test('should overwrite source properties', 1, function() { - var expected = { 'a': 3, 'b': 2, 'c': 1 }; - deepEqual(_.assign({ 'a': 1, 'b': 2 }, expected), expected); + QUnit.test('should return `false` for non-iteratee calls', function(assert) { + assert.expect(4); + + if (func) { + assert.strictEqual(func(2, 0, array), false); + assert.strictEqual(func(1, 1.1, array), false); + assert.strictEqual(func(1, 0, { 'length': MAX_SAFE_INTEGER + 1 }), false); + assert.strictEqual(func(1, 'b', object), false); + } + else { + skipAssert(assert, 4); + } }); - test('should assign source properties with `null` and `undefined` values', 1, function() { - var expected = { 'a': null, 'b': undefined, 'c': null }; - deepEqual(_.assign({ 'a': 1, 'b': 2 }, expected), expected); + QUnit.test('should work with `NaN` values', function(assert) { + assert.expect(2); + + if (func) { + assert.strictEqual(func(NaN, 0, [NaN]), true); + assert.strictEqual(func(NaN, 'a', { 'a': NaN }), true); + } + else { + skipAssert(assert, 2); + } }); - test('should not error on `null` or `undefined` sources (test in IE < 9)', 1, function() { - try { - deepEqual(_.assign({}, null, undefined, { 'a': 1 }), { 'a': 1 }); - } catch(e) { - ok(false); + QUnit.test('should not error when `index` is an object without a `toString` method', function(assert) { + assert.expect(1); + + if (func) { + try { + var actual = func(1, { 'toString': null }, [1]); + } catch (e) { + var message = e.message; + } + assert.strictEqual(actual, false, message || ''); + } + else { + skipAssert(assert); } }); + }()); - test('should work with a `callback`', 1, function() { - var actual = _.assign({ 'a': 1, 'b': 2 }, { 'a': 3, 'c': 3 }, function(a, b) { - return typeof a == 'undefined' ? b : a; - }); + /*--------------------------------------------------------------------------*/ + + QUnit.module('map caches'); + + (function() { + var keys = [null, undefined, false, true, 1, -Infinity, NaN, {}, 'a', symbol || noop]; - deepEqual(actual, { 'a': 1, 'b': 2, 'c': 3 }); + var pairs = lodashStable.map(keys, function(key, index) { + var lastIndex = keys.length - 1; + return [key, keys[lastIndex - index]]; }); - test('should pass the correct `callback` arguments', 1, function() { - var args; + function createCaches(pairs) { + var largeStack = new mapCaches.Stack(pairs), + length = pairs ? pairs.length : 0; - _.assign({ 'a': 1 }, { 'b': 2 }, function() { - args || (args = slice.call(arguments)); + lodashStable.times(LARGE_ARRAY_SIZE - length, function() { + largeStack.set({}, {}); }); - deepEqual(args, [undefined, 2]); - }); + return { + 'hashes': new mapCaches.Hash(pairs), + 'list caches': new mapCaches.ListCache(pairs), + 'map caches': new mapCaches.MapCache(pairs), + 'stack caches': new mapCaches.Stack(pairs), + 'large stacks': largeStack + }; + } + + lodashStable.forOwn(createCaches(pairs), function(cache, kind) { + var isLarge = /^large/.test(kind); + + QUnit.test('should implement a `Map` interface for ' + kind, function(assert) { + assert.expect(83); - test('should support the `thisArg` argument', 1, function() { - var actual = _.assign({ 'a': 1, 'b': 2 }, { 'a': 3, 'c': 3 }, function(a, b) { - return typeof this[a] == 'undefined' ? this[b] : this[a]; - }, { '1': 1, '2': 2, '3': 3 }); + lodashStable.each(keys, function(key, index) { + var value = pairs[index][1]; - deepEqual(actual, { 'a': 1, 'b': 2, 'c': 3 }); + assert.deepEqual(cache.get(key), value); + assert.strictEqual(cache.has(key), true); + assert.strictEqual(cache.delete(key), true); + assert.strictEqual(cache.has(key), false); + assert.strictEqual(cache.get(key), undefined); + assert.strictEqual(cache.delete(key), false); + assert.strictEqual(cache.set(key, value), cache); + assert.strictEqual(cache.has(key), true); + }); + + assert.strictEqual(cache.size, isLarge ? LARGE_ARRAY_SIZE : keys.length); + assert.strictEqual(cache.clear(), undefined); + assert.ok(lodashStable.every(keys, function(key) { + return !cache.has(key); + })); + }); }); - test('should be aliased', 1, function() { - strictEqual(_.extend, _.assign); + lodashStable.forOwn(createCaches(), function(cache, kind) { + QUnit.test('should support changing values of ' + kind, function(assert) { + assert.expect(10); + + lodashStable.each(keys, function(key) { + cache.set(key, 1).set(key, 2); + assert.strictEqual(cache.get(key), 2); + }); + }); }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.at'); + QUnit.module('lodash constructor'); (function() { - var args = arguments; - - test('should return `undefined` for nonexistent keys', 1, function() { - var actual = _.at(['a', 'b', 'c'], [0, 2, 4]); - deepEqual(actual, ['a', 'c', undefined]); - }); + var values = empties.concat(true, 1, 'a'), + expected = lodashStable.map(values, stubTrue); - test('should return an empty array when no keys are provided', 1, function() { - deepEqual(_.at(['a', 'b', 'c']), []); - }); + QUnit.test('should create a new instance when called without the `new` operator', function(assert) { + assert.expect(1); - test('should accept multiple key arguments', 1, function() { - var actual = _.at(['a', 'b', 'c', 'd'], 0, 2, 3); - deepEqual(actual, ['a', 'c', 'd']); - }); - - test('should work with an `arguments` object for `collection`', 1, function() { - var actual = _.at(args, [0, 2]); - deepEqual(actual, ['a', 'c']); - }); - - test('should work with an object for `collection`', 1, function() { - var actual = _.at({ 'a': 1, 'b': 2, 'c': 3 }, ['a', 'c']); - deepEqual(actual, [1, 3]); - }); - - test('should work when used as `callback` for `_.map`', 1, function() { - var array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]], - actual = _.map(array, _.at); - - deepEqual(actual, [[1], [5], [9]]); - }); - - _.forEach({ - 'literal': 'abc', - 'object': Object('abc') - }, - function(collection, key) { - test('should work with a string ' + key + ' for `collection`', 1, function() { - deepEqual(_.at(collection, [0, 2]), ['a', 'c']); - }); - }); - }('a', 'b', 'c')); - - /*--------------------------------------------------------------------------*/ - - QUnit.module('lodash.bind'); - - (function() { - function func() { - var args = [this]; - push.apply(args, arguments); - return args; - } - - test('should bind a function to an object', 1, function() { - var object = {}, - bound = _.bind(func, object); + if (!isNpm) { + var actual = lodashStable.map(values, function(value) { + return _(value) instanceof _; + }); - deepEqual(bound('a'), [object, 'a']); + assert.deepEqual(actual, expected); + } + else { + skipAssert(assert); + } }); - test('should accept a falsey `thisArg` argument', 1, function() { - var values = _.reject(falsey.slice(1), function(value) { return value == null; }), - expected = _.map(values, function(value) { return [value]; }); + QUnit.test('should return the given `lodash` instances', function(assert) { + assert.expect(1); - var actual = _.map(values, function(value, index) { - try { - var bound = _.bind(func, value); - return bound(); - } catch(e) { } - }); + if (!isNpm) { + var actual = lodashStable.map(values, function(value) { + var wrapped = _(value); + return _(wrapped) === wrapped; + }); - ok(_.every(actual, function(value, index) { - return _.isEqual(value, expected[index]); - })); + assert.deepEqual(actual, expected); + } + else { + skipAssert(assert); + } }); - test('should bind a function to `null` or `undefined`', 4, function() { - var bound = _.bind(func, null), - actual = bound('a'); + QUnit.test('should convert foreign wrapped values to `lodash` instances', function(assert) { + assert.expect(1); - ok(actual[0] === null || actual[0] && actual[0].Array); - equal(actual[1], 'a'); + if (!isNpm && lodashBizarro) { + var actual = lodashStable.map(values, function(value) { + var wrapped = _(lodashBizarro(value)), + unwrapped = wrapped.value(); - bound = _.bind(func, undefined); - actual = bound('b'); + return wrapped instanceof _ && + ((unwrapped === value) || (unwrapped !== unwrapped && value !== value)); + }); - ok(actual[0] === undefined || actual[0] && actual[0].Array); - equal(actual[1], 'b'); + assert.deepEqual(actual, expected); + } + else { + skipAssert(assert); + } }); + }()); - test('should partially apply arguments ', 4, function() { - var object = {}, - bound = _.bind(func, object, 'a'); - - deepEqual(bound(), [object, 'a']); - - bound = _.bind(func, object, 'a'); - deepEqual(bound('b'), [object, 'a', 'b']); + /*--------------------------------------------------------------------------*/ - bound = _.bind(func, object, 'a', 'b'); - deepEqual(bound(), [object, 'a', 'b']); - deepEqual(bound('c', 'd'), [object, 'a', 'b', 'c', 'd']); - }); + QUnit.module('lodash.add'); - test('bound functions should have a `length` of `0`', 1, function() { - var func = function(a, b, c) {}, - bound = _.bind(func, {}); + (function() { + QUnit.test('should add two numbers', function(assert) { + assert.expect(3); - strictEqual(bound.length, 0); + assert.strictEqual(_.add(6, 4), 10); + assert.strictEqual(_.add(-6, 4), -2); + assert.strictEqual(_.add(-6, -4), -10); }); - test('should ignore binding when called with the `new` operator', 3, function() { - function Foo() { - return this; - } - var bound = _.bind(Foo, { 'a': 1 }), - newBound = new bound; + QUnit.test('should not coerce arguments to numbers', function(assert) { + assert.expect(2); - strictEqual(newBound.a, undefined); - strictEqual(bound().a, 1); - ok(newBound instanceof Foo); + assert.strictEqual(_.add('6', '4'), '64'); + assert.strictEqual(_.add('x', 'y'), 'xy'); }); + }()); - test('ensure `new bound` is an instance of `func`', 2, function() { - function Foo(value) { - return value && object; - } - var bound = _.bind(Foo), - object = {}; + /*--------------------------------------------------------------------------*/ - ok(new bound instanceof Foo); - strictEqual(new bound(true), object); - }); + QUnit.module('lodash.after'); - test('should append array arguments to partially applied arguments (test in IE < 9)', 1, function() { - var object = {}, - bound = _.bind(func, object, 'a'); + (function() { + function after(n, times) { + var count = 0; + lodashStable.times(times, _.after(n, function() { count++; })); + return count; + } - deepEqual(bound(['b'], 'c'), [object, 'a', ['b'], 'c']); - }); + QUnit.test('should create a function that invokes `func` after `n` calls', function(assert) { + assert.expect(4); - test('should throw a TypeError if `func` is not a function', 1, function() { - raises(function() { _.bind(); }, TypeError); + assert.strictEqual(after(5, 5), 1, 'after(n) should invoke `func` after being called `n` times'); + assert.strictEqual(after(5, 4), 0, 'after(n) should not invoke `func` before being called `n` times'); + assert.strictEqual(after(0, 0), 0, 'after(0) should not invoke `func` immediately'); + assert.strictEqual(after(0, 1), 1, 'after(0) should invoke `func` when called once'); }); - test('should return a wrapped value when chaining', 2, function() { - if (!isNpm) { - var object = {}, - bound = _(func).bind({}, 'a', 'b'); - - ok(bound instanceof _); + QUnit.test('should coerce `n` values of `NaN` to `0`', function(assert) { + assert.expect(1); - var actual = bound.value()('c'); - deepEqual(actual, [object, 'a', 'b', 'c']); - } - else { - skipTest(2); - } + assert.strictEqual(after(NaN, 1), 1); }); - test('should rebind functions correctly', 3, function() { - var object1 = {}, - object2 = {}, - object3 = {}; + QUnit.test('should use `this` binding of function', function(assert) { + assert.expect(2); - var bound1 = _.bind(func, object1), - bound2 = _.bind(bound1, object2, 'a'), - bound3 = _.bind(bound1, object3, 'b'); + var after = _.after(1, function(assert) { return ++this.count; }), + object = { 'after': after, 'count': 0 }; - deepEqual(bound1(), [object1]); - deepEqual(bound2(), [object1, 'a']); - deepEqual(bound3(), [object1, 'b']); + object.after(); + assert.strictEqual(object.after(), 2); + assert.strictEqual(object.count, 2); }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.bindAll'); + QUnit.module('lodash.ary'); (function() { - var args = arguments; + function fn(a, b, c) { + return slice.call(arguments); + } - test('should bind all methods of `object`', 1, function() { - function Foo() { - this._a = 1; - this._b = 2; - this.a = function() { return this._a; }; - }; + QUnit.test('should cap the number of arguments provided to `func`', function(assert) { + assert.expect(2); - Foo.prototype.b = function() { return this._b; }; + var actual = lodashStable.map(['6', '8', '10'], _.ary(parseInt, 1)); + assert.deepEqual(actual, [6, 8, 10]); - var object = new Foo; - _.bindAll(object); + var capped = _.ary(fn, 2); + assert.deepEqual(capped('a', 'b', 'c', 'd'), ['a', 'b']); + }); - var actual = _.map(_.functions(object), function(methodName) { - return object[methodName].call({}); - }); + QUnit.test('should use `func.length` if `n` is not given', function(assert) { + assert.expect(1); - deepEqual(actual, [1, 2]); + var capped = _.ary(fn); + assert.deepEqual(capped('a', 'b', 'c', 'd'), ['a', 'b', 'c']); }); - test('should accept individual method names', 1, function() { - var object = { - '_a': 1, - '_b': 2, - '_c': 3, - 'a': function() { return this._a; }, - 'b': function() { return this._b; }, - 'c': function() { return this._c; } - }; + QUnit.test('should treat a negative `n` as `0`', function(assert) { + assert.expect(1); - _.bindAll(object, 'a', 'b'); + var capped = _.ary(fn, -1); - var actual = _.map(_.functions(object), function(methodName) { - return object[methodName].call({}); - }); + try { + var actual = capped('a'); + } catch (e) {} - deepEqual(actual, [1, 2, undefined]); + assert.deepEqual(actual, []); }); - test('should accept arrays of method names', 1, function() { - var object = { - '_a': 1, - '_b': 2, - '_c': 3, - '_d': 4, - 'a': function() { return this._a; }, - 'b': function() { return this._b; }, - 'c': function() { return this._c; }, - 'd': function() { return this._d; } - }; + QUnit.test('should coerce `n` to an integer', function(assert) { + assert.expect(1); - _.bindAll(object, ['a', 'b'], ['c']); + var values = ['1', 1.6, 'xyz'], + expected = [['a'], ['a'], []]; - var actual = _.map(_.functions(object), function(methodName) { - return object[methodName].call({}); + var actual = lodashStable.map(values, function(n) { + var capped = _.ary(fn, n); + return capped('a', 'b'); }); - deepEqual(actual, [1, 2, 3, undefined]); + assert.deepEqual(actual, expected); }); - test('should work with an array `object` argument', 1, function() { - var array = ['push', 'pop']; - _.bindAll(array); - strictEqual(array.pop, Array.prototype.pop); - }); + QUnit.test('should not force a minimum argument count', function(assert) { + assert.expect(1); - test('should work with `arguments` objects as secondary arguments', 1, function() { - var object = { - '_a': 1, - 'a': function() { return this._a; } - }; + var args = ['a', 'b', 'c'], + capped = _.ary(fn, 3); - _.bindAll(object, args); + var expected = lodashStable.map(args, function(arg, index) { + return args.slice(0, index); + }); - var actual = _.map(_.functions(object), function(methodName) { - return object[methodName].call({}); + var actual = lodashStable.map(expected, function(array) { + return capped.apply(undefined, array); }); - deepEqual(actual, [1]); + assert.deepEqual(actual, expected); }); - }('a')); - - /*--------------------------------------------------------------------------*/ - - QUnit.module('lodash.bindKey'); - (function() { - test('should work when the target function is overwritten', 2, function() { - var object = { - 'name': 'fred', - 'greet': function(greeting) { - return greeting + ' ' + this.name; - } - }; + QUnit.test('should use `this` binding of function', function(assert) { + assert.expect(1); - var func = _.bindKey(object, 'greet', 'hi'); - equal(func(), 'hi fred'); + var capped = _.ary(function(a, b) { return this; }, 1), + object = { 'capped': capped }; - object.greet = function(greeting) { - return greeting + ' ' + this.name + '!'; - }; - equal(func(), 'hi fred!'); + assert.strictEqual(object.capped(), object); }); - }()); + QUnit.test('should use the existing `ary` if smaller', function(assert) { + assert.expect(1); - /*--------------------------------------------------------------------------*/ + var capped = _.ary(_.ary(fn, 1), 2); + assert.deepEqual(capped('a', 'b', 'c'), ['a']); + }); - QUnit.module('lodash.chain'); + QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) { + assert.expect(1); - (function() { - test('should return a wrapped value', 1, function() { - if (!isNpm) { - var actual = _.chain({ 'a': 0 }); - ok(actual instanceof _); - } - else { - skipTest(); - } - }); + var funcs = lodashStable.map([fn], _.ary), + actual = funcs[0]('a', 'b', 'c'); - test('should return the existing wrapper when chaining', 1, function() { - if (!isNpm) { - var wrapper = _({ 'a': 0 }); - equal(wrapper.chain(), wrapper); - } - else { - skipTest(); - } + assert.deepEqual(actual, ['a', 'b', 'c']); }); - test('should enable chaining of methods that return unwrapped values by default', 6, function() { - if (!isNpm) { - var array = ['c', 'b', 'a']; + QUnit.test('should work when combined with other methods that use metadata', function(assert) { + assert.expect(2); - ok(_.chain(array).first() instanceof _); - ok(_(array).chain().first() instanceof _); + var array = ['a', 'b', 'c'], + includes = _.curry(_.rearg(_.ary(_.includes, 2), 1, 0), 2); - ok(_.chain(array).isArray() instanceof _); - ok(_(array).chain().isArray() instanceof _); + assert.strictEqual(includes('b')(array, 2), true); - ok(_.chain(array).sortBy().first() instanceof _); - ok(_(array).chain().sortBy().first() instanceof _); + if (!isNpm) { + includes = _(_.includes).ary(2).rearg(1, 0).curry(2).value(); + assert.strictEqual(includes('b')(array, 2), true); } else { - skipTest(6); + skipAssert(assert); } }); + }()); - test('should chain multiple methods', 6, function() { - if (!isNpm) { - _.times(2, function(index) { - var array = ['one two three four', 'five six seven eight', 'nine ten eleven twelve'], - expected = { ' ': 9, 'e': 14, 'f': 2, 'g': 1, 'h': 2, 'i': 4, 'l': 2, 'n': 6, 'o': 3, 'r': 2, 's': 2, 't': 5, 'u': 1, 'v': 4, 'w': 2, 'x': 1 }, - wrapper = index ? _(array).chain() : _.chain(array); - - var actual = wrapper - .chain() - .map(function(value) { return value.split(''); }) - .flatten() - .reduce(function(object, chr) { - object[chr] || (object[chr] = 0); - object[chr]++; - return object; - }, {}) - .value(); - - deepEqual(actual, expected); - - array = [1, 2, 3, 4, 5, 6]; - wrapper = index ? _(array).chain() : _.chain(array); - actual = wrapper - .chain() - .filter(function(n) { return n % 2; }) - .reject(function(n) { return n % 3 == 0; }) - .sortBy(function(n) { return -n; }) - .value(); + /*--------------------------------------------------------------------------*/ - deepEqual(actual, [5, 1]); + QUnit.module('lodash.assignIn'); - array = [3, 4]; - wrapper = index ? _(array).chain() : _.chain(array); - actual = wrapper - .reverse() - .concat([2, 1]) - .unshift(5) - .tap(function(value) { value.pop(); }) - .map(function(n) { return n * n; }) - .value(); + (function() { + QUnit.test('should be aliased', function(assert) { + assert.expect(1); - deepEqual(actual,[25, 16, 9, 4]); - }); - } - else { - skipTest(6); - } + assert.strictEqual(_.extend, _.assignIn); }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('cloning'); + QUnit.module('lodash.assign and lodash.assignIn'); - (function() { - function Klass() { this.a = 1; } - Klass.prototype = { 'b': 1 }; + lodashStable.each(['assign', 'assignIn'], function(methodName) { + var func = _[methodName]; - var nonCloneable = { - 'an element': body, - 'a function': Klass - }; + QUnit.test('`_.' + methodName + '` should assign source properties to `object`', function(assert) { + assert.expect(1); - var objects = { - 'an `arguments` object': arguments, - 'an array': ['a', 'b', 'c', ''], - 'an array-like-object': { '0': 'a', '1': 'b', '2': 'c', '3': '', 'length': 5 }, - 'boolean': false, - 'boolean object': Object(false), - 'a Klass instance': new Klass, - 'an object': { 'a': 0, 'b': 1, 'c': 3 }, - 'an object with object values': { 'a': /a/, 'b': ['B'], 'c': { 'C': 1 } }, - 'an object from another document': _._object || {}, - 'null': null, - 'a number': 3, - 'a number object': Object(3), - 'a regexp': /a/gim, - 'a string': 'a', - 'a string object': Object('a'), - 'undefined': undefined - }; + assert.deepEqual(func({ 'a': 1 }, { 'b': 2 }), { 'a': 1, 'b': 2 }); + }); - objects['an array'].length = 5; + QUnit.test('`_.' + methodName + '` should accept multiple sources', function(assert) { + assert.expect(2); - test('`_.clone` should shallow clone by default', 2, function() { - var expected = [{ 'a': 0 }, { 'b': 1 }], - actual = _.clone(expected); + var expected = { 'a': 1, 'b': 2, 'c': 3 }; + assert.deepEqual(func({ 'a': 1 }, { 'b': 2 }, { 'c': 3 }), expected); + assert.deepEqual(func({ 'a': 1 }, { 'b': 2, 'c': 2 }, { 'c': 3 }), expected); + }); - deepEqual(actual, expected); - ok(actual != expected && actual[0] === expected[0]); + QUnit.test('`_.' + methodName + '` should overwrite destination properties', function(assert) { + assert.expect(1); + + var expected = { 'a': 3, 'b': 2, 'c': 1 }; + assert.deepEqual(func({ 'a': 1, 'b': 2 }, expected), expected); }); - test('`_.clone` should perform a shallow clone when used as `callback` for `_.map`', 1, function() { - var expected = [{ 'a': [0] }, { 'b': [1] }], - actual = _.map(expected, _.clone); + QUnit.test('`_.' + methodName + '` should assign source properties with nullish values', function(assert) { + assert.expect(1); - ok(actual[0] != expected[0] && actual[0].a === expected[0].a && actual[1].b === expected[1].b); + var expected = { 'a': null, 'b': undefined, 'c': null }; + assert.deepEqual(func({ 'a': 1, 'b': 2 }, expected), expected); }); - test('`_.cloneDeep` should deep clone objects with circular references', 1, function() { - var object = { - 'foo': { 'b': { 'foo': { 'c': { } } } }, - 'bar': { } - }; + QUnit.test('`_.' + methodName + '` should skip assignments if values are the same', function(assert) { + assert.expect(1); - object.foo.b.foo.c = object; - object.bar.b = object.foo.b; + var object = {}; - var clone = _.cloneDeep(object); - ok(clone.bar.b === clone.foo.b && clone === clone.foo.b.foo.c && clone !== object); - }); + var descriptor = { + 'configurable': true, + 'enumerable': true, + 'set': function() { throw new Error; } + }; - _.forEach([ - 'clone', - 'cloneDeep' - ], - function(methodName) { - var func = _[methodName], - klass = new Klass; + var source = { + 'a': 1, + 'b': undefined, + 'c': NaN, + 'd': undefined, + 'constructor': Object, + 'toString': lodashStable.constant('source') + }; - _.forOwn(objects, function(object, key) { - test('`_.' + methodName + '` should clone ' + key, 2, function() { - var clone = func(object); - strictEqual(_.isEqual(object, clone), true); + defineProperty(object, 'a', lodashStable.assign({}, descriptor, { + 'get': stubOne + })); - if (_.isObject(object)) { - notStrictEqual(clone, object); - } else { - strictEqual(clone, object); - } - }); - }); + defineProperty(object, 'b', lodashStable.assign({}, descriptor, { + 'get': noop + })); - _.forOwn(nonCloneable, function(object, key) { - test('`_.' + methodName + '` should not clone ' + key, 1, function() { - strictEqual(func(object), object); - }); - }); + defineProperty(object, 'c', lodashStable.assign({}, descriptor, { + 'get': stubNaN + })); - test('`_.' + methodName + '` should clone problem JScript properties (test in IE < 9)', 2, function() { - deepEqual(func(shadowedObject), shadowedObject); - notStrictEqual(func(shadowedObject), shadowedObject); - }); + defineProperty(object, 'constructor', lodashStable.assign({}, descriptor, { + 'get': lodashStable.constant(Object) + })); - test('`_.' + methodName + '` should pass the correct `callback` arguments', 1, function() { - var args; + try { + var actual = func(object, source); + } catch (e) {} - func(klass, function() { - args || (args = slice.call(arguments)); - }); + assert.deepEqual(actual, source); + }); - deepEqual(args, [klass]); - }); + QUnit.test('`_.' + methodName + '` should treat sparse array sources as dense', function(assert) { + assert.expect(1); - test('`_.' + methodName + '` should support the `thisArg` argument', 1, function() { - var actual = func('a', function(value) { - return this[value]; - }, { 'a': 'A' }); + var array = [1]; + array[2] = 3; - equal(actual, 'A'); - }); + assert.deepEqual(func({}, array), { '0': 1, '1': undefined, '2': 3 }); + }); - test('`_.' + methodName + '` should handle cloning if `callback` returns `undefined`', 1, function() { - var actual = func({ 'a': { 'b': 'c' } }, function() {}); - deepEqual(actual, { 'a': { 'b': 'c' } }); - }); + QUnit.test('`_.' + methodName + '` should assign values of prototype objects', function(assert) { + assert.expect(1); - test('`_.' + methodName + '` should deep clone `index` and `input` array properties', 2, function() { - var array = /x/.exec('vwxyz'), - actual = func(array); + function Foo() {} + Foo.prototype.a = 1; - strictEqual(actual.index, 2); - equal(actual.input, 'vwxyz'); - }); + assert.deepEqual(func({}, Foo.prototype), { 'a': 1 }); + }); - test('`_.' + methodName + '` should deep clone `lastIndex` regexp property', 1, function() { - // avoid a regexp literal for older Opera and use `exec` for older Safari - var regexp = RegExp('x', 'g'); - regexp.exec('vwxyz'); + QUnit.test('`_.' + methodName + '` should coerce string sources to objects', function(assert) { + assert.expect(1); - var actual = func(regexp); - equal(actual.lastIndex, 3); - }); + assert.deepEqual(func({}, 'a'), { '0': 'a' }); }); - }(1, 2, 3)); + }); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.compact'); + QUnit.module('lodash.assignInWith'); (function() { - test('should filter falsey values', 1, function() { - var array = ['0', '1', '2']; - deepEqual(_.compact(falsey.concat(array)), array); + QUnit.test('should be aliased', function(assert) { + assert.expect(1); + + assert.strictEqual(_.extendWith, _.assignInWith); }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.compose'); + QUnit.module('lodash.assignWith and lodash.assignInWith'); - (function() { - test('should create a function that is the composition of the provided functions', 1, function() { - var realNameMap = { - 'pebbles': 'penelope' - }; + lodashStable.each(['assignWith', 'assignInWith'], function(methodName) { + var func = _[methodName]; - var format = function(name) { - name = realNameMap[name.toLowerCase()] || name; - return name.charAt(0).toUpperCase() + name.slice(1).toLowerCase(); - }; + QUnit.test('`_.' + methodName + '` should work with a `customizer` callback', function(assert) { + assert.expect(1); - var greet = function(formatted) { - return 'Hiya ' + formatted + '!'; - }; + var actual = func({ 'a': 1, 'b': 2 }, { 'a': 3, 'c': 3 }, function(a, b) { + return a === undefined ? b : a; + }); - var welcome = _.compose(greet, format); - equal(welcome('pebbles'), 'Hiya Penelope!'); + assert.deepEqual(actual, { 'a': 1, 'b': 2, 'c': 3 }); }); - }()); + + QUnit.test('`_.' + methodName + '` should work with a `customizer` that returns `undefined`', function(assert) { + assert.expect(1); + + var expected = { 'a': 1 }; + assert.deepEqual(func({}, expected, noop), expected); + }); + }); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.constant'); + QUnit.module('lodash.at'); (function() { - test('should create a function that always returns `value`', 1, function() { - var object = { 'a': 1 }, - values = falsey.concat(1, 'a'), - constant = _.constant(object), - expected = _.map(values, function() { return object; }); + var array = ['a', 'b', 'c'], + object = { 'a': [{ 'b': { 'c': 3 } }, 4] }; - var actual = _.map(values, function(value, index) { - return index ? constant(value) : constant(); - }); + QUnit.test('should return the elements corresponding to the specified keys', function(assert) { + assert.expect(1); - deepEqual(actual, expected); + var actual = _.at(array, [0, 2]); + assert.deepEqual(actual, ['a', 'c']); }); - }()); - /*--------------------------------------------------------------------------*/ + QUnit.test('should return `undefined` for nonexistent keys', function(assert) { + assert.expect(1); - QUnit.module('lodash.contains'); + var actual = _.at(array, [2, 4, 0]); + assert.deepEqual(actual, ['c', undefined, 'a']); + }); - (function() { - _.forEach({ - 'an `arguments` object': arguments, - 'an array': [1, 2, 3, 1, 2, 3], - 'an object': { 'a': 1, 'b': 2, 'c': 3, 'd': 1, 'e': 2, 'f': 3 }, - 'a string': '123123' - }, - function(collection, key) { - test('should work with ' + key + ' and return `true` for matched values', 1, function() { - strictEqual(_.contains(collection, 3), true); - }); + QUnit.test('should work with non-index keys on array values', function(assert) { + assert.expect(1); - test('should work with ' + key + ' and return `false` for unmatched values', 1, function() { - strictEqual(_.contains(collection, 4), false); - }); + var values = lodashStable.reject(empties, function(value) { + return (value === 0) || lodashStable.isArray(value); + }).concat(-1, 1.1); - test('should work with ' + key + ' and a positive `fromIndex`', 1, function() { - strictEqual(_.contains(collection, 1, 2), true); - }); + var array = lodashStable.transform(values, function(result, value) { + result[value] = 1; + }, []); - test('should work with ' + key + ' and a `fromIndex` >= collection\'s length', 4, function() { - strictEqual(_.contains(collection, 1, 6), false); - strictEqual(_.contains(collection, undefined, 6), false); - strictEqual(_.contains(collection, 1, 8), false); - strictEqual(_.contains(collection, undefined, 8), false); - }); + var expected = lodashStable.map(values, stubOne), + actual = _.at(array, values); - test('should work with ' + key + ' and a negative `fromIndex`', 1, function() { - strictEqual(_.contains(collection, 2, -3), true); - }); + assert.deepEqual(actual, expected); + }); - test('should work with ' + key + ' and a negative `fromIndex` <= negative collection\'s length', 2, function() { - strictEqual(_.contains(collection, 1, -6), true); - strictEqual(_.contains(collection, 2, -8), true); - }); + QUnit.test('should return an empty array when no keys are given', function(assert) { + assert.expect(2); - test('should work with ' + key + ' and return an unwrapped value when chaining', 1, function() { - if (!isNpm) { - strictEqual(_(collection).contains(3), true); - } - else { - skipTest(); - } - }); + assert.deepEqual(_.at(array), []); + assert.deepEqual(_.at(array, [], []), []); }); - _.forEach({ - 'literal': 'abc', - 'object': Object('abc') - }, - function(collection, key) { - test('should work with a string ' + key + ' for `collection`', 2, function() { - strictEqual(_.contains(collection, 'bc'), true); - strictEqual(_.contains(collection, 'd'), false); - }); - }); + QUnit.test('should accept multiple key arguments', function(assert) { + assert.expect(1); - test('should be aliased', 1, function() { - strictEqual(_.include, _.contains); + var actual = _.at(['a', 'b', 'c', 'd'], 3, 0, 2); + assert.deepEqual(actual, ['d', 'a', 'c']); }); - }(1, 2, 3, 1, 2, 3)); - /*--------------------------------------------------------------------------*/ - - QUnit.module('lodash.countBy'); + QUnit.test('should work with a falsey `object` when keys are given', function(assert) { + assert.expect(1); - (function() { - var array = [4.2, 6.1, 6.4]; + var expected = lodashStable.map(falsey, lodashStable.constant(Array(4))); - test('should work with a `callback`', 1, function() { - var actual = _.countBy(array, function(num) { - return Math.floor(num); - }, Math); + var actual = lodashStable.map(falsey, function(object) { + try { + return _.at(object, 0, 1, 'pop', 'push'); + } catch (e) {} + }); - deepEqual(actual, { '4': 1, '6': 2 }); + assert.deepEqual(actual, expected); }); - test('should use `_.identity` when no `callback` is provided', 1, function() { - var actual = _.countBy([4, 6, 6]); - deepEqual(actual, { '4': 1, '6': 2 }); - }); + QUnit.test('should work with an `arguments` object for `object`', function(assert) { + assert.expect(1); - test('should pass the correct `callback` arguments', 1, function() { - var args; + var actual = _.at(args, [2, 0]); + assert.deepEqual(actual, [3, 1]); + }); - _.countBy(array, function() { - args || (args = slice.call(arguments)); - }); + QUnit.test('should work with `arguments` object as secondary arguments', function(assert) { + assert.expect(1); - deepEqual(args, [4.2, 0, array]); + var actual = _.at([1, 2, 3, 4, 5], args); + assert.deepEqual(actual, [2, 3, 4]); }); - test('should support the `thisArg` argument', 1, function() { - var actual = _.countBy(array, function(num) { - return this.floor(num); - }, Math); + QUnit.test('should work with an object for `object`', function(assert) { + assert.expect(1); - deepEqual(actual, { '4': 1, '6': 2 }); + var actual = _.at(object, ['a[0].b.c', 'a[1]']); + assert.deepEqual(actual, [3, 4]); }); - test('should only add values to own, not inherited, properties', 2, function() { - var actual = _.countBy([4.2, 6.1, 6.4], function(num) { - return Math.floor(num) > 4 ? 'hasOwnProperty' : 'constructor'; - }); + QUnit.test('should pluck inherited property values', function(assert) { + assert.expect(1); - deepEqual(actual.constructor, 1); - deepEqual(actual.hasOwnProperty, 2); - }); + function Foo() { + this.a = 1; + } + Foo.prototype.b = 2; - test('should work with a string for `callback`', 1, function() { - var actual = _.countBy(['one', 'two', 'three'], 'length'); - deepEqual(actual, { '3': 2, '5': 1 }); + var actual = _.at(new Foo, 'b'); + assert.deepEqual(actual, [2]); }); - test('should work with an object for `collection`', 1, function() { - var actual = _.countBy({ 'a': 4.2, 'b': 6.1, 'c': 6.4 }, function(num) { - return Math.floor(num); - }); + QUnit.test('should work in a lazy sequence', function(assert) { + assert.expect(6); - deepEqual(actual, { '4': 1, '6': 2 }); - }); + if (!isNpm) { + var largeArray = lodashStable.range(LARGE_ARRAY_SIZE), + smallArray = array; - test('should work with a number for `callback`', 2, function() { - var array = [ - [1, 'a'], - [2, 'a'], - [2, 'b'] - ]; + lodashStable.each([[2], ['2'], [2, 1]], function(paths) { + lodashStable.times(2, function(index) { + var array = index ? largeArray : smallArray, + wrapped = _(array).map(identity).at(paths); - deepEqual(_.countBy(array, 0), { '1': 1, '2': 2 }); - deepEqual(_.countBy(array, 1), { 'a': 2, 'b': 1 }); + assert.deepEqual(wrapped.value(), _.at(_.map(array, identity), paths)); + }); + }); + } + else { + skipAssert(assert, 6); + } }); - }()); - /*--------------------------------------------------------------------------*/ + QUnit.test('should support shortcut fusion', function(assert) { + assert.expect(8); - QUnit.module('lodash.create'); + if (!isNpm) { + var array = lodashStable.range(LARGE_ARRAY_SIZE), + count = 0, + iteratee = function(value) { count++; return square(value); }, + lastIndex = LARGE_ARRAY_SIZE - 1; - (function() { - test('should create an object that inherits from the given `prototype` object', 3, function() { - function Shape() { - this.x = 0; - this.y = 0; - } + lodashStable.each([lastIndex, lastIndex + '', LARGE_ARRAY_SIZE, []], function(n, index) { + count = 0; + var actual = _(array).map(iteratee).at(n).value(), + expected = index < 2 ? 1 : 0; - function Circle() { - Shape.call(this); + assert.strictEqual(count, expected); + + expected = index == 3 ? [] : [index == 2 ? undefined : square(lastIndex)]; + assert.deepEqual(actual, expected); + }); } + else { + skipAssert(assert, 8); + } + }); - Circle.prototype = _.create(Shape.prototype); - Circle.prototype.constructor = Circle; + QUnit.test('work with an object for `object` when chaining', function(assert) { + assert.expect(2); - var actual = new Circle; + if (!isNpm) { + var paths = ['a[0].b.c', 'a[1]'], + actual = _(object).map(identity).at(paths).value(); - ok(actual instanceof Circle); - ok(actual instanceof Shape); - notStrictEqual(Circle.prototype, Shape.prototype); - }); + assert.deepEqual(actual, _.at(_.map(object, identity), paths)); - test('should assign `properties` to the created object', 3, function() { - function Shape() { - this.x = 0; - this.y = 0; + var indexObject = { '0': 1 }; + actual = _(indexObject).at(0).value(); + assert.deepEqual(actual, _.at(indexObject, 0)); } - - function Circle() { - Shape.call(this); + else { + skipAssert(assert, 2); } + }); + }()); - var expected = { 'constructor': Circle, 'radius': 0 }; - Circle.prototype = _.create(Shape.prototype, expected); + /*--------------------------------------------------------------------------*/ - var actual = new Circle; + QUnit.module('lodash.attempt'); - ok(actual instanceof Circle); - ok(actual instanceof Shape); - deepEqual(Circle.prototype, expected); - }); + (function() { + QUnit.test('should return the result of `func`', function(assert) { + assert.expect(1); - test('should accept a falsey `prototype` argument', 1, function() { - var expected = _.map(falsey, function() { return {}; }); + assert.strictEqual(_.attempt(lodashStable.constant('x')), 'x'); + }); - var actual = _.map(falsey, function(value, index) { - return index ? _.create(value) : _.create(); - }); + QUnit.test('should provide additional arguments to `func`', function(assert) { + assert.expect(1); - deepEqual(actual, expected); + var actual = _.attempt(function() { return slice.call(arguments); }, 1, 2); + assert.deepEqual(actual, [1, 2]); }); - test('should ignore primitive `prototype` arguments and use an empty object instead', 1, function() { - var primitives = [true, null, 1, 'a', undefined], - expected = _.map(primitives, function() { return true; }); + QUnit.test('should return the caught error', function(assert) { + assert.expect(1); - var actual = _.map(primitives, function(value, index) { - return _.isPlainObject(index ? _.create(value) : _.create()); + var expected = lodashStable.map(errors, stubTrue); + + var actual = lodashStable.map(errors, function(error) { + return _.attempt(function() { throw error; }) === error; }); - deepEqual(actual, expected); + assert.deepEqual(actual, expected); }); - }()); - - /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.createCallback'); + QUnit.test('should coerce errors to error objects', function(assert) { + assert.expect(1); - (function() { - test('should work with functions created by `_.partial` and `_.partialRight`', 2, function() { - function func() { - var result = [this.x]; - push.apply(result, arguments); - return result; - } - var expected = [1, 2, 3], - object = { 'x': 1 }, - callback = _.createCallback(_.partial(func, 2), object); + var actual = _.attempt(function() { throw 'x'; }); + assert.ok(lodashStable.isEqual(actual, Error('x'))); + }); - deepEqual(callback(3), expected); + QUnit.test('should preserve custom errors', function(assert) { + assert.expect(1); - callback = _.createCallback(_.partialRight(func, 3), object); - deepEqual(callback(2), expected); + var actual = _.attempt(function() { throw new CustomError('x'); }); + assert.ok(actual instanceof CustomError); }); - test('should work without an `argCount`', 1, function() { - var args, - expected = ['a', 'b', 'c', 'd', 'e']; - - var callback = _.createCallback(function() { - args = slice.call(arguments); - }); + QUnit.test('should work with an error object from another realm', function(assert) { + assert.expect(1); - callback.apply(null, expected); - deepEqual(args, expected); - }); + if (realm.errors) { + var expected = lodashStable.map(realm.errors, stubTrue); - test('should return the function provided if already bound with `Function#bind`', 1, function() { - function a() {} - var object = {}; + var actual = lodashStable.map(realm.errors, function(error) { + return _.attempt(function() { throw error; }) === error; + }); - var bound = a.bind && a.bind(object); - if (bound && !('prototype' in bound)) { - var bound = a.bind(object); - strictEqual(_.createCallback(bound, object), bound); + assert.deepEqual(actual, expected); } else { - skipTest(); + skipAssert(assert); } }); - test('should return the function provided when there is no `this` reference', 2, function() { - function a() {} - function b() { return this.b; } - - var object = {}; + QUnit.test('should return an unwrapped value when implicitly chaining', function(assert) { + assert.expect(1); - if (_.support.funcDecomp) { - strictEqual(_.createCallback(a, object), a); - notStrictEqual(_.createCallback(b, object), b); + if (!isNpm) { + assert.strictEqual(_(lodashStable.constant('x')).attempt(), 'x'); } else { - skipTest(2); + skipAssert(assert); } }); - test('should only write `__bindData__` to named functions', 3, function() { - function a() {}; - function c() {}; - - var b = function() {}, - object = {}; - - if (defineProperty && _.support.funcDecomp) { - _.createCallback(a, object); - ok('__bindData__' in a) - - _.createCallback(b, object); - ok(!('__bindData__' in b)); + QUnit.test('should return a wrapped value when explicitly chaining', function(assert) { + assert.expect(1); - if (_.support.funcNames) { - _.support.funcNames = false; - _.createCallback(c, object); - ok('__bindData__' in c); - _.support.funcNames = true; - } - else { - skipTest(); - } + if (!isNpm) { + assert.ok(_(lodashStable.constant('x')).chain().attempt() instanceof _); } else { - skipTest(3); + skipAssert(assert); } }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.curry'); + QUnit.module('lodash.before'); (function() { - function func(a, b, c) { - return a + b + c; + function before(n, times) { + var count = 0; + lodashStable.times(times, _.before(n, function() { count++; })); + return count; } - test('should curry based on the number of arguments provided', 3, function() { - var curried = _.curry(func); + QUnit.test('should create a function that invokes `func` after `n` calls', function(assert) { + assert.expect(4); - equal(curried(1)(2)(3), 6); - equal(curried(1, 2)(3), 6); - equal(curried(1, 2, 3), 6); + assert.strictEqual(before(5, 4), 4, 'before(n) should invoke `func` before being called `n` times'); + assert.strictEqual(before(5, 6), 4, 'before(n) should not invoke `func` after being called `n - 1` times'); + assert.strictEqual(before(0, 0), 0, 'before(0) should not invoke `func` immediately'); + assert.strictEqual(before(0, 1), 0, 'before(0) should not invoke `func` when called'); }); - test('should work with partial methods', 2, function() { - var curried = _.curry(func), - a = _.partial(curried, 1), - b = _.partialRight(a, 3), - c = _.partialRight(a(2), 3); + QUnit.test('should coerce `n` values of `NaN` to `0`', function(assert) { + assert.expect(1); - equal(b(2), 6); - equal(c(), 6); + assert.strictEqual(before(NaN, 1), 0); }); - test('should return a function with a `length` of `0`', 6, function() { - _.times(2, function(index) { - var curried = index ? _.curry(func, 4) : _.curry(func); + QUnit.test('should use `this` binding of function', function(assert) { + assert.expect(2); - strictEqual(curried.length, 0); - strictEqual(curried(1).length, 0); - strictEqual(curried(1, 2).length, 0); - }); + var before = _.before(2, function(assert) { return ++this.count; }), + object = { 'before': before, 'count': 0 }; + + object.before(); + assert.strictEqual(object.before(), 1); + assert.strictEqual(object.count, 1); }); + }()); - test('ensure `new bound` is an instance of `func`', 2, function() { - function Foo(value) { - return value && object; - } - var bound = _.curry(Foo), - object = {}; + /*--------------------------------------------------------------------------*/ - ok(new bound(false) instanceof Foo); - strictEqual(new bound(true), object); - }); + QUnit.module('lodash.bind'); - test('should not alter the `this` binding', 9, function() { - function func(a, b, c) { - var value = this || {}; - return value[a] + value[b] + value[c]; - } + (function() { + function fn() { + var result = [this]; + push.apply(result, arguments); + return result; + } + + QUnit.test('should bind a function to an object', function(assert) { + assert.expect(1); + + var object = {}, + bound = _.bind(fn, object); - var object = { 'a': 1, 'b': 2, 'c': 3 }; + assert.deepEqual(bound('a'), [object, 'a']); + }); - equal(_.curry(_.bind(func, object), 3)('a')('b')('c'), 6); - equal(_.curry(_.bind(func, object), 3)('a', 'b')('c'), 6); - equal(_.curry(_.bind(func, object), 3)('a', 'b', 'c'), 6); + QUnit.test('should accept a falsey `thisArg`', function(assert) { + assert.expect(1); - ok(_.isEqual(_.bind(_.curry(func), object)('a')('b')('c'), NaN)); - ok(_.isEqual(_.bind(_.curry(func), object)('a', 'b')('c'), NaN)); - equal(_.bind(_.curry(func), object)('a', 'b', 'c'), 6); + var values = lodashStable.reject(falsey.slice(1), function(value) { return value == null; }), + expected = lodashStable.map(values, function(value) { return [value]; }); - object.func = _.curry(func); + var actual = lodashStable.map(values, function(value) { + try { + var bound = _.bind(fn, value); + return bound(); + } catch (e) {} + }); - ok(_.isEqual(object.func('a')('b')('c'), NaN)); - ok(_.isEqual(object.func('a', 'b')('c'), NaN)); - equal(object.func('a', 'b', 'c'), 6); + assert.ok(lodashStable.every(actual, function(value, index) { + return lodashStable.isEqual(value, expected[index]); + })); }); - }()); - /*--------------------------------------------------------------------------*/ + QUnit.test('should bind a function to nullish values', function(assert) { + assert.expect(6); - QUnit.module('lodash.debounce'); + var bound = _.bind(fn, null), + actual = bound('a'); - (function() { - asyncTest('should debounce a function', 2, function() { - if (!(isRhino && isModularize)) { - var count = 0, - debounced = _.debounce(function() { count++; }, 32); + assert.ok((actual[0] === null) || (actual[0] && actual[0].Array)); + assert.strictEqual(actual[1], 'a'); - debounced(); - debounced(); - debounced(); + lodashStable.times(2, function(index) { + bound = index ? _.bind(fn, undefined) : _.bind(fn); + actual = bound('b'); + + assert.ok((actual[0] === undefined) || (actual[0] && actual[0].Array)); + assert.strictEqual(actual[1], 'b'); + }); + }); - equal(count, 0); + QUnit.test('should partially apply arguments ', function(assert) { + assert.expect(4); - setTimeout(function() { - equal(count, 1); - QUnit.start(); - }, 96); - } - else { - skipTest(2); - QUnit.start(); - } + var object = {}, + bound = _.bind(fn, object, 'a'); + + assert.deepEqual(bound(), [object, 'a']); + + bound = _.bind(fn, object, 'a'); + assert.deepEqual(bound('b'), [object, 'a', 'b']); + + bound = _.bind(fn, object, 'a', 'b'); + assert.deepEqual(bound(), [object, 'a', 'b']); + assert.deepEqual(bound('c', 'd'), [object, 'a', 'b', 'c', 'd']); }); - asyncTest('subsequent debounced calls return the last `func` result', 2, function() { - if (!(isRhino && isModularize)) { - var debounced = _.debounce(_.identity, 32); - debounced('x'); + QUnit.test('should support placeholders', function(assert) { + assert.expect(4); - setTimeout(function() { - notEqual(debounced('y'), 'y'); - }, 64); + var object = {}, + ph = _.bind.placeholder, + bound = _.bind(fn, object, ph, 'b', ph); - setTimeout(function() { - notEqual(debounced('z'), 'z'); - QUnit.start(); - }, 128); - } - else { - skipTest(2); - QUnit.start(); - } + assert.deepEqual(bound('a', 'c'), [object, 'a', 'b', 'c']); + assert.deepEqual(bound('a'), [object, 'a', 'b', undefined]); + assert.deepEqual(bound('a', 'c', 'd'), [object, 'a', 'b', 'c', 'd']); + assert.deepEqual(bound(), [object, undefined, 'b', undefined]); }); - asyncTest('subsequent "immediate" debounced calls return the last `func` result', 2, function() { - if (!(isRhino && isModularize)) { - var debounced = _.debounce(_.identity, 32, true), - result = [debounced('x'), debounced('y')]; + QUnit.test('should use `_.placeholder` when set', function(assert) { + assert.expect(1); - deepEqual(result, ['x', 'x']); + if (!isModularize) { + var _ph = _.placeholder = {}, + ph = _.bind.placeholder, + object = {}, + bound = _.bind(fn, object, _ph, 'b', ph); - setTimeout(function() { - var result = [debounced('a'), debounced('b')]; - deepEqual(result, ['a', 'a']); - QUnit.start(); - }, 64); + assert.deepEqual(bound('a', 'c'), [object, 'a', 'b', ph, 'c']); + delete _.placeholder; } else { - skipTest(2); - QUnit.start(); + skipAssert(assert); } }); - asyncTest('should apply default options correctly', 2, function() { - if (!(isRhino && isModularize)) { - var count = 0; + QUnit.test('should create a function with a `length` of `0`', function(assert) { + assert.expect(2); - var debounced = _.debounce(function(value) { - count++; - return value; - }, 32, {}); + var fn = function(a, b, c) {}, + bound = _.bind(fn, {}); - strictEqual(debounced('x'), undefined); + assert.strictEqual(bound.length, 0); - setTimeout(function() { - strictEqual(count, 1); - QUnit.start(); - }, 64); - } - else { - skipTest(2); - QUnit.start(); - } + bound = _.bind(fn, {}, 1); + assert.strictEqual(bound.length, 0); }); - asyncTest('should work with `leading` option', 7, function() { - if (!(isRhino && isModularize)) { - var withLeading, - counts = [0, 0, 0]; + QUnit.test('should ignore binding when called with the `new` operator', function(assert) { + assert.expect(3); - _.forEach([true, { 'leading': true }], function(options, index) { - var debounced = _.debounce(function(value) { - counts[index]++; - return value; - }, 32, options); + function Foo() { + return this; + } - if (index == 1) { - withLeading = debounced; - } - equal(debounced('x'), 'x'); - }); + var bound = _.bind(Foo, { 'a': 1 }), + newBound = new bound; - _.forEach([false, { 'leading': false }], function(options) { - var withoutLeading = _.debounce(_.identity, 32, options); - strictEqual(withoutLeading('x'), undefined); - }); + assert.strictEqual(bound().a, 1); + assert.strictEqual(newBound.a, undefined); + assert.ok(newBound instanceof Foo); + }); - var withLeadingAndTrailing = _.debounce(function() { - counts[2]++; - }, 32, { 'leading': true }); + QUnit.test('should handle a number of arguments when called with the `new` operator', function(assert) { + assert.expect(1); - withLeadingAndTrailing(); - withLeadingAndTrailing(); + function Foo() { + return this; + } + + function Bar() {} - strictEqual(counts[2], 1); + var thisArg = { 'a': 1 }, + boundFoo = _.bind(Foo, thisArg), + boundBar = _.bind(Bar, thisArg), + count = 9, + expected = lodashStable.times(count, lodashStable.constant([undefined, undefined])); - setTimeout(function() { - deepEqual(counts, [1, 1, 2]); + var actual = lodashStable.times(count, function(index) { + try { + switch (index) { + case 0: return [new boundFoo().a, new boundBar().a]; + case 1: return [new boundFoo(1).a, new boundBar(1).a]; + case 2: return [new boundFoo(1, 2).a, new boundBar(1, 2).a]; + case 3: return [new boundFoo(1, 2, 3).a, new boundBar(1, 2, 3).a]; + case 4: return [new boundFoo(1, 2, 3, 4).a, new boundBar(1, 2, 3, 4).a]; + case 5: return [new boundFoo(1, 2, 3, 4, 5).a, new boundBar(1, 2, 3, 4, 5).a]; + case 6: return [new boundFoo(1, 2, 3, 4, 5, 6).a, new boundBar(1, 2, 3, 4, 5, 6).a]; + case 7: return [new boundFoo(1, 2, 3, 4, 5, 6, 7).a, new boundBar(1, 2, 3, 4, 5, 6, 7).a]; + case 8: return [new boundFoo(1, 2, 3, 4, 5, 6, 7, 8).a, new boundBar(1, 2, 3, 4, 5, 6, 7, 8).a]; + } + } catch (e) {} + }); - withLeading('x'); - equal(counts[1], 2); + assert.deepEqual(actual, expected); + }); - QUnit.start(); - }, 64); - } - else { - skipTest(7); - QUnit.start(); + QUnit.test('should ensure `new bound` is an instance of `func`', function(assert) { + assert.expect(2); + + function Foo(value) { + return value && object; } + + var bound = _.bind(Foo), + object = {}; + + assert.ok(new bound instanceof Foo); + assert.strictEqual(new bound(true), object); }); - asyncTest('should work with `trailing` option', 4, function() { - if (!(isRhino && isModularize)) { - var withCount = 0, - withoutCount = 0; + QUnit.test('should append array arguments to partially applied arguments', function(assert) { + assert.expect(1); - var withTrailing = _.debounce(function(value) { - withCount++; - return value; - }, 32, { 'trailing': true }); + var object = {}, + bound = _.bind(fn, object, 'a'); - var withoutTrailing = _.debounce(function(value) { - withoutCount++; - return value; - }, 32, { 'trailing': false }); + assert.deepEqual(bound(['b'], 'c'), [object, 'a', ['b'], 'c']); + }); - strictEqual(withTrailing('x'), undefined); - strictEqual(withoutTrailing('x'), undefined); + QUnit.test('should not rebind functions', function(assert) { + assert.expect(3); - setTimeout(function() { - strictEqual(withCount, 1); - strictEqual(withoutCount, 0); - QUnit.start(); - }, 64); - } - else { - skipTest(4); - QUnit.start(); - } + var object1 = {}, + object2 = {}, + object3 = {}; + + var bound1 = _.bind(fn, object1), + bound2 = _.bind(bound1, object2, 'a'), + bound3 = _.bind(bound1, object3, 'b'); + + assert.deepEqual(bound1(), [object1]); + assert.deepEqual(bound2(), [object1, 'a']); + assert.deepEqual(bound3(), [object1, 'b']); }); - test('should work with `maxWait` option', 2, function() { - if (!(isRhino && isModularize)) { - var limit = argv ? 1000 : 500, - withCount = 0, - withoutCount = 0; + QUnit.test('should not error when instantiating bound built-ins', function(assert) { + assert.expect(2); - var withMaxWait = _.debounce(function() { - withCount++; - }, 64, { 'maxWait': 128 }); + var Ctor = _.bind(Date, null), + expected = new Date(2012, 4, 23, 0, 0, 0, 0); - var withoutMaxWait = _.debounce(function() { - withoutCount++; - }, 96); + try { + var actual = new Ctor(2012, 4, 23, 0, 0, 0, 0); + } catch (e) {} - var start = +new Date; - while ((new Date - start) < limit) { - withMaxWait(); - withoutMaxWait(); - } - ok(withCount > 0); - ok(!withoutCount); - } - else { - skipTest(2); - } + assert.deepEqual(actual, expected); + + Ctor = _.bind(Date, null, 2012, 4, 23); + + try { + actual = new Ctor(0, 0, 0, 0); + } catch (e) {} + + assert.deepEqual(actual, expected); }); - asyncTest('should cancel `maxDelayed` when `delayed` is executed', 1, function() { - if (!(isRhino && isModularize)) { - var count = 0; + QUnit.test('should not error when calling bound class constructors with the `new` operator', function(assert) { + assert.expect(1); - var debounced = _.debounce(function() { - count++; - }, 32, { 'maxWait': 64 }); + var createCtor = lodashStable.attempt(Function, '"use strict";return class A{}'); - debounced(); + if (typeof createCtor == 'function') { + var bound = _.bind(createCtor()), + count = 8, + expected = lodashStable.times(count, stubTrue); - setTimeout(function() { - strictEqual(count, 1); - QUnit.start(); - }, 128); + var actual = lodashStable.times(count, function(index) { + try { + switch (index) { + case 0: return !!(new bound); + case 1: return !!(new bound(1)); + case 2: return !!(new bound(1, 2)); + case 3: return !!(new bound(1, 2, 3)); + case 4: return !!(new bound(1, 2, 3, 4)); + case 5: return !!(new bound(1, 2, 3, 4, 5)); + case 6: return !!(new bound(1, 2, 3, 4, 5, 6)); + case 7: return !!(new bound(1, 2, 3, 4, 5, 6, 7)); + } + } catch (e) {} + }); + + assert.deepEqual(actual, expected); } else { - skipTest(1); - QUnit.start(); + skipAssert(assert); } }); - asyncTest('should execute the `trailing` call with the correct arguments and `this` binding', 2, function() { - if (!(isRhino && isModularize)) { - var args, - count = 0, - object = {}; + QUnit.test('should return a wrapped value when chaining', function(assert) { + assert.expect(2); - var debounced = _.debounce(function(value) { - args = [this]; - push.apply(args, arguments); - return ++count != 2; - }, 32, { 'leading': true, 'maxWait': 64 }); + if (!isNpm) { + var object = {}, + bound = _(fn).bind({}, 'a', 'b'); - while (true) { - if (!debounced.call(object, 'a')) { - break; - } - } - setTimeout(function() { - equal(count, 2); - deepEqual(args, [object, 'a']); - QUnit.start(); - }, 64); + assert.ok(bound instanceof _); + + var actual = bound.value()('c'); + assert.deepEqual(actual, [object, 'a', 'b', 'c']); } else { - skipTest(2); - QUnit.start(); + skipAssert(assert, 2); } }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.defaults'); + QUnit.module('lodash.bindAll'); (function() { - test('should assign properties of a source object if missing on the destination object', 1, function() { - deepEqual(_.defaults({ 'a': 1 }, { 'a': 2, 'b': 2 }), { 'a': 1, 'b': 2 }); - }); + var args = toArgs(['a']); + + var source = { + '_n0': -2, + '_p0': -1, + '_a': 1, + '_b': 2, + '_c': 3, + '_d': 4, + '-0': function() { return this._n0; }, + '0': function() { return this._p0; }, + 'a': function() { return this._a; }, + 'b': function() { return this._b; }, + 'c': function() { return this._c; }, + 'd': function() { return this._d; } + }; - test('should assign own source properties', 1, function() { - function Foo() { - this.a = 1; - this.c = 3; - } + QUnit.test('should accept individual method names', function(assert) { + assert.expect(1); - Foo.prototype.b = 2; - deepEqual(_.defaults({ 'c': 2 }, new Foo), { 'a': 1, 'c': 2 }); - }); + var object = lodashStable.cloneDeep(source); + _.bindAll(object, 'a', 'b'); - test('should accept multiple source objects', 2, function() { - var expected = { 'a': 1, 'b': 2, 'c': 3 }; - deepEqual(_.defaults({ 'a': 1, 'b': 2 }, { 'b': 3 }, { 'c': 3 }), expected); - deepEqual(_.defaults({ 'a': 1, 'b': 2 }, { 'b': 3, 'c': 3 }, { 'c': 2 }), expected); - }); + var actual = lodashStable.map(['a', 'b', 'c'], function(key) { + return object[key].call({}); + }); - test('should not overwrite `null` values', 1, function() { - var actual = _.defaults({ 'a': null }, { 'a': 1 }); - strictEqual(actual.a, null); + assert.deepEqual(actual, [1, 2, undefined]); }); - test('should overwrite `undefined` values', 1, function() { - var actual = _.defaults({ 'a': undefined }, { 'a': 1 }); - strictEqual(actual.a, 1); - }); + QUnit.test('should accept arrays of method names', function(assert) { + assert.expect(1); - test('should not error on `null` or `undefined` sources (test in IE < 9)', 1, function() { - try { - deepEqual(_.defaults({ 'a': 1 }, null, undefined, { 'a': 2, 'b': 2 }), { 'a': 1, 'b': 2 }); - } catch(e) { - ok(false); - } - }); - }()); + var object = lodashStable.cloneDeep(source); + _.bindAll(object, ['a', 'b'], ['c']); - /*--------------------------------------------------------------------------*/ + var actual = lodashStable.map(['a', 'b', 'c', 'd'], function(key) { + return object[key].call({}); + }); - QUnit.module('lodash.defer'); + assert.deepEqual(actual, [1, 2, 3, undefined]); + }); - (function() { - asyncTest('should defer `func` execution', 1, function() { - if (!(isRhino && isModularize)) { - var pass = false; - _.defer(function(){ pass = true; }); + QUnit.test('should preserve the sign of `0`', function(assert) { + assert.expect(1); - setTimeout(function() { - ok(pass); - QUnit.start(); - }, 128); - } - else { - skipTest(); - QUnit.start(); - } - }); + var props = [-0, Object(-0), 0, Object(0)]; - asyncTest('should accept additional arguments', 1, function() { - if (!(isRhino && isModularize)) { - var args; + var actual = lodashStable.map(props, function(key) { + var object = lodashStable.cloneDeep(source); + _.bindAll(object, key); + return object[lodashStable.toString(key)].call({}); + }); - _.defer(function() { - args = slice.call(arguments); - }, 1, 2, 3); + assert.deepEqual(actual, [-2, -2, -1, -1]); + }); - setTimeout(function() { - deepEqual(args, [1, 2, 3]); - QUnit.start(); - }, 128); - } - else { - skipTest(); - QUnit.start(); - } + QUnit.test('should work with an array `object`', function(assert) { + assert.expect(1); + + var array = ['push', 'pop']; + _.bindAll(array); + assert.strictEqual(array.pop, arrayProto.pop); }); - asyncTest('should be cancelable', 1, function() { - if (!(isRhino && isModularize)) { - var pass = true; + QUnit.test('should work with `arguments` objects as secondary arguments', function(assert) { + assert.expect(1); - var timerId = _.defer(function() { - pass = false; - }); + var object = lodashStable.cloneDeep(source); + _.bindAll(object, args); - clearTimeout(timerId); + var actual = lodashStable.map(args, function(key) { + return object[key].call({}); + }); - setTimeout(function() { - ok(pass); - QUnit.start(); - }, 128); - } - else { - skipTest(); - QUnit.start(); - } + assert.deepEqual(actual, [1]); }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.delay'); + QUnit.module('lodash.bindKey'); (function() { - asyncTest('should delay `func` execution', 2, function() { - if (!(isRhino && isModularize)) { - var pass = false; - _.delay(function(){ pass = true; }, 96); + QUnit.test('should work when the target function is overwritten', function(assert) { + assert.expect(2); - setTimeout(function() { - ok(!pass); - }, 32); + var object = { + 'user': 'fred', + 'greet': function(greeting) { + return this.user + ' says: ' + greeting; + } + }; - setTimeout(function() { - ok(pass); - QUnit.start(); - }, 160); - } - else { - skipTest(2); - QUnit.start(); - } + var bound = _.bindKey(object, 'greet', 'hi'); + assert.strictEqual(bound(), 'fred says: hi'); + + object.greet = function(greeting) { + return this.user + ' says: ' + greeting + '!'; + }; + + assert.strictEqual(bound(), 'fred says: hi!'); }); - asyncTest('should accept additional arguments', 1, function() { - if (!(isRhino && isModularize)) { - var args; + QUnit.test('should support placeholders', function(assert) { + assert.expect(4); - _.delay(function() { - args = slice.call(arguments); - }, 32, 1, 2, 3); + var object = { + 'fn': function() { + return slice.call(arguments); + } + }; - setTimeout(function() { - deepEqual(args, [1, 2, 3]); - QUnit.start(); - }, 128); - } - else { - skipTest(); - QUnit.start(); - } + var ph = _.bindKey.placeholder, + bound = _.bindKey(object, 'fn', ph, 'b', ph); + + assert.deepEqual(bound('a', 'c'), ['a', 'b', 'c']); + assert.deepEqual(bound('a'), ['a', 'b', undefined]); + assert.deepEqual(bound('a', 'c', 'd'), ['a', 'b', 'c', 'd']); + assert.deepEqual(bound(), [undefined, 'b', undefined]); }); - asyncTest('should be cancelable', 1, function() { - if (!(isRhino && isModularize)) { - var pass = true; + QUnit.test('should use `_.placeholder` when set', function(assert) { + assert.expect(1); - var timerId = _.delay(function() { - pass = false; - }, 32); + if (!isModularize) { + var object = { + 'fn': function() { + return slice.call(arguments); + } + }; - clearTimeout(timerId); + var _ph = _.placeholder = {}, + ph = _.bindKey.placeholder, + bound = _.bindKey(object, 'fn', _ph, 'b', ph); - setTimeout(function() { - ok(pass); - QUnit.start(); - }, 128); + assert.deepEqual(bound('a', 'c'), ['a', 'b', ph, 'c']); + delete _.placeholder; } else { - skipTest(); - QUnit.start(); + skipAssert(assert); + } + }); + + QUnit.test('should ensure `new bound` is an instance of `object[key]`', function(assert) { + assert.expect(2); + + function Foo(value) { + return value && object; } + + var object = { 'Foo': Foo }, + bound = _.bindKey(object, 'Foo'); + + assert.ok(new bound instanceof Foo); + assert.strictEqual(new bound(true), object); }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.difference'); + QUnit.module('case methods'); - (function() { - test('should return the difference of the given arrays', 2, function() { - var actual = _.difference([1, 2, 3, 4, 5], [5, 2, 10]); - deepEqual(actual, [1, 3, 4]); + lodashStable.each(['camel', 'kebab', 'lower', 'snake', 'start', 'upper'], function(caseName) { + var methodName = caseName + 'Case', + func = _[methodName]; + + var strings = [ + 'foo bar', 'Foo bar', 'foo Bar', 'Foo Bar', + 'FOO BAR', 'fooBar', '--foo-bar--', '__foo_bar__' + ]; + + var converted = (function() { + switch (caseName) { + case 'camel': return 'fooBar'; + case 'kebab': return 'foo-bar'; + case 'lower': return 'foo bar'; + case 'snake': return 'foo_bar'; + case 'start': return 'Foo Bar'; + case 'upper': return 'FOO BAR'; + } + }()); + + QUnit.test('`_.' + methodName + '` should convert `string` to ' + caseName + ' case', function(assert) { + assert.expect(1); - actual = _.difference([1, 2, 3, 4, 5], [5, 2, 10], [8, 4]); - deepEqual(actual, [1, 3]); + var actual = lodashStable.map(strings, function(string) { + var expected = (caseName == 'start' && string == 'FOO BAR') ? string : converted; + return func(string) === expected; + }); + + assert.deepEqual(actual, lodashStable.map(strings, stubTrue)); }); - test('should work with large arrays', 1, function() { - var array1 = _.range(largeArraySize), - array2 = array1.slice(), - a = {}, - b = {}, - c = {}; + QUnit.test('`_.' + methodName + '` should handle double-converting strings', function(assert) { + assert.expect(1); - array1.push(a, b, c); - array2.push(b, c, a); + var actual = lodashStable.map(strings, function(string) { + var expected = (caseName == 'start' && string == 'FOO BAR') ? string : converted; + return func(func(string)) === expected; + }); - deepEqual(_.difference(array1, array2), []); + assert.deepEqual(actual, lodashStable.map(strings, stubTrue)); }); - test('should work with large arrays of objects', 1, function() { - var object = {}; + QUnit.test('`_.' + methodName + '` should deburr letters', function(assert) { + assert.expect(1); - var largeArray = _.times(largeArraySize, function() { - return object; + var actual = lodashStable.map(burredLetters, function(burred, index) { + var letter = deburredLetters[index].replace(/['\u2019]/g, ''); + if (caseName == 'start') { + letter = letter == 'IJ' ? letter : lodashStable.capitalize(letter); + } else if (caseName == 'upper') { + letter = letter.toUpperCase(); + } else { + letter = letter.toLowerCase(); + } + return func(burred) === letter; }); - deepEqual(_.difference(largeArray, [object]), []); + assert.deepEqual(actual, lodashStable.map(burredLetters, stubTrue)); }); - test('should ignore individual secondary values', 1, function() { - var array = [1, null, 3]; - deepEqual(_.difference(array, null, 3), array); + QUnit.test('`_.' + methodName + '` should remove contraction apostrophes', function(assert) { + assert.expect(2); + + var postfixes = ['d', 'll', 'm', 're', 's', 't', 've']; + + lodashStable.each(["'", '\u2019'], function(apos) { + var actual = lodashStable.map(postfixes, function(postfix) { + return func('a b' + apos + postfix + ' c'); + }); + + var expected = lodashStable.map(postfixes, function(postfix) { + switch (caseName) { + case 'camel': return 'aB' + postfix + 'C'; + case 'kebab': return 'a-b' + postfix + '-c'; + case 'lower': return 'a b' + postfix + ' c'; + case 'snake': return 'a_b' + postfix + '_c'; + case 'start': return 'A B' + postfix + ' C'; + case 'upper': return 'A B' + postfix.toUpperCase() + ' C'; + } + }); + + assert.deepEqual(actual, expected); + }); }); - }()); - /*--------------------------------------------------------------------------*/ + QUnit.test('`_.' + methodName + '` should remove Latin mathematical operators', function(assert) { + assert.expect(1); - QUnit.module('lodash.escape'); + var actual = lodashStable.map(['\xd7', '\xf7'], func); + assert.deepEqual(actual, ['', '']); + }); - (function() { - var escaped = '&<>"'\/', - unescaped = '&<>"\'\/'; + QUnit.test('`_.' + methodName + '` should coerce `string` to a string', function(assert) { + assert.expect(2); + + var string = 'foo bar'; + assert.strictEqual(func(Object(string)), converted); + assert.strictEqual(func({ 'toString': lodashStable.constant(string) }), converted); + }); - test('should not escape the "/" character', 1, function() { - equal(_.escape('/'), '/'); + QUnit.test('`_.' + methodName + '` should return an unwrapped value implicitly when chaining', function(assert) { + assert.expect(1); + + if (!isNpm) { + assert.strictEqual(_('foo bar')[methodName](), converted); + } + else { + skipAssert(assert); + } }); - test('should escape values', 1, function() { - equal(_.escape(unescaped), escaped); + QUnit.test('`_.' + methodName + '` should return a wrapped value when explicitly chaining', function(assert) { + assert.expect(1); + + if (!isNpm) { + assert.ok(_('foo bar').chain()[methodName]() instanceof _); + } + else { + skipAssert(assert); + } }); + }); + + (function() { + QUnit.test('should get the original value after cycling through all case methods', function(assert) { + assert.expect(1); + + var funcs = [_.camelCase, _.kebabCase, _.lowerCase, _.snakeCase, _.startCase, _.lowerCase, _.camelCase]; - test('should return an empty string when provided `null` or `undefined`', 2, function() { - equal(_.escape(null), ''); - equal(_.escape(undefined), ''); + var actual = lodashStable.reduce(funcs, function(result, func) { + return func(result); + }, 'enable 6h format'); + + assert.strictEqual(actual, 'enable6HFormat'); }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.every'); + QUnit.module('lodash.camelCase'); (function() { - test('should return `true` for empty or falsey collections', 1, function() { - var expected = _.map(empties, function() { return true; }); + QUnit.test('should work with numbers', function(assert) { + assert.expect(6); - var actual = _.map(empties, function(value) { - try { - return _.every(value, _.identity); - } catch(e) { } + assert.strictEqual(_.camelCase('12 feet'), '12Feet'); + assert.strictEqual(_.camelCase('enable 6h format'), 'enable6HFormat'); + assert.strictEqual(_.camelCase('enable 24H format'), 'enable24HFormat'); + assert.strictEqual(_.camelCase('too legit 2 quit'), 'tooLegit2Quit'); + assert.strictEqual(_.camelCase('walk 500 miles'), 'walk500Miles'); + assert.strictEqual(_.camelCase('xhr2 request'), 'xhr2Request'); + }); + + QUnit.test('should handle acronyms', function(assert) { + assert.expect(6); + + lodashStable.each(['safe HTML', 'safeHTML'], function(string) { + assert.strictEqual(_.camelCase(string), 'safeHtml'); }); - deepEqual(actual, expected); - }); + lodashStable.each(['escape HTML entities', 'escapeHTMLEntities'], function(string) { + assert.strictEqual(_.camelCase(string), 'escapeHtmlEntities'); + }); - test('should return `true` if the callback returns truey for all elements in the collection', 1, function() { - strictEqual(_.every([true, 1, 'x'], _.identity), true); + lodashStable.each(['XMLHttpRequest', 'XmlHTTPRequest'], function(string) { + assert.strictEqual(_.camelCase(string), 'xmlHttpRequest'); + }); }); + }()); - test('should return `false` as soon as the callback result is falsey', 1, function() { - strictEqual(_.every([true, null, true], _.identity), false); - }); + /*--------------------------------------------------------------------------*/ - test('should work with collections of `undefined` values (test in IE < 9)', 1, function() { - strictEqual(_.every([undefined, undefined, undefined], _.identity), false); - }); + QUnit.module('lodash.capitalize'); - test('should use `_.identity` when no callback is provided', 2, function() { - strictEqual(_.every([0]), false); - strictEqual(_.every([1]), true); - }); + (function() { + QUnit.test('should capitalize the first character of a string', function(assert) { + assert.expect(3); - test('should be aliased', 1, function() { - strictEqual(_.all, _.every); + assert.strictEqual(_.capitalize('fred'), 'Fred'); + assert.strictEqual(_.capitalize('Fred'), 'Fred'); + assert.strictEqual(_.capitalize(' fred'), ' fred'); }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('source property checks'); - - _.forEach(['assign', 'defaults', 'merge'], function(methodName) { - var func = _[methodName]; + QUnit.module('lodash.castArray'); - test('`_.' + methodName + '` should not assign inherited `source` properties', 1, function() { - function Foo() {} - Foo.prototype = { 'a': 1 }; - deepEqual(func({}, new Foo), {}); - }); + (function() { + QUnit.test('should wrap non-array items in an array', function(assert) { + assert.expect(1); - test('should work when used as `callback` for `_.reduce`', 1, function() { - var array = [{ 'a': 1 }, { 'b': 2 }, { 'c': 3 }], - actual = _.reduce(array, _.merge); + var values = falsey.concat(true, 1, 'a', { 'a': 1 }), + expected = lodashStable.map(values, function(value) { return [value]; }), + actual = lodashStable.map(values, _.castArray); - deepEqual(actual, { 'a': 1, 'b': 2, 'c': 3 }); + assert.deepEqual(actual, expected); }); - if (methodName == 'merge') { - test('`_.' + methodName + '` should treat sparse arrays as dense', 2, function() { - var array = Array(3); - array[0] = 1; - array[2] = 3; + QUnit.test('should return array values by reference', function(assert) { + assert.expect(1); - var actual = func([], array), - expected = array.slice(); + var array = [1]; + assert.strictEqual(_.castArray(array), array); + }); - expected[1] = undefined; + QUnit.test('should return an empty array when no arguments are given', function(assert) { + assert.expect(1); - ok(1 in actual); - deepEqual(actual, expected); - }); - } - }); + assert.deepEqual(_.castArray(), []); + }); + }()); /*--------------------------------------------------------------------------*/ - QUnit.module('strict mode checks'); + QUnit.module('lodash.chain'); - _.forEach(['assign', 'bindAll', 'defaults'], function(methodName) { - var func = _[methodName]; + (function() { + QUnit.test('should return a wrapped value', function(assert) { + assert.expect(1); - test('`_.' + methodName + '` should not throw strict mode errors', 1, function() { - var object = { 'a': null, 'b': function(){} }, - pass = true; + if (!isNpm) { + var actual = _.chain({ 'a': 0 }); + assert.ok(actual instanceof _); + } + else { + skipAssert(assert); + } + }); - if (freeze) { - freeze(object); - try { - if (methodName == 'bindAll') { - func(object); - } else { - func(object, { 'a': 1 }); - } - } catch(e) { - pass = false; - } - ok(pass); + QUnit.test('should return existing wrapped values', function(assert) { + assert.expect(2); + + if (!isNpm) { + var wrapped = _({ 'a': 0 }); + assert.strictEqual(_.chain(wrapped), wrapped); + assert.strictEqual(wrapped.chain(), wrapped); } else { - skipTest(); + skipAssert(assert, 2); } }); - }); - /*--------------------------------------------------------------------------*/ + QUnit.test('should enable chaining for methods that return unwrapped values', function(assert) { + assert.expect(6); - QUnit.module('lodash.filter'); + if (!isNpm) { + var array = ['c', 'b', 'a']; - (function() { - test('should return elements the `callback` returns truey for', 1, function() { - var actual = _.filter([1, 2, 3], function(num) { - return num % 2; - }); + assert.ok(_.chain(array).head() instanceof _); + assert.ok(_(array).chain().head() instanceof _); + + assert.ok(_.chain(array).isArray() instanceof _); + assert.ok(_(array).chain().isArray() instanceof _); - deepEqual(actual, [1, 3]); + assert.ok(_.chain(array).sortBy().head() instanceof _); + assert.ok(_(array).chain().sortBy().head() instanceof _); + } + else { + skipAssert(assert, 6); + } }); - test('should not modify wrapped values', 2, function() { + QUnit.test('should chain multiple methods', function(assert) { + assert.expect(6); + if (!isNpm) { - var wrapped = _([1, 2, 3, 4]); + lodashStable.times(2, function(index) { + var array = ['one two three four', 'five six seven eight', 'nine ten eleven twelve'], + expected = { ' ': 9, 'e': 14, 'f': 2, 'g': 1, 'h': 2, 'i': 4, 'l': 2, 'n': 6, 'o': 3, 'r': 2, 's': 2, 't': 5, 'u': 1, 'v': 4, 'w': 2, 'x': 1 }, + wrapped = index ? _(array).chain() : _.chain(array); - var actual = wrapped.filter(function(num) { - return num < 3; - }); + var actual = wrapped + .chain() + .map(function(value) { return value.split(''); }) + .flatten() + .reduce(function(object, chr) { + object[chr] || (object[chr] = 0); + object[chr]++; + return object; + }, {}) + .value(); - deepEqual(actual.value(), [1, 2]); + assert.deepEqual(actual, expected); - actual = wrapped.filter(function(num) { - return num > 2; - }); + array = [1, 2, 3, 4, 5, 6]; + wrapped = index ? _(array).chain() : _.chain(array); + actual = wrapped + .chain() + .filter(function(n) { return n % 2 != 0; }) + .reject(function(n) { return n % 3 == 0; }) + .sortBy(function(n) { return -n; }) + .value(); + + assert.deepEqual(actual, [5, 1]); + + array = [3, 4]; + wrapped = index ? _(array).chain() : _.chain(array); + actual = wrapped + .reverse() + .concat([2, 1]) + .unshift(5) + .tap(function(value) { value.pop(); }) + .map(square) + .value(); - deepEqual(actual.value(), [3, 4]); + assert.deepEqual(actual, [25, 16, 9, 4]); + }); } else { - skipTest(2); + skipAssert(assert, 6); } }); - - test('should be aliased', 1, function() { - strictEqual(_.select, _.filter); - }); }()); /*--------------------------------------------------------------------------*/ + QUnit.module('lodash.chunk'); + (function() { - var objects = [ - { 'a': 0, 'b': 0 }, - { 'a': 1, 'b': 1 }, - { 'a': 2, 'b': 2 } - ]; + var array = [0, 1, 2, 3, 4, 5]; - _.forEach({ - 'find': [objects[1], undefined, objects[2], objects[1]], - 'findLast': [objects[2], undefined, objects[2], objects[2]], - 'findIndex': [1, -1, 2, 1], - 'findLastIndex': [2, -1, 2, 2], - 'findKey': ['1', undefined, '2', '1'], - 'findLastKey': ['2', undefined, '2', '2'] - }, - function(expected, methodName) { - QUnit.module('lodash.' + methodName); + QUnit.test('should return chunked arrays', function(assert) { + assert.expect(1); - var func = _[methodName]; + var actual = _.chunk(array, 3); + assert.deepEqual(actual, [[0, 1, 2], [3, 4, 5]]); + }); - test('should return the correct value', 1, function() { - strictEqual(func(objects, function(object) { return object.a; }), expected[0]); - }); + QUnit.test('should return the last chunk as remaining elements', function(assert) { + assert.expect(1); + + var actual = _.chunk(array, 4); + assert.deepEqual(actual, [[0, 1, 2, 3], [4, 5]]); + }); + + QUnit.test('should treat falsey `size` values, except `undefined`, as `0`', function(assert) { + assert.expect(1); - test('should work with a `thisArg`', 1, function() { - strictEqual(func(objects, function(object, index) { return this[index].a; }, objects), expected[0]); + var expected = lodashStable.map(falsey, function(value) { + return value === undefined ? [[0], [1], [2], [3], [4], [5]] : []; }); - test('should return `' + expected[1] + '` if value is not found', 1, function() { - strictEqual(func(objects, function(object) { return object.a == 3; }), expected[1]); + var actual = lodashStable.map(falsey, function(size, index) { + return index ? _.chunk(array, size) : _.chunk(array); }); - test('should work with an object for `collection`', 1, function() { - var actual = _.find({ 'a': 1, 'b': 2, 'c': 3 }, function(num) { - return num > 2; - }); + assert.deepEqual(actual, expected); + }); - equal(actual, 3); - }); + QUnit.test('should ensure the minimum `size` is `0`', function(assert) { + assert.expect(1); - test('should work with an object for `callback`', 1, function() { - strictEqual(func(objects, { 'b': 2 }), expected[2]); - }); + var values = lodashStable.reject(falsey, lodashStable.isUndefined).concat(-1, -Infinity), + expected = lodashStable.map(values, stubArray); - test('should work with a string for `callback`', 1, function() { - strictEqual(func(objects, 'b'), expected[3]); + var actual = lodashStable.map(values, function(n) { + return _.chunk(array, n); }); - test('should return `' + expected[1] + '` for empty or falsey collections', 1, function() { - var actual = [], - emptyValues = /Index/.test(methodName) ? _.reject(empties, _.isPlainObject) : empties, - expecting = _.map(emptyValues, function() { return expected[1]; }); + assert.deepEqual(actual, expected); + }); - _.forEach(emptyValues, function(value) { - try { - actual.push(func(value, { 'a': 3 })); - } catch(e) { } - }); + QUnit.test('should coerce `size` to an integer', function(assert) { + assert.expect(1); - deepEqual(actual, expecting); - }); + assert.deepEqual(_.chunk(array, array.length / 4), [[0], [1], [2], [3], [4], [5]]); + }); - if (methodName == 'find') { - test('should be aliased', 2, function() { - strictEqual(_.detect, func); - strictEqual(_.findWhere, func); - }); - } + QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) { + assert.expect(1); + + var actual = lodashStable.map([[1, 2], [3, 4]], _.chunk); + assert.deepEqual(actual, [[[1], [2]], [[3], [4]]]); }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.first'); + QUnit.module('lodash.clamp'); (function() { - var array = [1, 2, 3]; + QUnit.test('should work with a `max`', function(assert) { + assert.expect(2); - var objects = [ - { 'a': 2, 'b': 2 }, - { 'a': 1, 'b': 1 }, - { 'a': 0, 'b': 0 } - ]; - - test('should return the first element', 1, function() { - strictEqual(_.first(array), 1); + assert.strictEqual(_.clamp(5, 3), 3); + assert.strictEqual(_.clamp(1, 3), 1); }); - test('should return the first two elements', 1, function() { - deepEqual(_.first(array, 2), [1, 2]); - }); + QUnit.test('should clamp negative numbers', function(assert) { + assert.expect(3); - test('should return an empty array when `n` < `1`', 3, function() { - _.forEach([0, -1, -2], function(n) { - deepEqual(_.first(array, n), []); - }); + assert.strictEqual(_.clamp(-10, -5, 5), -5); + assert.strictEqual(_.clamp(-10.2, -5.5, 5.5), -5.5); + assert.strictEqual(_.clamp(-Infinity, -5, 5), -5); }); - test('should return all elements when `n` >= `array.length`', 2, function() { - _.forEach([3, 4], function(n) { - deepEqual(_.first(array, n), array); - }); - }); + QUnit.test('should clamp positive numbers', function(assert) { + assert.expect(3); - test('should return `undefined` when querying empty arrays', 1, function() { - strictEqual(_.first([]), undefined); + assert.strictEqual(_.clamp(10, -5, 5), 5); + assert.strictEqual(_.clamp(10.6, -5.6, 5.4), 5.4); + assert.strictEqual(_.clamp(Infinity, -5, 5), 5); }); - test('should work when used as `callback` for `_.map`', 1, function() { - var array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]], - actual = _.map(array, _.first); + QUnit.test('should not alter negative numbers in range', function(assert) { + assert.expect(3); - deepEqual(actual, [1, 4, 7]); + assert.strictEqual(_.clamp(-4, -5, 5), -4); + assert.strictEqual(_.clamp(-5, -5, 5), -5); + assert.strictEqual(_.clamp(-5.5, -5.6, 5.6), -5.5); }); - test('should work with a `callback`', 1, function() { - var actual = _.first(array, function(num) { - return num < 3; - }); + QUnit.test('should not alter positive numbers in range', function(assert) { + assert.expect(3); - deepEqual(actual, [1, 2]); + assert.strictEqual(_.clamp(4, -5, 5), 4); + assert.strictEqual(_.clamp(5, -5, 5), 5); + assert.strictEqual(_.clamp(4.5, -5.1, 5.2), 4.5); }); - test('should pass the correct `callback` arguments', 1, function() { - var args; - - _.first(array, function() { - args || (args = slice.call(arguments)); - }); + QUnit.test('should not alter `0` in range', function(assert) { + assert.expect(1); - deepEqual(args, [1, 0, array]); + assert.strictEqual(1 / _.clamp(0, -5, 5), Infinity); }); - test('should support the `thisArg` argument', 1, function() { - var actual = _.first(array, function(num, index) { - return this[index] < 3; - }, array); + QUnit.test('should clamp to `0`', function(assert) { + assert.expect(1); - deepEqual(actual, [1, 2]); + assert.strictEqual(1 / _.clamp(-10, 0, 5), Infinity); }); - test('should chain when passing `n`, `callback`, or `thisArg`', 3, function() { - if (!isNpm) { - var actual = _(array).first(2); + QUnit.test('should not alter `-0` in range', function(assert) { + assert.expect(1); - ok(actual instanceof _); + assert.strictEqual(1 / _.clamp(-0, -5, 5), -Infinity); + }); - actual = _(array).first(function(num) { - return num < 3; - }); + QUnit.test('should clamp to `-0`', function(assert) { + assert.expect(1); - ok(actual instanceof _); + assert.strictEqual(1 / _.clamp(-10, -0, 5), -Infinity); + }); - actual = _(array).first(function(num, index) { - return this[index] < 3; - }, array); + QUnit.test('should return `NaN` when `number` is `NaN`', function(assert) { + assert.expect(1); - ok(actual instanceof _); - } - else { - skipTest(3); - } + assert.deepEqual(_.clamp(NaN, -5, 5), NaN); }); - test('should not chain when arguments are not provided', 1, function() { - if (!isNpm) { - var actual = _(array).first(); - strictEqual(actual, 1); - } - else { - skipTest(); - } - }); - - test('should work with an object for `callback`', 1, function() { - deepEqual(_.first(objects, { 'b': 2 }), objects.slice(0, 1)); - }); - - test('should work with a string for `callback`', 1, function() { - deepEqual(_.first(objects, 'b'), objects.slice(0, 2)); - }); + QUnit.test('should coerce `min` and `max` of `NaN` to `0`', function(assert) { + assert.expect(2); - test('should be aliased', 2, function() { - strictEqual(_.head, _.first); - strictEqual(_.take, _.first); + assert.deepEqual(_.clamp(1, -5, NaN), 0); + assert.deepEqual(_.clamp(-1, NaN, 5), 0); }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.flatten'); + QUnit.module('clone methods'); (function() { - var args = arguments, - array = [{ 'a': [1, [2]] }, { 'a': [3] }]; - - test('should flatten `arguments` objects', 1, function() { - var actual = _.flatten([args, args]); - deepEqual(actual, [1, 2, 3, 1, 2, 3]); - }); + function Foo() { + this.a = 1; + } + Foo.prototype.b = 1; + Foo.c = function() {}; - test('should work with a `callback`', 1, function() { - var actual = _.flatten(array, function(object) { - return object.a; - }); + if (Map) { + var map = new Map; + map.set('a', 1); + map.set('b', 2); + } + if (Set) { + var set = new Set; + set.add(1); + set.add(2); + } + var objects = { + '`arguments` objects': arguments, + 'arrays': ['a', ''], + 'array-like objects': { '0': 'a', 'length': 1 }, + 'booleans': false, + 'boolean objects': Object(false), + 'date objects': new Date, + 'Foo instances': new Foo, + 'objects': { 'a': 0, 'b': 1, 'c': 2 }, + 'objects with object values': { 'a': /a/, 'b': ['B'], 'c': { 'C': 1 } }, + 'objects from another document': realm.object || {}, + 'maps': map, + 'null values': null, + 'numbers': 0, + 'number objects': Object(0), + 'regexes': /a/gim, + 'sets': set, + 'strings': 'a', + 'string objects': Object('a'), + 'undefined values': undefined + }; - deepEqual(actual, [1, 2, 3]); - }); + objects.arrays.length = 3; - test('should work with `isShallow` and `callback`', 1, function() { - var actual = _.flatten(array, true, function(object) { - return object.a; - }); + var uncloneable = { + 'DOM elements': body, + 'functions': Foo, + 'async functions': asyncFunc, + 'generator functions': genFunc, + 'the `Proxy` constructor': Proxy + }; - deepEqual(actual, [1, [2], 3]); + lodashStable.each(errors, function(error) { + uncloneable[error.name + 's'] = error; }); - test('should pass the correct `callback` arguments', 1, function() { - var args; + QUnit.test('`_.clone` should perform a shallow clone', function(assert) { + assert.expect(2); - _.flatten(array, function() { - args || (args = slice.call(arguments)); - }); + var array = [{ 'a': 0 }, { 'b': 1 }], + actual = _.clone(array); - deepEqual(args, [{ 'a': [1, [2]] }, 0, array]); + assert.deepEqual(actual, array); + assert.ok(actual !== array && actual[0] === array[0]); }); - test('should support the `thisArg` argument', 1, function() { - var actual = _.flatten(array, function(object, index) { - return this[index].a; - }, array); + QUnit.test('`_.cloneDeep` should deep clone objects with circular references', function(assert) { + assert.expect(1); - deepEqual(actual, [1, 2, 3]); - }); - - test('should work with a string for `callback`', 1, function() { - deepEqual(_.flatten(array, 'a'), [1, 2, 3]); - }); + var object = { + 'foo': { 'b': { 'c': { 'd': {} } } }, + 'bar': {} + }; - test('should perform a deep flatten when used as `callback` for `_.map`', 1, function() { - var array = [[[['a']]], [[['b']]]], - actual = _.map(array, _.flatten); + object.foo.b.c.d = object; + object.bar.b = object.foo.b; - deepEqual(actual, [['a'], ['b']]); + var actual = _.cloneDeep(object); + assert.ok(actual.bar.b === actual.foo.b && actual === actual.foo.b.c.d && actual !== object); }); - test('should treat sparse arrays as dense', 4, function() { - var array = [[1, 2, 3], Array(3)], - expected = [1, 2, 3], - actual1 = _.flatten(array), - actual2 = _.flatten(array, true); + QUnit.test('`_.cloneDeep` should deep clone objects with lots of circular references', function(assert) { + assert.expect(2); - expected.push(undefined, undefined, undefined); + var cyclical = {}; + lodashStable.times(LARGE_ARRAY_SIZE + 1, function(index) { + cyclical['v' + index] = [index ? cyclical['v' + (index - 1)] : cyclical]; + }); - deepEqual(actual1, expected); - ok(4 in actual1); + var clone = _.cloneDeep(cyclical), + actual = clone['v' + LARGE_ARRAY_SIZE][0]; - deepEqual(actual2, expected); - ok(4 in actual2); + assert.strictEqual(actual, clone['v' + (LARGE_ARRAY_SIZE - 1)]); + assert.notStrictEqual(actual, cyclical['v' + (LARGE_ARRAY_SIZE - 1)]); }); - test('should work with extremely large arrays', 1, function() { - var expected = Array(5e5), - pass = true; - - if (freeze) { - try { - var actual = _.flatten([expected]); - } catch(e) { - pass = false; - } - if (pass) { - deepEqual(actual, expected); - } else { - ok(pass); - } - } else { - skipTest(); - } - }); + QUnit.test('`_.cloneDeepWith` should provide `stack` to `customizer`', function(assert) { + assert.expect(1); - test('should work with empty arrays', 1, function() { - var actual = _.flatten([[], [[]], [[], [[[]]]]]); - deepEqual(actual, []); - }); + var actual; - test('should flatten nested arrays', 1, function() { - var array = [1, [2], [3, [[4]]]], - expected = [1, 2, 3, 4]; + _.cloneDeepWith({ 'a': 1 }, function() { + actual = _.last(arguments); + }); - deepEqual(_.flatten(array), expected); + assert.ok(isNpm + ? actual.constructor.name == 'Stack' + : actual instanceof mapCaches.Stack + ); }); - test('should support shallow flattening nested arrays', 1, function() { - var array = [1, [2], [3, [4]]], - expected = [1, 2, 3, [4]]; + lodashStable.each(['clone', 'cloneDeep'], function(methodName) { + var func = _[methodName], + isDeep = methodName == 'cloneDeep'; - deepEqual(_.flatten(array, true), expected); - }); + lodashStable.forOwn(objects, function(object, kind) { + QUnit.test('`_.' + methodName + '` should clone ' + kind, function(assert) { + assert.expect(2); - test('should support shallow flattening arrays of other arrays', 1, function() { - var array = [[1], [2], [3], [[4]]], - expected = [1, 2, 3, [4]]; + var actual = func(object); + assert.ok(lodashStable.isEqual(actual, object)); - deepEqual(_.flatten(array, true), expected); - }); - }(1, 2, 3)); + if (lodashStable.isObject(object)) { + assert.notStrictEqual(actual, object); + } else { + assert.strictEqual(actual, object); + } + }); + }); - /*--------------------------------------------------------------------------*/ + QUnit.test('`_.' + methodName + '` should clone array buffers', function(assert) { + assert.expect(2); - QUnit.module('forEach methods'); + if (ArrayBuffer) { + var actual = func(arrayBuffer); + assert.strictEqual(actual.byteLength, arrayBuffer.byteLength); + assert.notStrictEqual(actual, arrayBuffer); + } + else { + skipAssert(assert, 2); + } + }); - _.forEach(['forEach', 'forEachRight'], function(methodName) { - var func = _[methodName]; + QUnit.test('`_.' + methodName + '` should clone buffers', function(assert) { + assert.expect(4); - _.forEach({ - 'literal': 'abc', - 'object': Object('abc') - }, - function(collection, key) { - test('`_.' + methodName + '` should work with a string ' + key + ' for `collection` (test in IE < 9)', 2, function() { - var args, - values = []; + if (Buffer) { + var buffer = new Buffer([1, 2]), + actual = func(buffer); - func(collection, function(value) { - args || (args = slice.call(arguments)); - values.push(value); - }); + assert.strictEqual(actual.byteLength, buffer.byteLength); + assert.strictEqual(actual.inspect(), buffer.inspect()); + assert.notStrictEqual(actual, buffer); - if (methodName == 'forEach') { - deepEqual(args, ['a', 0, collection]); - deepEqual(values, ['a', 'b', 'c']); - } else { - deepEqual(args, ['c', 2, collection]); - deepEqual(values, ['c', 'b', 'a']); + buffer[0] = 2; + assert.strictEqual(actual[0], isDeep ? 2 : 1); + } + else { + skipAssert(assert, 4); } }); - }); - test('`_.' + methodName + '` should be aliased', 1, function() { - if (methodName == 'forEach') { - strictEqual(_.each, _.forEach); - } else { - strictEqual(_.eachRight, _.forEachRight); - } - }); - }); - - /*--------------------------------------------------------------------------*/ - - QUnit.module('forIn methods'); + QUnit.test('`_.' + methodName + '` should clone `index` and `input` array properties', function(assert) { + assert.expect(2); - _.forEach(['forIn', 'forInRight'], function(methodName) { - var func = _[methodName]; + var array = /c/.exec('abcde'), + actual = func(array); - test('`_.' + methodName + '` iterates over inherited properties', 1, function() { - function Foo() { this.a = 1; } - Foo.prototype.b = 2; + assert.strictEqual(actual.index, 2); + assert.strictEqual(actual.input, 'abcde'); + }); - var keys = []; - func(new Foo, function(value, key) { keys.push(key); }); - deepEqual(keys.sort(), ['a', 'b']); - }); + QUnit.test('`_.' + methodName + '` should clone `lastIndex` regexp property', function(assert) { + assert.expect(1); - test('`_.' + methodName + '` fixes the JScript [[DontEnum]] bug with inherited properties (test in IE < 9)', 1, function() { - function Foo() {} - Foo.prototype = shadowedObject; + var regexp = /c/g; + regexp.exec('abcde'); - function Bar() {} - Bar.prototype = new Foo; - Bar.prototype.constructor = Bar; + assert.strictEqual(func(regexp).lastIndex, 3); + }); - var keys = []; - func(shadowedObject, function(value, key) { keys.push(key); }); - deepEqual(keys.sort(), shadowedProps); - }); - }); + QUnit.test('`_.' + methodName + '` should clone expando properties', function(assert) { + assert.expect(1); - /*--------------------------------------------------------------------------*/ + var values = lodashStable.map([false, true, 1, 'a'], function(value) { + var object = Object(value); + object.a = 1; + return object; + }); - QUnit.module('forOwn methods'); + var expected = lodashStable.map(values, stubTrue); - _.forEach(['forOwn', 'forOwnRight'], function(methodName) { - var func = _[methodName]; + var actual = lodashStable.map(values, function(value) { + return func(value).a === 1; + }); - test('iterates over the `length` property', 1, function() { - var object = { '0': 'zero', '1': 'one', 'length': 2 }, - props = []; + assert.deepEqual(actual, expected); + }); - func(object, function(value, prop) { props.push(prop); }); - deepEqual(props.sort(), ['0', '1', 'length']); - }); - }); + QUnit.test('`_.' + methodName + '` should clone prototype objects', function(assert) { + assert.expect(2); - /*--------------------------------------------------------------------------*/ + var actual = func(Foo.prototype); - QUnit.module('iteration methods'); + assert.notOk(actual instanceof Foo); + assert.deepEqual(actual, { 'b': 1 }); + }); - (function() { - var methods = [ - 'every', - 'filter', - 'forEach', - 'forEachRight', - 'forIn', - 'forInRight', - 'forOwn', - 'forOwnRight', - 'map', - 'reject', - 'some' - ]; + QUnit.test('`_.' + methodName + '` should set the `[[Prototype]]` of a clone', function(assert) { + assert.expect(1); - var boolMethods = [ - 'every', - 'some' - ]; + assert.ok(func(new Foo) instanceof Foo); + }); - var forInMethods = [ - 'forIn', - 'forInRight' - ]; + QUnit.test('`_.' + methodName + '` should set the `[[Prototype]]` of a clone even when the `constructor` is incorrect', function(assert) { + assert.expect(1); - var iterationMethods = [ - 'forEach', - 'forEachRight', - 'forIn', - 'forInRight', - 'forOwn', - 'forOwnRight' - ] + Foo.prototype.constructor = Object; + assert.ok(func(new Foo) instanceof Foo); + Foo.prototype.constructor = Foo; + }); - var objectMethods = [ - 'forIn', - 'forInRight', - 'forOwn', - 'forOwnRight' - ]; + QUnit.test('`_.' + methodName + '` should ensure `value` constructor is a function before using its `[[Prototype]]`', function(assert) { + assert.expect(1); - var rightMethods = [ - 'forEachRight', - 'forInRight', - 'forOwnRight' - ]; + Foo.prototype.constructor = null; + assert.notOk(func(new Foo) instanceof Foo); + Foo.prototype.constructor = Foo; + }); - _.forEach(methods, function(methodName) { - var array = [1, 2, 3], - func = _[methodName]; + QUnit.test('`_.' + methodName + '` should clone properties that shadow those on `Object.prototype`', function(assert) { + assert.expect(2); - test('`_.' + methodName + '` should pass the correct `callback` arguments', 1, function() { - var args, - expected = [1, 0, array]; + var object = { + 'constructor': objectProto.constructor, + 'hasOwnProperty': objectProto.hasOwnProperty, + 'isPrototypeOf': objectProto.isPrototypeOf, + 'propertyIsEnumerable': objectProto.propertyIsEnumerable, + 'toLocaleString': objectProto.toLocaleString, + 'toString': objectProto.toString, + 'valueOf': objectProto.valueOf + }; - func(array, function() { - args || (args = slice.call(arguments)); - }); + var actual = func(object); - if (_.contains(rightMethods, methodName)) { - expected[0] = 3; - expected[1] = 2; - } - if (_.contains(objectMethods, methodName)) { - expected[1] += ''; - } - deepEqual(args, expected); + assert.deepEqual(actual, object); + assert.notStrictEqual(actual, object); }); - test('`_.' + methodName + '` should support the `thisArg` argument', 2, function() { - var actual; + QUnit.test('`_.' + methodName + '` should clone symbol properties', function(assert) { + assert.expect(7); - function callback(num, index) { - actual = this[index]; + function Foo() { + this[symbol] = { 'c': 1 }; } - func([1], callback, [2]); - equal(actual, 2); + if (Symbol) { + var symbol2 = Symbol('b'); + Foo.prototype[symbol2] = 2; - func({ 'a': 1 }, callback, { 'a': 2 }); - equal(actual, 2); - }); - }); + var symbol3 = Symbol('c'); + defineProperty(Foo.prototype, symbol3, { + 'configurable': true, + 'enumerable': false, + 'writable': true, + 'value': 3 + }); - _.forEach(_.difference(methods, boolMethods), function(methodName) { - var array = [1, 2, 3], - func = _[methodName]; + var object = { 'a': { 'b': new Foo } }; + object[symbol] = { 'b': 1 }; - test('`_.' + methodName + '` should return a wrapped value when chaining', 1, function() { - if (!isNpm) { - var actual = _(array)[methodName](noop); - ok(actual instanceof _); + var actual = func(object); + if (isDeep) { + assert.notStrictEqual(actual[symbol], object[symbol]); + assert.notStrictEqual(actual.a, object.a); + } else { + assert.strictEqual(actual[symbol], object[symbol]); + assert.strictEqual(actual.a, object.a); + } + assert.deepEqual(actual[symbol], object[symbol]); + assert.deepEqual(getSymbols(actual.a.b), [symbol]); + assert.deepEqual(actual.a.b[symbol], object.a.b[symbol]); + assert.deepEqual(actual.a.b[symbol2], object.a.b[symbol2]); + assert.deepEqual(actual.a.b[symbol3], object.a.b[symbol3]); } else { - skipTest(); + skipAssert(assert, 7); } }); - }); - - _.forEach(_.difference(methods, forInMethods), function(methodName) { - var array = [1, 2, 3], - func = _[methodName]; - - test('`_.' + methodName + '` iterates over own properties of objects', 1, function() { - function Foo() { this.a = 1; } - Foo.prototype.b = 2; - var keys = []; - func(new Foo, function(value, key) { keys.push(key); }); - deepEqual(keys, ['a']); - }); - }); + QUnit.test('`_.' + methodName + '` should clone symbol objects', function(assert) { + assert.expect(4); - _.forEach(iterationMethods, function(methodName) { - var array = [1, 2, 3], - func = _[methodName]; + if (Symbol) { + assert.strictEqual(func(symbol), symbol); - test('`_.' + methodName + '` should return the collection', 1, function() { - equal(func(array, Boolean), array); - }); + var object = Object(symbol), + actual = func(object); - test('`_.' + methodName + '` should return the existing wrapper when chaining', 1, function() { - if (!isNpm) { - var wrapper = _(array); - equal(wrapper[methodName](noop), wrapper); + assert.strictEqual(typeof actual, 'object'); + assert.strictEqual(typeof actual.valueOf(), 'symbol'); + assert.notStrictEqual(actual, object); } else { - skipTest(); + skipAssert(assert, 4); } }); - }); - }()); - /*--------------------------------------------------------------------------*/ - - QUnit.module('collection iteration bugs'); + QUnit.test('`_.' + methodName + '` should not clone symbol primitives', function(assert) { + assert.expect(1); - _.forEach(['forEach', 'forEachRight', 'forIn', 'forInRight', 'forOwn', 'forOwnRight'], function(methodName) { - var func = _[methodName]; + if (Symbol) { + assert.strictEqual(func(symbol), symbol); + } + else { + skipAssert(assert); + } + }); - test('`_.' + methodName + '` fixes the JScript [[DontEnum]] bug (test in IE < 9)', 1, function() { - var props = []; - func(shadowedObject, function(value, prop) { props.push(prop); }); - deepEqual(props.sort(), shadowedProps); - }); - - test('`_.' + methodName + '` does not iterate over non-enumerable properties (test in IE < 9)', 10, function() { - _.forOwn({ - 'Array': Array.prototype, - 'Boolean': Boolean.prototype, - 'Date': Date.prototype, - 'Error': Error.prototype, - 'Function': Function.prototype, - 'Object': Object.prototype, - 'Number': Number.prototype, - 'TypeError': TypeError.prototype, - 'RegExp': RegExp.prototype, - 'String': String.prototype - }, - function(object, builtin) { - var message = 'non-enumerable properties on ' + builtin + '.prototype', - props = []; + QUnit.test('`_.' + methodName + '` should not error on DOM elements', function(assert) { + assert.expect(1); - func(object, function(value, prop) { props.push(prop); }); + if (document) { + var element = document.createElement('div'); - if (/Error/.test(builtin)) { - ok(_.every(['constructor', 'toString'], function(prop) { - return !_.contains(props, prop); - }), message); + try { + assert.deepEqual(func(element), {}); + } catch (e) { + assert.ok(false, e.message); + } } else { - deepEqual(props, [], message); + skipAssert(assert); } }); - }); - test('`_.' + methodName + '` skips the prototype property of functions (test in Firefox < 3.6, Opera > 9.50 - Opera < 11.60, and Safari < 5.1)', 2, function() { - function Foo() {} - Foo.prototype.a = 1; + QUnit.test('`_.' + methodName + '` should create an object from the same realm as `value`', function(assert) { + assert.expect(1); - var props = []; - function callback(value, prop) { props.push(prop); } + var props = []; - func(Foo, callback); - deepEqual(props, []); - props.length = 0; + var objects = lodashStable.transform(_, function(result, value, key) { + if (lodashStable.startsWith(key, '_') && lodashStable.isObject(value) && + !lodashStable.isArguments(value) && !lodashStable.isElement(value) && + !lodashStable.isFunction(value)) { + props.push(lodashStable.capitalize(lodashStable.camelCase(key))); + result.push(value); + } + }, []); - Foo.prototype = { 'a': 1 }; - func(Foo, callback); - deepEqual(props, []); - }); - }); + var expected = lodashStable.map(objects, stubTrue); - /*--------------------------------------------------------------------------*/ + var actual = lodashStable.map(objects, function(object) { + var Ctor = object.constructor, + result = func(object); - QUnit.module('object assignments'); + return result !== object && ((result instanceof Ctor) || !(new Ctor instanceof Ctor)); + }); - _.forEach(['assign', 'defaults', 'merge'], function(methodName) { - var func = _[methodName]; + assert.deepEqual(actual, expected, props.join(', ')); + }); - test('`_.' + methodName + '` should return the existing wrapper when chaining', 1, function() { - if (!isNpm) { - var wrapper = _({ 'a': 1 }); - equal(wrapper[methodName]({ 'b': 2 }), wrapper); - } - else { - skipTest(); - } - }); + QUnit.test('`_.' + methodName + '` should perform a ' + (isDeep ? 'deep' : 'shallow') + ' clone when used as an iteratee for methods like `_.map`', function(assert) { + assert.expect(2); - test('`_.' + methodName + '` should assign problem JScript properties (test in IE < 9)', 1, function() { - var object = { - 'constructor': '0', - 'hasOwnProperty': '1', - 'isPrototypeOf': '2', - 'propertyIsEnumerable': undefined, - 'toLocaleString': undefined, - 'toString': undefined, - 'valueOf': undefined - }; + var expected = [{ 'a': [0] }, { 'b': [1] }], + actual = lodashStable.map(expected, func); - var source = { - 'propertyIsEnumerable': '3', - 'toLocaleString': '4', - 'toString': '5', - 'valueOf': '6' - }; + assert.deepEqual(actual, expected); - deepEqual(func(object, source), shadowedObject); - }); + if (isDeep) { + assert.ok(actual[0] !== expected[0] && actual[0].a !== expected[0].a && actual[1].b !== expected[1].b); + } else { + assert.ok(actual[0] !== expected[0] && actual[0].a === expected[0].a && actual[1].b === expected[1].b); + } + }); - test('`_.' + methodName + '` skips the prototype property of functions (test in Firefox < 3.6, Opera > 9.50 - Opera < 11.60, and Safari < 5.1)', 2, function() { - function Foo() {} - Foo.prototype.c = 3; + QUnit.test('`_.' + methodName + '` should return a unwrapped value when chaining', function(assert) { + assert.expect(2); - Foo.a = 1; - Foo.b = 2; + if (!isNpm) { + var object = objects.objects, + actual = _(object)[methodName](); - var expected = { 'a': 1, 'b': 2 }; - deepEqual(func({}, Foo), expected); + assert.deepEqual(actual, object); + assert.notStrictEqual(actual, object); + } + else { + skipAssert(assert, 2); + } + }); - Foo.prototype = { 'c': 3 }; - deepEqual(func({}, Foo), expected); - }); + lodashStable.each(arrayViews, function(type) { + QUnit.test('`_.' + methodName + '` should clone ' + type + ' values', function(assert) { + assert.expect(10); + + var Ctor = root[type]; + + lodashStable.times(2, function(index) { + if (Ctor) { + var buffer = new ArrayBuffer(24), + view = index ? new Ctor(buffer, 8, 1) : new Ctor(buffer), + actual = func(view); + + assert.deepEqual(actual, view); + assert.notStrictEqual(actual, view); + assert.strictEqual(actual.buffer === view.buffer, !isDeep); + assert.strictEqual(actual.byteOffset, view.byteOffset); + assert.strictEqual(actual.length, view.length); + } + else { + skipAssert(assert, 5); + } + }); + }); + }); - test('`_.' + methodName + '` should work with `_.reduce`', 1, function() { - var actual = { 'a': 1}, - array = [{ 'b': 2 }, { 'c': 3 }]; + lodashStable.forOwn(uncloneable, function(value, key) { + QUnit.test('`_.' + methodName + '` should not clone ' + key, function(assert) { + assert.expect(3); - _.reduce(array, func, actual); - deepEqual(actual, { 'a': 1, 'b': 2, 'c': 3}); + if (value) { + var object = { 'a': value, 'b': { 'c': value } }, + actual = func(object), + expected = value === Foo ? { 'c': Foo.c } : {}; + + assert.deepEqual(actual, object); + assert.notStrictEqual(actual, object); + assert.deepEqual(func(value), expected); + } + else { + skipAssert(assert, 3); + } + }); + }); }); - }); - _.forEach(['assign', 'merge'], function(methodName) { - var func = _[methodName]; + lodashStable.each(['cloneWith', 'cloneDeepWith'], function(methodName) { + var func = _[methodName], + isDeep = methodName == 'cloneDeepWith'; - test('`_.' + methodName + '` should pass the correct `callback` arguments', 2, function() { - var args; + QUnit.test('`_.' + methodName + '` should provide correct `customizer` arguments', function(assert) { + assert.expect(1); - func({ 'a': 1 }, { 'a': 2 }, function() { - args || (args = slice.call(arguments)); - }); + var argsList = [], + object = new Foo; - deepEqual(args, [1, 2], 'primitive property values'); + func(object, function() { + var length = arguments.length, + args = slice.call(arguments, 0, length - (length > 1 ? 1 : 0)); - var array = [1, 2], - object = { 'b': 2 }; + argsList.push(args); + }); - args = null; - func({ 'a': array }, { 'a': object }, function() { - args || (args = slice.call(arguments)); + assert.deepEqual(argsList, isDeep ? [[object], [1, 'a', object]] : [[object]]); }); - deepEqual(args, [array, object], 'non-primitive property values'); - }); + QUnit.test('`_.' + methodName + '` should handle cloning when `customizer` returns `undefined`', function(assert) { + assert.expect(1); - test('`_.' + methodName + '`should support the `thisArg` argument', 1, function() { - var actual = func({}, { 'a': 0 }, function(a, b) { - return this[b]; - }, [2]); + var actual = func({ 'a': { 'b': 'c' } }, noop); + assert.deepEqual(actual, { 'a': { 'b': 'c' } }); + }); - deepEqual(actual, { 'a': 2 }); - }); + lodashStable.forOwn(uncloneable, function(value, key) { + QUnit.test('`_.' + methodName + '` should work with a `customizer` callback and ' + key, function(assert) { + assert.expect(3); - test('`_.' + methodName + '` should not treat the second argument as a `callback`', 2, function() { - function callback() {} - callback.b = 2; + var customizer = function(value) { + return lodashStable.isPlainObject(value) ? undefined : value; + }; - var actual = func({ 'a': 1 }, callback); - deepEqual(actual, { 'a': 1, 'b': 2 }); + var actual = func(value, customizer); + assert.strictEqual(actual, value); - actual = func({ 'a': 1 }, callback, { 'c': 3 }); - deepEqual(actual, { 'a': 1, 'b': 2, 'c': 3 }); + var object = { 'a': value, 'b': { 'c': value } }; + actual = func(object, customizer); + + assert.deepEqual(actual, object); + assert.notStrictEqual(actual, object); + }); + }); }); - }); + }()); /*--------------------------------------------------------------------------*/ - QUnit.module('exit early'); + QUnit.module('lodash.compact'); - _.forEach(['forEach', 'forEachRight', 'forIn', 'forInRight', 'forOwn', 'forOwnRight'], function(methodName) { - var func = _[methodName]; + (function() { + var largeArray = lodashStable.range(LARGE_ARRAY_SIZE).concat(null); - test('`_.' + methodName + '` can exit early when iterating arrays', 1, function() { - var array = [1, 2, 3], - values = []; + QUnit.test('should filter falsey values', function(assert) { + assert.expect(1); - func(array, function(value) { values.push(value); return false; }); - deepEqual(values, [/Right/.test(methodName) ? 3 : 1]); + var array = ['0', '1', '2']; + assert.deepEqual(_.compact(falsey.concat(array)), array); }); - test('`_.' + methodName + '` can exit early when iterating objects', 1, function() { - var object = { 'a': 1, 'b': 2, 'c': 3 }, - values = []; + QUnit.test('should work when in-between lazy operators', function(assert) { + assert.expect(2); + + if (!isNpm) { + var actual = _(falsey).thru(_.slice).compact().thru(_.slice).value(); + assert.deepEqual(actual, []); - func(object, function(value) { values.push(value); return false; }); - equal(values.length, 1); + actual = _(falsey).thru(_.slice).push(true, 1).compact().push('a').value(); + assert.deepEqual(actual, [true, 1, 'a']); + } + else { + skipAssert(assert, 2); + } }); - }); - /*--------------------------------------------------------------------------*/ + QUnit.test('should work in a lazy sequence', function(assert) { + assert.expect(1); - QUnit.module('`__proto__` property bugs'); + if (!isNpm) { + var actual = _(largeArray).slice(1).compact().reverse().take().value(); + assert.deepEqual(actual, _.take(_.compact(_.slice(largeArray, 1)).reverse())); + } + else { + skipAssert(assert); + } + }); - (function() { - test('internal data objects should work with the `__proto__` key', 4, function() { - var stringLiteral = '__proto__', - stringObject = Object(stringLiteral), - expected = [stringLiteral, stringObject]; + QUnit.test('should work in a lazy sequence with a custom `_.iteratee`', function(assert) { + assert.expect(1); - var largeArray = _.times(largeArraySize, function(count) { - return count % 2 ? stringObject : stringLiteral; - }); + if (!isModularize) { + var iteratee = _.iteratee, + pass = false; - deepEqual(_.difference(largeArray, largeArray), []); - deepEqual(_.intersection(largeArray, largeArray), expected); - deepEqual(_.uniq(largeArray), expected); - deepEqual(_.without.apply(_, [largeArray].concat(largeArray)), []); - }); + _.iteratee = identity; - test('lodash.memoize should memoize values resolved to the `__proto__` key', 1, function() { - var count = 0, - memoized = _.memoize(function() { return ++count; }); + try { + var actual = _(largeArray).slice(1).compact().value(); + pass = lodashStable.isEqual(actual, _.compact(_.slice(largeArray, 1))); + } catch (e) {console.log(e);} - memoized('__proto__'); - memoized('__proto__'); - strictEqual(count, 1); + assert.ok(pass); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.functions'); + QUnit.module('lodash.concat'); (function() { - test('should return the function names of an object', 1, function() { - var object = { 'a': 'a', 'b': _.identity, 'c': /x/, 'd': _.each }; - deepEqual(_.functions(object), ['b', 'd']); - }); - - test('should include inherited functions', 1, function() { - function Foo() { - this.a = _.identity; - this.b = 'b' - } + QUnit.test('should shallow clone `array`', function(assert) { + assert.expect(2); - Foo.prototype.c = noop; - deepEqual(_.functions(new Foo), ['a', 'c']); - }); + var array = [1, 2, 3], + actual = _.concat(array); - test('should be aliased', 1, function() { - strictEqual(_.methods, _.functions); + assert.deepEqual(actual, array); + assert.notStrictEqual(actual, array); }); - }()); - - /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.groupBy'); + QUnit.test('should concat arrays and values', function(assert) { + assert.expect(2); - (function() { - var array = [4.2, 6.1, 6.4]; + var array = [1], + actual = _.concat(array, 2, [3], [[4]]); - test('should use `_.identity` when no `callback` is provided', 1, function() { - var actual = _.groupBy([4, 6, 6]); - deepEqual(actual, { '4': [4], '6': [6, 6] }); + assert.deepEqual(actual, [1, 2, 3, [4]]); + assert.deepEqual(array, [1]); }); - test('should pass the correct `callback` arguments', 1, function() { - var args; + QUnit.test('should cast non-array `array` values to arrays', function(assert) { + assert.expect(2); - _.groupBy(array, function() { - args || (args = slice.call(arguments)); + var values = [, null, undefined, false, true, 1, NaN, 'a']; + + var expected = lodashStable.map(values, function(value, index) { + return index ? [value] : []; }); - deepEqual(args, [4.2, 0, array]); - }); + var actual = lodashStable.map(values, function(value, index) { + return index ? _.concat(value) : _.concat(); + }); - test('should support the `thisArg` argument', 1, function() { - var actual = _.groupBy(array, function(num) { - return this.floor(num); - }, Math); + assert.deepEqual(actual, expected); - deepEqual(actual, { '4': [4.2], '6': [6.1, 6.4] }); - }); + expected = lodashStable.map(values, function(value) { + return [value, 2, [3]]; + }); - test('should only add values to own, not inherited, properties', 2, function() { - var actual = _.groupBy([4.2, 6.1, 6.4], function(num) { - return Math.floor(num) > 4 ? 'hasOwnProperty' : 'constructor'; + actual = lodashStable.map(values, function(value) { + return _.concat(value, [2], [[3]]); }); - deepEqual(actual.constructor, [4.2]); - deepEqual(actual.hasOwnProperty, [6.1, 6.4]); + assert.deepEqual(actual, expected); }); - test('should work with an object for `collection`', 1, function() { - var actual = _.groupBy({ 'a': 4.2, 'b': 6.1, 'c': 6.4 }, function(num) { - return Math.floor(num); - }); + QUnit.test('should treat sparse arrays as dense', function(assert) { + assert.expect(3); - deepEqual(actual, { '4': [4.2], '6': [6.1, 6.4] }); - }); + var expected = [], + actual = _.concat(Array(1), Array(1)); - test('should work with a number for `callback`', 2, function() { - var array = [ - [1, 'a'], - [2, 'a'], - [2, 'b'] - ]; + expected.push(undefined, undefined); - deepEqual(_.groupBy(array, 0), { '1': [[1 , 'a']], '2': [[2, 'a'], [2, 'b']] }); - deepEqual(_.groupBy(array, 1), { 'a': [[1 , 'a'], [2, 'a']], 'b': [[2, 'b']] }); + assert.ok('0'in actual); + assert.ok('1' in actual); + assert.deepEqual(actual, expected); }); - test('should work with a string for `callback`', 1, function() { - var actual = _.groupBy(['one', 'two', 'three'], 'length'); - deepEqual(actual, { '3': ['one', 'two'], '5': ['three'] }); + QUnit.test('should return a new wrapped array', function(assert) { + assert.expect(2); + + if (!isNpm) { + var array = [1], + wrapped = _(array).concat([2, 3]), + actual = wrapped.value(); + + assert.deepEqual(array, [1]); + assert.deepEqual(actual, [1, 2, 3]); + } + else { + skipAssert(assert, 2); + } }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.has'); + QUnit.module('lodash.cond'); (function() { - test('should check for own properties', 2, function() { - var object = { 'a': 1 }; - strictEqual(_.has(object, 'a'), true); - strictEqual(_.has(object, 'b'), false); - }); - - test('should not use the `hasOwnProperty` method of the object', 1, function() { - var object = { 'hasOwnProperty': null, 'a': 1 }; - strictEqual(_.has(object, 'a'), true); - }); + QUnit.test('should create a conditional function', function(assert) { + assert.expect(3); - test('should not check for inherited properties', 1, function() { - function Foo() {} - Foo.prototype.a = 1; - strictEqual(_.has(new Foo, 'a'), false); - }); + var cond = _.cond([ + [lodashStable.matches({ 'a': 1 }), stubA], + [lodashStable.matchesProperty('b', 1), stubB], + [lodashStable.property('c'), stubC] + ]); - test('should work with functions', 1, function() { - function Foo() {} - strictEqual(_.has(Foo, 'prototype'), true); + assert.strictEqual(cond({ 'a': 1, 'b': 2, 'c': 3 }), 'a'); + assert.strictEqual(cond({ 'a': 0, 'b': 1, 'c': 2 }), 'b'); + assert.strictEqual(cond({ 'a': -1, 'b': 0, 'c': 1 }), 'c'); }); - test('should return `false` for primitives', 1, function() { - var values = falsey.concat(1, 'a'), - expected = _.map(values, function() { return false; }); + QUnit.test('should provide arguments to functions', function(assert) { + assert.expect(2); - var actual = _.map(values, function(value) { - return _.has(value, 'valueOf'); - }); - - deepEqual(actual, expected); - }); - }()); + var args1, + args2, + expected = ['a', 'b', 'c']; - /*--------------------------------------------------------------------------*/ + var cond = _.cond([[ + function() { args1 || (args1 = slice.call(arguments)); return true; }, + function() { args2 || (args2 = slice.call(arguments)); } + ]]); - QUnit.module('lodash.identity'); + cond('a', 'b', 'c'); - (function() { - test('should return the first argument provided', 1, function() { - var object = { 'name': 'fred' }; - strictEqual(_.identity(object), object); + assert.deepEqual(args1, expected); + assert.deepEqual(args2, expected); }); - }()) - /*--------------------------------------------------------------------------*/ + QUnit.test('should work with predicate shorthands', function(assert) { + assert.expect(3); - QUnit.module('lodash.indexBy'); + var cond = _.cond([ + [{ 'a': 1 }, stubA], + [['b', 1], stubB], + ['c', stubC] + ]); - (function() { - test('should use `_.identity` when no `callback` is provided', 1, function() { - var actual = _.indexBy([4, 6, 6]); - deepEqual(actual, { '4': 4, '6': 6 }); + assert.strictEqual(cond({ 'a': 1, 'b': 2, 'c': 3 }), 'a'); + assert.strictEqual(cond({ 'a': 0, 'b': 1, 'c': 2 }), 'b'); + assert.strictEqual(cond({ 'a': -1, 'b': 0, 'c': 1 }), 'c'); }); - test('should support the `thisArg` argument', 1, function() { - var actual = _.indexBy([4.2, 6.1, 6.4], function(num) { - return this.floor(num); - }, Math); + QUnit.test('should return `undefined` when no condition is met', function(assert) { + assert.expect(1); - deepEqual(actual, { '4': 4.2, '6': 6.4 }); + var cond = _.cond([[stubFalse, stubA]]); + assert.strictEqual(cond({ 'a': 1 }), undefined); }); - test('should only add values to own, not inherited, properties', 2, function() { - var actual = _.indexBy([4.2, 6.1, 6.4], function(num) { - return Math.floor(num) > 4 ? 'hasOwnProperty' : 'constructor'; - }); - - deepEqual(actual.constructor, 4.2); - deepEqual(actual.hasOwnProperty, 6.4); - }); + QUnit.test('should throw a TypeError if `pairs` is not composed of functions', function(assert) { + assert.expect(2); - test('should work with an object for `collection`', 1, function() { - var actual = _.indexBy({ 'a': 4.2, 'b': 6.1, 'c': 6.4 }, function(num) { - return Math.floor(num); + lodashStable.each([false, true], function(value) { + assert.raises(function() { _.cond([[stubTrue, value]])(); }, TypeError); }); - - deepEqual(actual, { '4': 4.2, '6': 6.4 }); }); - test('should work with a number for `callback`', 2, function() { - var array = [ - [1, 'a'], - [2, 'a'], - [2, 'b'] - ]; + QUnit.test('should use `this` binding of function for `pairs`', function(assert) { + assert.expect(1); + + var cond = _.cond([ + [function(a) { return this[a]; }, function(a, b) { return this[b]; }] + ]); - deepEqual(_.indexBy(array, 0), { '1': [1 , 'a'], '2': [2, 'b'] }); - deepEqual(_.indexBy(array, 1), { 'a': [2, 'a'], 'b': [2, 'b'] }); + var object = { 'cond': cond, 'a': 1, 'b': 2 }; + assert.strictEqual(object.cond('a', 'b'), 2); }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.indexOf'); + QUnit.module('lodash.conforms'); (function() { - var array = [1, 2, 3, 1, 2, 3]; - - test('should return the index of the first matched value', 1, function() { - equal(_.indexOf(array, 3), 2); - }); - - test('should return `-1` for an unmatched value', 1, function() { - equal(_.indexOf(array, 4), -1); - }); + QUnit.test('should not change behavior if `source` is modified', function(assert) { + assert.expect(2); - test('should work with a positive `fromIndex`', 1, function() { - equal(_.indexOf(array, 1, 2), 3); - }); - - test('should work with `fromIndex` >= `array.length`', 4, function() { - equal(_.indexOf(array, 1, 6), -1); - equal(_.indexOf(array, undefined, 6), -1); - equal(_.indexOf(array, 1, 8), -1); - equal(_.indexOf(array, undefined, 8), -1); - }); - - test('should work with a negative `fromIndex`', 1, function() { - equal(_.indexOf(array, 2, -3), 4); - }); - - test('should work with a negative `fromIndex` <= `-array.length`', 2, function() { - strictEqual(_.indexOf(array, 1, -6), 0); - strictEqual(_.indexOf(array, 2, -8), 1); - }); + var object = { 'a': 2 }, + source = { 'a': function(value) { return value > 1; } }, + par = _.conforms(source); - test('should ignore non-number `fromIndex` values', 1, function() { - strictEqual(_.indexOf([1, 2, 3], 1, '1'), 0); - }); + assert.strictEqual(par(object), true); - test('should work with `isSorted`', 1, function() { - strictEqual(_.indexOf([1, 2, 3], 1, true), 0); + source.a = function(value) { return value < 2; }; + assert.strictEqual(par(object), true); }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('custom `_.indexOf` methods'); + QUnit.module('conforms methods'); - (function() { - function custom(array, value, fromIndex) { - var index = (fromIndex || 0) - 1, - length = array.length; + lodashStable.each(['conforms', 'conformsTo'], function(methodName) { + var isConforms = methodName == 'conforms'; - while (++index < length) { - var other = array[index]; - if (other === value || (value instanceof Foo && other instanceof Foo)) { - return index; - } - } - return -1; + function conforms(source) { + return isConforms ? _.conforms(source) : function(object) { + return _.conformsTo(object, source); + }; } - function Foo() {} + QUnit.test('`_.' + methodName + '` should check if `object` conforms to `source`', function(assert) { + assert.expect(2); - var array = [1, new Foo, 3, new Foo], - indexOf = _.indexOf; + var objects = [ + { 'a': 1, 'b': 8 }, + { 'a': 2, 'b': 4 }, + { 'a': 3, 'b': 16 } + ]; - test('`_.contains` should work with a custom `_.indexOf` method', 1, function() { - if (!isModularize) { - _.indexOf = custom; - ok(_.contains(array, new Foo)); - _.indexOf = indexOf; - } - else { - skipTest(); - } - }); + var par = conforms({ + 'b': function(value) { return value > 4; } + }); - test('`_.difference` should work with a custom `_.indexOf` method', 1, function() { - if (!isModularize) { - _.indexOf = custom; - deepEqual(_.difference(array, [new Foo]), [1, 3]); - _.indexOf = indexOf; - } - else { - skipTest(); - } + var actual = lodashStable.filter(objects, par); + assert.deepEqual(actual, [objects[0], objects[2]]); + + par = conforms({ + 'b': function(value) { return value > 8; }, + 'a': function(value) { return value > 1; } + }); + + actual = lodashStable.filter(objects, par); + assert.deepEqual(actual, [objects[2]]); }); - test('`_.intersection` should work with a custom `_.indexOf` method', 1, function() { - if (!isModularize) { - _.indexOf = custom; - deepEqual(_.intersection(array, [new Foo]), [array[1]]); - _.indexOf = indexOf; - } - else { - skipTest(); + QUnit.test('`_.' + methodName + '` should not match by inherited `source` properties', function(assert) { + assert.expect(1); + + function Foo() { + this.a = function(value) { + return value > 1; + }; } - }); + Foo.prototype.b = function(value) { + return value > 8; + }; - test('`_.uniq` should work with a custom `_.indexOf` method', 2, function() { - if (!isModularize) { - _.indexOf = custom; - deepEqual(_.uniq(array), array.slice(0, 3)); + var objects = [ + { 'a': 1, 'b': 8 }, + { 'a': 2, 'b': 4 }, + { 'a': 3, 'b': 16 } + ]; - var largeArray = _.times(largeArraySize, function() { - return new Foo; - }); + var par = conforms(new Foo), + actual = lodashStable.filter(objects, par); - deepEqual(_.uniq(largeArray), [largeArray[0]]); - _.indexOf = indexOf; - } - else { - skipTest(2); - } + assert.deepEqual(actual, [objects[1], objects[2]]); }); - }()); - /*--------------------------------------------------------------------------*/ + QUnit.test('`_.' + methodName + '` should not invoke `source` predicates for missing `object` properties', function(assert) { + assert.expect(2); - QUnit.module('lodash.initial'); + var count = 0; - (function() { - var array = [1, 2, 3]; + var par = conforms({ + 'a': function() { count++; return true; } + }); - var objects = [ - { 'a': 0, 'b': 0 }, - { 'a': 1, 'b': 1 }, - { 'a': 2, 'b': 2 } - ]; + assert.strictEqual(par({}), false); + assert.strictEqual(count, 0); + }); - test('should accept a falsey `array` argument', 1, function() { - var expected = _.map(falsey, function() { return []; }); + QUnit.test('`_.' + methodName + '` should work with a function for `object`', function(assert) { + assert.expect(2); - var actual = _.map(falsey, function(value, index) { - try { - return index ? _.initial(value) : _.initial(); - } catch(e) { } + function Foo() {} + Foo.a = 1; + + function Bar() {} + Bar.a = 2; + + var par = conforms({ + 'a': function(value) { return value > 1; } }); - deepEqual(actual, expected); + assert.strictEqual(par(Foo), false); + assert.strictEqual(par(Bar), true); }); - test('should exclude last element', 1, function() { - deepEqual(_.initial(array), [1, 2]); - }); + QUnit.test('`_.' + methodName + '` should work with a function for `source`', function(assert) { + assert.expect(1); - test('should exclude the last two elements', 1, function() { - deepEqual(_.initial(array, 2), [1]); - }); + function Foo() {} + Foo.a = function(value) { return value > 1; }; - test('should return an empty when querying empty arrays', 1, function() { - deepEqual(_.initial([]), []); - }); + var objects = [{ 'a': 1 }, { 'a': 2 }], + actual = lodashStable.filter(objects, conforms(Foo)); - test('should return all elements when `n` < `1`', 3, function() { - _.forEach([0, -1, -2], function(n) { - deepEqual(_.initial(array, n), array); - }); + assert.deepEqual(actual, [objects[1]]); }); - test('should return an empty array when `n` >= `array.length`', 2, function() { - _.forEach([3, 4], function(n) { - deepEqual(_.initial(array, n), []); + QUnit.test('`_.' + methodName + '` should work with a non-plain `object`', function(assert) { + assert.expect(1); + + function Foo() { + this.a = 1; + } + Foo.prototype.b = 2; + + var par = conforms({ + 'b': function(value) { return value > 1; } }); + + assert.strictEqual(par(new Foo), true); }); - test('should work when used as `callback` for `_.map`', 1, function() { - var array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]], - actual = _.map(array, _.initial); + QUnit.test('`_.' + methodName + '` should return `false` when `object` is nullish', function(assert) { + assert.expect(1); - deepEqual(actual, [[1, 2], [4, 5], [7, 8]]); - }); + var values = [, null, undefined], + expected = lodashStable.map(values, stubFalse); + + var par = conforms({ + 'a': function(value) { return value > 1; } + }); - test('should work with a `callback`', 1, function() { - var actual = _.initial(array, function(num) { - return num > 1; + var actual = lodashStable.map(values, function(value, index) { + try { + return index ? par(value) : par(); + } catch (e) {} }); - deepEqual(actual, [1]); + assert.deepEqual(actual, expected); }); - test('should pass the correct `callback` arguments', 1, function() { - var args; + QUnit.test('`_.' + methodName + '` should return `true` when comparing an empty `source` to a nullish `object`', function(assert) { + assert.expect(1); - _.initial(array, function() { - args || (args = slice.call(arguments)); + var values = [, null, undefined], + expected = lodashStable.map(values, stubTrue), + par = conforms({}); + + var actual = lodashStable.map(values, function(value, index) { + try { + return index ? par(value) : par(); + } catch (e) {} }); - deepEqual(args, [3, 2, array]); + assert.deepEqual(actual, expected); }); - test('should support the `thisArg` argument', 1, function() { - var actual = _.initial(array, function(num, index) { - return this[index] > 1; - }, array); + QUnit.test('`_.' + methodName + '` should return `true` when comparing an empty `source`', function(assert) { + assert.expect(1); - deepEqual(actual, [1]); - }); + var object = { 'a': 1 }, + expected = lodashStable.map(empties, stubTrue); - test('should work with an object for `callback`', 1, function() { - deepEqual(_.initial(objects, { 'b': 2 }), objects.slice(0, 2)); - }); + var actual = lodashStable.map(empties, function(value) { + var par = conforms(value); + return par(object); + }); - test('should work with a string for `callback`', 1, function() { - deepEqual(_.initial(objects, 'b'), objects.slice(0, 1)); + assert.deepEqual(actual, expected); }); - }()); + }); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.intersection'); + QUnit.module('lodash.constant'); (function() { - test('should return the intersection of the given arrays', 1, function() { - var actual = _.intersection([1, 3, 2], [5, 2, 1, 4], [2, 1]); - deepEqual(actual, [1, 2]); - }); + QUnit.test('should create a function that returns `value`', function(assert) { + assert.expect(1); - test('should return an array of unique values', 1, function() { - var actual = _.intersection([1, 1, 3, 2, 2], [5, 2, 2, 1, 4], [2, 1, 1]); - deepEqual(actual, [1, 2]); + var object = { 'a': 1 }, + values = Array(2).concat(empties, true, 1, 'a'), + constant = _.constant(object); + + var results = lodashStable.map(values, function(value, index) { + if (index < 2) { + return index ? constant.call({}) : constant(); + } + return constant(value); + }); + + assert.ok(lodashStable.every(results, function(result) { + return result === object; + })); }); - test('should work with large arrays of objects', 1, function() { - var object = {}, - expected = [object]; + QUnit.test('should work with falsey values', function(assert) { + assert.expect(1); - var largeArray = _.times(largeArraySize, function() { - return object; + var expected = lodashStable.map(falsey, stubTrue); + + var actual = lodashStable.map(falsey, function(value, index) { + var constant = index ? _.constant(value) : _.constant(), + result = constant(); + + return (result === value) || (result !== result && value !== value); }); - deepEqual(_.intersection(expected, largeArray), expected); + assert.deepEqual(actual, expected); }); - test('should return a wrapped value when chaining', 2, function() { + QUnit.test('should return a wrapped value when chaining', function(assert) { + assert.expect(1); + if (!isNpm) { - var actual = _([1, 3, 2]).intersection([5, 2, 1, 4]); - ok(actual instanceof _); - deepEqual(actual.value(), [1, 2]); + var wrapped = _(true).constant(); + assert.ok(wrapped instanceof _); } else { - skipTest(2); + skipAssert(assert); } }); - - test('should ignore individual secondary values', 1, function() { - deepEqual(_.intersection([1, null, 3], 3, null), []); - }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.invert'); + QUnit.module('lodash.countBy'); (function() { - test('should invert an object', 2, function() { - var object = { 'a': 1, 'b': 2 }, - actual = _.invert(object); + var array = [6.1, 4.2, 6.3]; - deepEqual(actual, { '1': 'a', '2': 'b' }); - deepEqual(_.invert(actual), { 'a': '1', 'b': '2' }); - }); + QUnit.test('should transform keys by `iteratee`', function(assert) { + assert.expect(1); - test('should work with an object that has a `length` property', 1, function() { - var object = { '0': 'a', '1': 'b', 'length': 2 }; - deepEqual(_.invert(object), { 'a': '0', 'b': '1', '2': 'length' }); + var actual = _.countBy(array, Math.floor); + assert.deepEqual(actual, { '4': 1, '6': 2 }); }); - }()); - /*--------------------------------------------------------------------------*/ - - QUnit.module('lodash.invoke'); + QUnit.test('should use `_.identity` when `iteratee` is nullish', function(assert) { + assert.expect(1); - (function() { - test('should invoke a methods on each element of a collection', 1, function() { - var actual = _.invoke(['a', 'b', 'c'], 'toUpperCase'); - deepEqual(actual, ['A', 'B', 'C']); - }); + var array = [4, 6, 6], + values = [, null, undefined], + expected = lodashStable.map(values, lodashStable.constant({ '4': 1, '6': 2 })); - test('should work with a function `methodName` argument', 1, function() { - var actual = _.invoke(['a', 'b', 'c'], function() { - return this.toUpperCase(); + var actual = lodashStable.map(values, function(value, index) { + return index ? _.countBy(array, value) : _.countBy(array); }); - deepEqual(actual, ['A', 'B', 'C']); - }); - - test('should work with an object for `collection`', 1, function() { - var object = { 'a': 1, 'b': 2, 'c': 3 }; - deepEqual(_.invoke(object, 'toFixed', 1), ['1.0', '2.0', '3.0']); + assert.deepEqual(actual, expected); }); - }()); - - /*--------------------------------------------------------------------------*/ - - QUnit.module('lodash.isArguments'); - (function() { - var args = arguments; + QUnit.test('should work with `_.property` shorthands', function(assert) { + assert.expect(1); - test('should return `true` for `arguments` objects', 1, function() { - strictEqual(_.isArguments(args), true); + var actual = _.countBy(['one', 'two', 'three'], 'length'); + assert.deepEqual(actual, { '3': 2, '5': 1 }); }); - test('should return `false` for non `arguments` objects', 9, function() { - var expected = _.map(falsey, function() { return false; }); + QUnit.test('should only add values to own, not inherited, properties', function(assert) { + assert.expect(2); - var actual = _.map(falsey, function(value, index) { - return index ? _.isArguments(value) : _.isArguments(); + var actual = _.countBy(array, function(n) { + return Math.floor(n) > 4 ? 'hasOwnProperty' : 'constructor'; }); - strictEqual(_.isArguments([1, 2, 3]), false); - strictEqual(_.isArguments(true), false); - strictEqual(_.isArguments(new Date), false); - strictEqual(_.isArguments(_), false); - strictEqual(_.isArguments({ '0': 1, 'callee': noop, 'length': 1 }), false); - strictEqual(_.isArguments(0), false); - strictEqual(_.isArguments(/x/), false); - strictEqual(_.isArguments('a'), false); - - deepEqual(actual, expected); + assert.deepEqual(actual.constructor, 1); + assert.deepEqual(actual.hasOwnProperty, 2); }); - test('should work with `arguments` objects from another realm', 1, function() { - if (_._object) { - strictEqual(_.isArguments(_._arguments), true); - } - else { - skipTest(); - } - }); - }(1, 2, 3)); + QUnit.test('should work with a number for `iteratee`', function(assert) { + assert.expect(2); - /*--------------------------------------------------------------------------*/ + var array = [ + [1, 'a'], + [2, 'a'], + [2, 'b'] + ]; - QUnit.module('lodash.isArray'); + assert.deepEqual(_.countBy(array, 0), { '1': 1, '2': 2 }); + assert.deepEqual(_.countBy(array, 1), { 'a': 2, 'b': 1 }); + }); - (function() { - var args = arguments; + QUnit.test('should work with an object for `collection`', function(assert) { + assert.expect(1); - test('should return `true` for arrays', 1, function() { - strictEqual(_.isArray([1, 2, 3]), true); + var actual = _.countBy({ 'a': 6.1, 'b': 4.2, 'c': 6.3 }, Math.floor); + assert.deepEqual(actual, { '4': 1, '6': 2 }); }); - test('should return `false` for non arrays', 9, function() { - var expected = _.map(falsey, function() { return false; }); - - var actual = _.map(falsey, function(value, index) { - return index ? _.isArray(value) : _.isArray(); - }); + QUnit.test('should work in a lazy sequence', function(assert) { + assert.expect(1); - strictEqual(_.isArray(args), false); - strictEqual(_.isArray(true), false); - strictEqual(_.isArray(new Date), false); - strictEqual(_.isArray(_), false); - strictEqual(_.isArray({ '0': 1, 'length': 1 }), false); - strictEqual(_.isArray(0), false); - strictEqual(_.isArray(/x/), false); - strictEqual(_.isArray('a'), false); + if (!isNpm) { + var array = lodashStable.range(LARGE_ARRAY_SIZE).concat( + lodashStable.range(Math.floor(LARGE_ARRAY_SIZE / 2), LARGE_ARRAY_SIZE), + lodashStable.range(Math.floor(LARGE_ARRAY_SIZE / 1.5), LARGE_ARRAY_SIZE) + ); - deepEqual(actual, expected); - }); + var actual = _(array).countBy().map(square).filter(isEven).take().value(); - test('should work with arrays from another realm', 1, function() { - if (_._object) { - strictEqual(_.isArray(_._array), true); + assert.deepEqual(actual, _.take(_.filter(_.map(_.countBy(array), square), isEven))); } else { - skipTest(); + skipAssert(assert); } }); - }(1, 2, 3)); + }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.isBoolean'); + QUnit.module('lodash.create'); (function() { - var args = arguments; + function Shape() { + this.x = 0; + this.y = 0; + } - test('should return `true` for booleans', 4, function() { - strictEqual(_.isBoolean(true), true); - strictEqual(_.isBoolean(false), true); - strictEqual(_.isBoolean(new Boolean(true)), true); - strictEqual(_.isBoolean(new Boolean(false)), true); - }); + function Circle() { + Shape.call(this); + } - test('should return `false` for non booleans', 9, function() { - var expected = _.map(falsey, function(value) { return value === false; }); + QUnit.test('should create an object that inherits from the given `prototype` object', function(assert) { + assert.expect(3); - var actual = _.map(falsey, function(value, index) { - return index ? _.isBoolean(value) : _.isBoolean(); - }); + Circle.prototype = _.create(Shape.prototype); + Circle.prototype.constructor = Circle; - strictEqual(_.isBoolean(args), false); - strictEqual(_.isBoolean([1, 2, 3]), false); - strictEqual(_.isBoolean(new Date), false); - strictEqual(_.isBoolean(_), false); - strictEqual(_.isBoolean({ 'a': 1 }), false); - strictEqual(_.isBoolean(0), false); - strictEqual(_.isBoolean(/x/), false); - strictEqual(_.isBoolean('a'), false); + var actual = new Circle; - deepEqual(actual, expected); + assert.ok(actual instanceof Circle); + assert.ok(actual instanceof Shape); + assert.notStrictEqual(Circle.prototype, Shape.prototype); }); - test('should work with booleans from another realm', 1, function() { - if (_._object) { - strictEqual(_.isBoolean(_._boolean), true); - } - else { - skipTest(); - } - }); - }(1, 2, 3)); + QUnit.test('should assign `properties` to the created object', function(assert) { + assert.expect(3); - /*--------------------------------------------------------------------------*/ + var expected = { 'constructor': Circle, 'radius': 0 }; + Circle.prototype = _.create(Shape.prototype, expected); - QUnit.module('lodash.isDate'); - - (function() { - var args = arguments; + var actual = new Circle; - test('should return `true` for dates', 1, function() { - strictEqual(_.isDate(new Date), true); + assert.ok(actual instanceof Circle); + assert.ok(actual instanceof Shape); + assert.deepEqual(Circle.prototype, expected); }); - test('should return `false` for non dates', 9, function() { - var expected = _.map(falsey, function() { return false; }); + QUnit.test('should assign own properties', function(assert) { + assert.expect(1); - var actual = _.map(falsey, function(value, index) { - return index ? _.isDate(value) : _.isDate(); - }); - - strictEqual(_.isDate(args), false); - strictEqual(_.isDate([1, 2, 3]), false); - strictEqual(_.isDate(true), false); - strictEqual(_.isDate(_), false); - strictEqual(_.isDate({ 'a': 1 }), false); - strictEqual(_.isDate(0), false); - strictEqual(_.isDate(/x/), false); - strictEqual(_.isDate('a'), false); + function Foo() { + this.a = 1; + this.c = 3; + } + Foo.prototype.b = 2; - deepEqual(actual, expected); + assert.deepEqual(_.create({}, new Foo), { 'a': 1, 'c': 3 }); }); - test('should work with dates from another realm', 1, function() { - if (_._object) { - strictEqual(_.isDate(_._date), true); - } - else { - skipTest(); + QUnit.test('should assign properties that shadow those of `prototype`', function(assert) { + assert.expect(1); + + function Foo() { + this.a = 1; } + var object = _.create(new Foo, { 'a': 1 }); + assert.deepEqual(lodashStable.keys(object), ['a']); }); - }(1, 2, 3)); - /*--------------------------------------------------------------------------*/ + QUnit.test('should accept a falsey `prototype`', function(assert) { + assert.expect(1); - QUnit.module('lodash.isElement'); + var expected = lodashStable.map(falsey, stubObject); - (function() { - test('should use strict equality in its duck type check', 6, function() { - var element = body || { 'nodeType': 1 }; + var actual = lodashStable.map(falsey, function(prototype, index) { + return index ? _.create(prototype) : _.create(); + }); - strictEqual(_.isElement(element), true); - strictEqual(_.isElement({ 'nodeType': new Number(1) }), false); - strictEqual(_.isElement({ 'nodeType': true }), false); - strictEqual(_.isElement({ 'nodeType': [1] }), false); - strictEqual(_.isElement({ 'nodeType': '1' }), false); - strictEqual(_.isElement({ 'nodeType': '001' }), false); + assert.deepEqual(actual, expected); }); - test('should work with elements from another realm', 1, function() { - if (_._element) { - strictEqual(_.isElement(_._element), true); - } - else { - skipTest(); - } + QUnit.test('should ignore a primitive `prototype` and use an empty object instead', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(primitives, stubTrue); + + var actual = lodashStable.map(primitives, function(value, index) { + return lodashStable.isPlainObject(index ? _.create(value) : _.create()); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) { + assert.expect(1); + + var array = [{ 'a': 1 }, { 'a': 1 }, { 'a': 1 }], + expected = lodashStable.map(array, stubTrue), + objects = lodashStable.map(array, _.create); + + var actual = lodashStable.map(objects, function(object) { + return object.a === 1 && !_.keys(object).length; + }); + + assert.deepEqual(actual, expected); }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.isEmpty'); + QUnit.module('lodash.curry'); (function() { - var args = arguments; + function fn(a, b, c, d) { + return slice.call(arguments); + } - test('should return `true` for empty or falsey values', 3, function() { - var expected = _.map(empties, function() { return true; }); + QUnit.test('should curry based on the number of arguments given', function(assert) { + assert.expect(3); - var actual = _.map(empties, function(value) { - return _.isEmpty(value); - }); + var curried = _.curry(fn), + expected = [1, 2, 3, 4]; - strictEqual(_.isEmpty(), true); - strictEqual(_.isEmpty(/x/), true); - deepEqual(actual, expected); + assert.deepEqual(curried(1)(2)(3)(4), expected); + assert.deepEqual(curried(1, 2)(3, 4), expected); + assert.deepEqual(curried(1, 2, 3, 4), expected); }); - test('should return `false` for non-empty values', 3, function() { - strictEqual(_.isEmpty([0]), false); - strictEqual(_.isEmpty({ 'a': 0 }), false); - strictEqual(_.isEmpty('a'), false); - }); + QUnit.test('should allow specifying `arity`', function(assert) { + assert.expect(3); - test('fixes the JScript [[DontEnum]] bug (test in IE < 9)', 1, function() { - equal(_.isEmpty(shadowedObject), false); + var curried = _.curry(fn, 3), + expected = [1, 2, 3]; + + assert.deepEqual(curried(1)(2, 3), expected); + assert.deepEqual(curried(1, 2)(3), expected); + assert.deepEqual(curried(1, 2, 3), expected); }); - test('skips the prototype property of functions (test in Firefox < 3.6, Opera > 9.50 - Opera < 11.60, and Safari < 5.1)', 2, function() { - function Foo() {} - Foo.prototype.a = 1; - strictEqual(_.isEmpty(Foo), true); + QUnit.test('should coerce `arity` to an integer', function(assert) { + assert.expect(2); - Foo.prototype = { 'a': 1 }; - strictEqual(_.isEmpty(Foo), true); - }); + var values = ['0', 0.6, 'xyz'], + expected = lodashStable.map(values, stubArray); - test('should work with an object that has a `length` property', 1, function() { - strictEqual(_.isEmpty({ 'length': 0 }), false); + var actual = lodashStable.map(values, function(arity) { + return _.curry(fn, arity)(); + }); + + assert.deepEqual(actual, expected); + assert.deepEqual(_.curry(fn, '2')(1)(2), [1, 2]); }); - test('should work with jQuery/MooTools DOM query collections', 1, function() { - function Foo(elements) { push.apply(this, elements); } - Foo.prototype = { 'length': 0, 'splice': Array.prototype.splice }; + QUnit.test('should support placeholders', function(assert) { + assert.expect(4); - strictEqual(_.isEmpty(new Foo([])), true); - }); + var curried = _.curry(fn), + ph = curried.placeholder; - test('should work with `arguments` objects (test in IE < 9)', 1, function() { - if (!isPhantomPage) { - strictEqual(_.isEmpty(args), false); - } else { - skipTest(); - } + assert.deepEqual(curried(1)(ph, 3)(ph, 4)(2), [1, 2, 3, 4]); + assert.deepEqual(curried(ph, 2)(1)(ph, 4)(3), [1, 2, 3, 4]); + assert.deepEqual(curried(ph, ph, 3)(ph, 2)(ph, 4)(1), [1, 2, 3, 4]); + assert.deepEqual(curried(ph, ph, ph, 4)(ph, ph, 3)(ph, 2)(1), [1, 2, 3, 4]); }); - test('should return an unwrapped value when intuitively chaining', 1, function() { - if (!isNpm) { - strictEqual(_({}).isEmpty(), true); - } - else { - skipTest(); - } + QUnit.test('should persist placeholders', function(assert) { + assert.expect(1); + + var curried = _.curry(fn), + ph = curried.placeholder, + actual = curried(ph, ph, ph, 'd')('a')(ph)('b')('c'); + + assert.deepEqual(actual, ['a', 'b', 'c', 'd']); }); - test('should return a wrapped value when explicitly chaining', 1, function() { - if (!isNpm) { - ok(_({}).chain().isEmpty() instanceof _); + QUnit.test('should use `_.placeholder` when set', function(assert) { + assert.expect(1); + + if (!isModularize) { + var curried = _.curry(fn), + _ph = _.placeholder = {}, + ph = curried.placeholder; + + assert.deepEqual(curried(1)(_ph, 3)(ph, 4), [1, ph, 3, 4]); + delete _.placeholder; } else { - skipTest(); + skipAssert(assert); } }); - }(1, 2, 3)); - /*--------------------------------------------------------------------------*/ + QUnit.test('should provide additional arguments after reaching the target arity', function(assert) { + assert.expect(3); - QUnit.module('lodash.isEqual'); + var curried = _.curry(fn, 3); + assert.deepEqual(curried(1)(2, 3, 4), [1, 2, 3, 4]); + assert.deepEqual(curried(1, 2)(3, 4, 5), [1, 2, 3, 4, 5]); + assert.deepEqual(curried(1, 2, 3, 4, 5, 6), [1, 2, 3, 4, 5, 6]); + }); - (function() { - test('should perform comparisons between primitive values', 1, function() { - var pairs = [ - [1, 1, true], [1, new Number(1), true], [1, '1', false], [1, 2, false], - [-0, -0, true], [0, 0, true], [0, new Number(0), true], [new Number(0), new Number(0), true], [-0, 0, false], [0, '0', false], [0, null, false], - [NaN, NaN, true], [NaN, new Number(NaN), true], [new Number(NaN), new Number(NaN), true], [NaN, 'a', false], [NaN, Infinity, false], - ['a', 'a', true], ['a', new String('a'), true], [new String('a'), new String('a'), true], ['a', 'b', false], ['a', ['a'], false], - [true, true, true], [true, new Boolean(true), true], [new Boolean(true), new Boolean(true), true], [true, 1, false], [true, 'a', false], - [false, false, true], [false, new Boolean(false), true], [new Boolean(false), new Boolean(false), true], [false, 0, false], [false, '', false], - [null, null, true], [null, undefined, false], [null, {}, false], [null, '', false], - [undefined, undefined, true], [undefined, null, false], [undefined, '', false] - ]; + QUnit.test('should create a function with a `length` of `0`', function(assert) { + assert.expect(6); - var expected = _.map(pairs, function(pair) { - return pair[2]; + lodashStable.times(2, function(index) { + var curried = index ? _.curry(fn, 4) : _.curry(fn); + assert.strictEqual(curried.length, 0); + assert.strictEqual(curried(1).length, 0); + assert.strictEqual(curried(1, 2).length, 0); }); + }); - var actual = _.map(pairs, function(pair) { - return _.isEqual(pair[0], pair[1]); - }) + QUnit.test('should ensure `new curried` is an instance of `func`', function(assert) { + assert.expect(2); + + function Foo(value) { + return value && object; + } + + var curried = _.curry(Foo), + object = {}; - deepEqual(actual, expected); + assert.ok(new curried(false) instanceof Foo); + assert.strictEqual(new curried(true), object); }); - test('should return `false` for objects with custom `toString` methods', 1, function() { - var primitive, - object = { 'toString': function() { return primitive; } }, - values = [true, null, 1, 'a', undefined], - expected = _.map(values, function() { return false; }); + QUnit.test('should use `this` binding of function', function(assert) { + assert.expect(9); - var actual = _.map(values, function(value) { - primitive = value; - return _.isEqual(object, value); - }); + var fn = function(a, b, c) { + var value = this || {}; + return [value[a], value[b], value[c]]; + }; - ok(actual, expected); - }); + var object = { 'a': 1, 'b': 2, 'c': 3 }, + expected = [1, 2, 3]; - test('should perform comparisons between arrays', 6, function() { - var array1 = [true, null, 1, 'a', undefined], - array2 = [true, null, 1, 'a', undefined]; + assert.deepEqual(_.curry(_.bind(fn, object), 3)('a')('b')('c'), expected); + assert.deepEqual(_.curry(_.bind(fn, object), 3)('a', 'b')('c'), expected); + assert.deepEqual(_.curry(_.bind(fn, object), 3)('a', 'b', 'c'), expected); - strictEqual(_.isEqual(array1, array2), true); + assert.deepEqual(_.bind(_.curry(fn), object)('a')('b')('c'), Array(3)); + assert.deepEqual(_.bind(_.curry(fn), object)('a', 'b')('c'), Array(3)); + assert.deepEqual(_.bind(_.curry(fn), object)('a', 'b', 'c'), expected); - array1 = [[1, 2, 3], new Date(2012, 4, 23), /x/, { 'e': 1 }]; - array2 = [[1, 2, 3], new Date(2012, 4, 23), /x/, { 'e': 1 }]; + object.curried = _.curry(fn); + assert.deepEqual(object.curried('a')('b')('c'), Array(3)); + assert.deepEqual(object.curried('a', 'b')('c'), Array(3)); + assert.deepEqual(object.curried('a', 'b', 'c'), expected); + }); - strictEqual(_.isEqual(array1, array2), true); + QUnit.test('should work with partialed methods', function(assert) { + assert.expect(2); - array1 = [1]; - array1[2] = 3; + var curried = _.curry(fn), + expected = [1, 2, 3, 4]; - array2 = [1]; - array2[1] = undefined; - array2[2] = 3; + var a = _.partial(curried, 1), + b = _.bind(a, null, 2), + c = _.partialRight(b, 4), + d = _.partialRight(b(3), 4); - strictEqual(_.isEqual(array1, array2), true); + assert.deepEqual(c(3), expected); + assert.deepEqual(d(), expected); + }); + }()); - array1 = [new Number(1), false, new String('a'), /x/, new Date(2012, 4, 23), ['a', 'b', [new String('c')]], { 'a': 1 }]; - array2 = [1, new Boolean(false), 'a', /x/, new Date(2012, 4, 23), ['a', new String('b'), ['c']], { 'a': 1 }]; + /*--------------------------------------------------------------------------*/ - strictEqual(_.isEqual(array1, array2), true); + QUnit.module('lodash.curryRight'); - array1 = [1, 2, 3]; - array2 = [3, 2, 1]; + (function() { + function fn(a, b, c, d) { + return slice.call(arguments); + } - strictEqual(_.isEqual(array1, array2), false); + QUnit.test('should curry based on the number of arguments given', function(assert) { + assert.expect(3); - array1 = [1, 2]; - array2 = [1, 2, 3]; + var curried = _.curryRight(fn), + expected = [1, 2, 3, 4]; - strictEqual(_.isEqual(array1, array2), false); + assert.deepEqual(curried(4)(3)(2)(1), expected); + assert.deepEqual(curried(3, 4)(1, 2), expected); + assert.deepEqual(curried(1, 2, 3, 4), expected); }); - test('should treat arrays with identical values but different non-numeric properties as equal', 3, function() { - var array1 = [1, 2, 3], - array2 = [1, 2, 3]; - - array1.every = array1.filter = array1.forEach = array1.indexOf = array1.lastIndexOf = array1.map = array1.some = array1.reduce = array1.reduceRight = null; - array2.concat = array2.join = array2.pop = array2.reverse = array2.shift = array2.slice = array2.sort = array2.splice = array2.unshift = null; + QUnit.test('should allow specifying `arity`', function(assert) { + assert.expect(3); - strictEqual(_.isEqual(array1, array2), true); + var curried = _.curryRight(fn, 3), + expected = [1, 2, 3]; - array1 = [1, 2, 3]; - array1.a = 1; + assert.deepEqual(curried(3)(1, 2), expected); + assert.deepEqual(curried(2, 3)(1), expected); + assert.deepEqual(curried(1, 2, 3), expected); + }); - array2 = [1, 2, 3]; - array2.b = 1; + QUnit.test('should coerce `arity` to an integer', function(assert) { + assert.expect(2); - strictEqual(_.isEqual(array1, array2), true); + var values = ['0', 0.6, 'xyz'], + expected = lodashStable.map(values, stubArray); - array1 = /x/.exec('vwxyz'); - array2 = ['x']; + var actual = lodashStable.map(values, function(arity) { + return _.curryRight(fn, arity)(); + }); - strictEqual(_.isEqual(array1, array2), true); + assert.deepEqual(actual, expected); + assert.deepEqual(_.curryRight(fn, '2')(1)(2), [2, 1]); }); - test('should perform comparisons between date objects', 4, function() { - strictEqual(_.isEqual(new Date(2012, 4, 23), new Date(2012, 4, 23)), true); - strictEqual(_.isEqual(new Date(2012, 4, 23), new Date(2013, 3, 25)), false); - strictEqual(_.isEqual(new Date(2012, 4, 23), { 'getTime': function() { return 1337756400000; } }), false); - strictEqual(_.isEqual(new Date('a'), new Date('a')), false); + QUnit.test('should support placeholders', function(assert) { + assert.expect(4); + + var curried = _.curryRight(fn), + expected = [1, 2, 3, 4], + ph = curried.placeholder; + + assert.deepEqual(curried(4)(2, ph)(1, ph)(3), expected); + assert.deepEqual(curried(3, ph)(4)(1, ph)(2), expected); + assert.deepEqual(curried(ph, ph, 4)(ph, 3)(ph, 2)(1), expected); + assert.deepEqual(curried(ph, ph, ph, 4)(ph, ph, 3)(ph, 2)(1), expected); }); - test('should perform comparisons between functions', 2, function() { - function a() { return 1 + 2; } - function b() { return 1 + 2; } + QUnit.test('should persist placeholders', function(assert) { + assert.expect(1); - strictEqual(_.isEqual(a, a), true); - strictEqual(_.isEqual(a, b), false); + var curried = _.curryRight(fn), + ph = curried.placeholder, + actual = curried('a', ph, ph, ph)('b')(ph)('c')('d'); + + assert.deepEqual(actual, ['a', 'b', 'c', 'd']); }); - test('should perform comparisons between plain objects', 5, function() { - var object1 = { 'a': true, 'b': null, 'c': 1, 'd': 'a', 'e': undefined }, - object2 = { 'a': true, 'b': null, 'c': 1, 'd': 'a', 'e': undefined }; + QUnit.test('should use `_.placeholder` when set', function(assert) { + assert.expect(1); - strictEqual(_.isEqual(object1, object2), true); + if (!isModularize) { + var curried = _.curryRight(fn), + _ph = _.placeholder = {}, + ph = curried.placeholder; - object1 = { 'a': [1, 2, 3], 'b': new Date(2012, 4, 23), 'c': /x/, 'd': { 'e': 1 } }; - object2 = { 'a': [1, 2, 3], 'b': new Date(2012, 4, 23), 'c': /x/, 'd': { 'e': 1 } }; + assert.deepEqual(curried(4)(2, _ph)(1, ph), [1, 2, ph, 4]); + delete _.placeholder; + } + else { + skipAssert(assert); + } + }); - strictEqual(_.isEqual(object1, object2), true); + QUnit.test('should provide additional arguments after reaching the target arity', function(assert) { + assert.expect(3); - object1 = { 'a': 1, 'b': 2, 'c': 3 }; - object2 = { 'a': 3, 'b': 2, 'c': 1 }; + var curried = _.curryRight(fn, 3); + assert.deepEqual(curried(4)(1, 2, 3), [1, 2, 3, 4]); + assert.deepEqual(curried(4, 5)(1, 2, 3), [1, 2, 3, 4, 5]); + assert.deepEqual(curried(1, 2, 3, 4, 5, 6), [1, 2, 3, 4, 5, 6]); + }); - strictEqual(_.isEqual(object1, object2), false); + QUnit.test('should create a function with a `length` of `0`', function(assert) { + assert.expect(6); - object1 = { 'a': 1, 'b': 2, 'c': 3 }; - object2 = { 'd': 1, 'e': 2, 'f': 3 }; + lodashStable.times(2, function(index) { + var curried = index ? _.curryRight(fn, 4) : _.curryRight(fn); + assert.strictEqual(curried.length, 0); + assert.strictEqual(curried(4).length, 0); + assert.strictEqual(curried(3, 4).length, 0); + }); + }); - strictEqual(_.isEqual(object1, object2), false); + QUnit.test('should ensure `new curried` is an instance of `func`', function(assert) { + assert.expect(2); - object1 = { 'a': 1, 'b': 2 }; - object2 = { 'a': 1, 'b': 2, 'c': 3 }; + function Foo(value) { + return value && object; + } + + var curried = _.curryRight(Foo), + object = {}; - strictEqual(_.isEqual(object1, object2), false); + assert.ok(new curried(false) instanceof Foo); + assert.strictEqual(new curried(true), object); }); - test('should perform comparisons of nested objects', 1, function() { - var object1 = { - 'a': [1, 2, 3], - 'b': true, - 'c': new Number(1), - 'd': 'a', - 'e': { - 'f': ['a', new String('b'), 'c'], - 'g': new Boolean(false), - 'h': new Date(2012, 4, 23), - 'i': noop, - 'j': 'a' - } - }; + QUnit.test('should use `this` binding of function', function(assert) { + assert.expect(9); - var object2 = { - 'a': [1, new Number(2), 3], - 'b': new Boolean(true), - 'c': 1, - 'd': new String('a'), - 'e': { - 'f': ['a', 'b', 'c'], - 'g': false, - 'h': new Date(2012, 4, 23), - 'i': noop, - 'j': 'a' - } + var fn = function(a, b, c) { + var value = this || {}; + return [value[a], value[b], value[c]]; }; - strictEqual(_.isEqual(object1, object2), true); - }); + var object = { 'a': 1, 'b': 2, 'c': 3 }, + expected = [1, 2, 3]; - test('should perform comparisons between object instances', 4, function() { - function Foo() { - this.value = 1; - } - Foo.prototype.value = 1; + assert.deepEqual(_.curryRight(_.bind(fn, object), 3)('c')('b')('a'), expected); + assert.deepEqual(_.curryRight(_.bind(fn, object), 3)('b', 'c')('a'), expected); + assert.deepEqual(_.curryRight(_.bind(fn, object), 3)('a', 'b', 'c'), expected); - function Bar() { - this.value = 1; - } - Bar.prototype.value = 2; + assert.deepEqual(_.bind(_.curryRight(fn), object)('c')('b')('a'), Array(3)); + assert.deepEqual(_.bind(_.curryRight(fn), object)('b', 'c')('a'), Array(3)); + assert.deepEqual(_.bind(_.curryRight(fn), object)('a', 'b', 'c'), expected); - strictEqual(_.isEqual(new Foo, new Foo), true); - strictEqual(_.isEqual(new Foo, new Bar), false); - strictEqual(_.isEqual({ 'value': 1 }, new Foo), false); - strictEqual(_.isEqual({ 'value': 2 }, new Bar), false); + object.curried = _.curryRight(fn); + assert.deepEqual(object.curried('c')('b')('a'), Array(3)); + assert.deepEqual(object.curried('b', 'c')('a'), Array(3)); + assert.deepEqual(object.curried('a', 'b', 'c'), expected); }); - test('should perform comparisons between regexes', 4, function() { - strictEqual(_.isEqual(/x/gim, /x/gim), true); - strictEqual(_.isEqual(/x/gi, /x/g), false); - strictEqual(_.isEqual(/x/, /y/), false); - strictEqual(_.isEqual(/x/g, { 'global': true, 'ignoreCase': false, 'multiline': false, 'source': 'x' }), false); - }); + QUnit.test('should work with partialed methods', function(assert) { + assert.expect(2); - test('should avoid common type coercions', 9, function() { - strictEqual(_.isEqual(true, new Boolean(false)), false); - strictEqual(_.isEqual(new Boolean(false), new Number(0)), false); - strictEqual(_.isEqual(false, new String('')), false); - strictEqual(_.isEqual(new Number(36), new String(36)), false); - strictEqual(_.isEqual(0, ''), false); - strictEqual(_.isEqual(1, true), false); - strictEqual(_.isEqual(1337756400000, new Date(2012, 4, 23)), false); - strictEqual(_.isEqual('36', 36), false); - strictEqual(_.isEqual(36, '36'), false); - }); + var curried = _.curryRight(fn), + expected = [1, 2, 3, 4]; + + var a = _.partialRight(curried, 4), + b = _.partialRight(a, 3), + c = _.bind(b, null, 1), + d = _.partial(b(2), 1); - test('should work with sparse arrays', 2, function() { - strictEqual(_.isEqual(Array(3), Array(3)), true); - strictEqual(_.isEqual(Array(3), Array(6)), false); + assert.deepEqual(c(2), expected); + assert.deepEqual(d(), expected); }); + }()); - test('should work with `arguments` objects (test in IE < 9)', 2, function() { - var args1 = (function() { return arguments; }(1, 2, 3)), - args2 = (function() { return arguments; }(1, 2, 3)), - args3 = (function() { return arguments; }(1, 2)); + /*--------------------------------------------------------------------------*/ - if (!isPhantomPage) { - strictEqual(_.isEqual(args1, args2), true); - strictEqual(_.isEqual(args1, args3), false); - } else { - skipTest(2); + QUnit.module('curry methods'); + + lodashStable.each(['curry', 'curryRight'], function(methodName) { + var func = _[methodName], + fn = function(a, b) { return slice.call(arguments); }, + isCurry = methodName == 'curry'; + + QUnit.test('`_.' + methodName + '` should not error on functions with the same name as lodash methods', function(assert) { + assert.expect(1); + + function run(a, b) { + return a + b; } - }); - test('fixes the JScript [[DontEnum]] bug (test in IE < 9)', 1, function() { - strictEqual(_.isEqual(shadowedObject, {}), false); + var curried = func(run); + + try { + var actual = curried(1)(2); + } catch (e) {} + + assert.strictEqual(actual, 3); }); - test('should perform comparisons between arrays with circular references', 4, function() { - var array1 = [], - array2 = []; + QUnit.test('`_.' + methodName + '` should work for function names that shadow those on `Object.prototype`', function(assert) { + assert.expect(1); - array1.push(array1); - array2.push(array2); + var curried = _.curry(function hasOwnProperty(a, b, c) { + return [a, b, c]; + }); - strictEqual(_.isEqual(array1, array2), true); + var expected = [1, 2, 3]; - array1.push('a'); - array2.push('a'); + assert.deepEqual(curried(1)(2)(3), expected); + }); - strictEqual(_.isEqual(array1, array2), true); + QUnit.test('`_.' + methodName + '` should work as an iteratee for methods like `_.map`', function(assert) { + assert.expect(2); - array1.push('b'); - array2.push('c'); + var array = [fn, fn, fn], + object = { 'a': fn, 'b': fn, 'c': fn }; - strictEqual(_.isEqual(array1, array2), false); + lodashStable.each([array, object], function(collection) { + var curries = lodashStable.map(collection, func), + expected = lodashStable.map(collection, lodashStable.constant(isCurry ? ['a', 'b'] : ['b', 'a'])); - array1 = ['a', 'b', 'c']; - array1[1] = array1; - array2 = ['a', ['a', 'b', 'c'], 'c']; + var actual = lodashStable.map(curries, function(curried) { + return curried('a')('b'); + }); - strictEqual(_.isEqual(array1, array2), false); + assert.deepEqual(actual, expected); + }); }); + }); - test('should perform comparisons between objects with circular references', 4, function() { - var object1 = {}, - object2 = {}; + /*--------------------------------------------------------------------------*/ - object1.a = object1; - object2.a = object2; + QUnit.module('lodash.debounce'); - strictEqual(_.isEqual(object1, object2), true); + (function() { + QUnit.test('should debounce a function', function(assert) { + assert.expect(6); - object1.b = 0; - object2.b = new Number(0); + var done = assert.async(); - strictEqual(_.isEqual(object1, object2), true); + var callCount = 0; - object1.c = new Number(1); - object2.c = new Number(2); + var debounced = _.debounce(function(value) { + ++callCount; + return value; + }, 32); - strictEqual(_.isEqual(object1, object2), false); + var results = [debounced('a'), debounced('b'), debounced('c')]; + assert.deepEqual(results, [undefined, undefined, undefined]); + assert.strictEqual(callCount, 0); - object1 = { 'a': 1, 'b': 2, 'c': 3 }; - object1.b = object1; - object2 = { 'a': 1, 'b': { 'a': 1, 'b': 2, 'c': 3 }, 'c': 3 }; + setTimeout(function() { + assert.strictEqual(callCount, 1); + + var results = [debounced('d'), debounced('e'), debounced('f')]; + assert.deepEqual(results, ['c', 'c', 'c']); + assert.strictEqual(callCount, 1); + }, 128); - strictEqual(_.isEqual(object1, object2), false); + setTimeout(function() { + assert.strictEqual(callCount, 2); + done(); + }, 256); }); - test('should perform comparisons between objects with multiple circular references', 3, function() { - var array1 = [{}], - array2 = [{}]; + QUnit.test('subsequent debounced calls return the last `func` result', function(assert) { + assert.expect(2); - (array1[0].a = array1).push(array1); - (array2[0].a = array2).push(array2); + var done = assert.async(); - strictEqual(_.isEqual(array1, array2), true); + var debounced = _.debounce(identity, 32); + debounced('a'); - array1[0].b = 0; - array2[0].b = new Number(0); + setTimeout(function() { + assert.notEqual(debounced('b'), 'b'); + }, 64); + + setTimeout(function() { + assert.notEqual(debounced('c'), 'c'); + done(); + }, 128); + }); + + QUnit.test('should not immediately call `func` when `wait` is `0`', function(assert) { + assert.expect(2); - strictEqual(_.isEqual(array1, array2), true); + var done = assert.async(); - array1[0].c = new Number(1); - array2[0].c = new Number(2); + var callCount = 0, + debounced = _.debounce(function() { ++callCount; }, 0); - strictEqual(_.isEqual(array1, array2), false); + debounced(); + debounced(); + assert.strictEqual(callCount, 0); + + setTimeout(function() { + assert.strictEqual(callCount, 1); + done(); + }, 5); }); - test('should perform comparisons between objects with complex circular references', 1, function() { - var object1 = { - 'foo': { 'b': { 'foo': { 'c': { } } } }, - 'bar': { 'a': 2 } - }; + QUnit.test('should apply default options', function(assert) { + assert.expect(2); - var object2 = { - 'foo': { 'b': { 'foo': { 'c': { } } } }, - 'bar': { 'a': 2 } - }; + var done = assert.async(); - object1.foo.b.foo.c = object1; - object1.bar.b = object1.foo.b; + var callCount = 0, + debounced = _.debounce(function() { callCount++; }, 32, {}); - object2.foo.b.foo.c = object2; - object2.bar.b = object2.foo.b; + debounced(); + assert.strictEqual(callCount, 0); - strictEqual(_.isEqual(object1, object2), true); + setTimeout(function() { + assert.strictEqual(callCount, 1); + done(); + }, 64); }); - test('should perform comparisons between objects with shared property values', function() { - var object1 = { - 'a': [1, 2] - }; + QUnit.test('should support a `leading` option', function(assert) { + assert.expect(4); - var object2 = { - 'a': [1, 2], - 'b': [1, 2] - }; + var done = assert.async(); - object1.b = object1.a; + var callCounts = [0, 0]; - strictEqual(_.isEqual(object1, object2), true); - }); + var withLeading = _.debounce(function() { + callCounts[0]++; + }, 32, { 'leading': true }); - test('should pass the correct `callback` arguments', 1, function() { - var args; + var withLeadingAndTrailing = _.debounce(function() { + callCounts[1]++; + }, 32, { 'leading': true }); - _.isEqual('a', 'b', function() { - args || (args = slice.call(arguments)); - }); + withLeading(); + assert.strictEqual(callCounts[0], 1); - deepEqual(args, ['a', 'b']); - }); + withLeadingAndTrailing(); + withLeadingAndTrailing(); + assert.strictEqual(callCounts[1], 1); - test('should correctly set the `this` binding', 1, function() { - var actual = _.isEqual('a', 'b', function(a, b) { - return this[a] == this[b]; - }, { 'a': 1, 'b': 1 }); + setTimeout(function() { + assert.deepEqual(callCounts, [1, 2]); - strictEqual(actual, true); - }); + withLeading(); + assert.strictEqual(callCounts[0], 2); - test('should handle comparisons if `callback` returns `undefined`', 1, function() { - var actual = _.isEqual('a', 'a', function() {}); - strictEqual(actual, true); + done(); + }, 64); }); - test('should return a boolean value even if `callback` does not', 2, function() { - var actual = _.isEqual('a', 'a', function() { return 'a'; }); - strictEqual(actual, true); + QUnit.test('subsequent leading debounced calls return the last `func` result', function(assert) { + assert.expect(2); - var expected = _.map(falsey, function() { return false; }); - actual = []; + var done = assert.async(); - _.forEach(falsey, function(value) { - actual.push(_.isEqual('a', 'b', function() { return value; })); - }); + var debounced = _.debounce(identity, 32, { 'leading': true, 'trailing': false }), + results = [debounced('a'), debounced('b')]; + + assert.deepEqual(results, ['a', 'a']); - deepEqual(actual, expected); + setTimeout(function() { + var results = [debounced('c'), debounced('d')]; + assert.deepEqual(results, ['c', 'c']); + done(); + }, 64); }); - test('should ensure `callback` is a function', 1, function() { - var array = [1, 2, 3], - eq = _.partial(_.isEqual, array), - actual = _.every([array, [1, 0, 3]], eq); + QUnit.test('should support a `trailing` option', function(assert) { + assert.expect(4); - strictEqual(actual, false); - }); + var done = assert.async(); - test('should treat objects created by `Object.create(null)` like any other plain object', 2, function() { - function Foo() { this.a = 1; } - Foo.prototype.constructor = null; + var withCount = 0, + withoutCount = 0; - var other = { 'a': 1 }; - strictEqual(_.isEqual(new Foo, other), false); + var withTrailing = _.debounce(function() { + withCount++; + }, 32, { 'trailing': true }); - if (create) { - var object = Object.create(null); - object.a = 1; - strictEqual(_.isEqual(object, other), true); - } - else { - skipTest(); - } + var withoutTrailing = _.debounce(function() { + withoutCount++; + }, 32, { 'trailing': false }); + + withTrailing(); + assert.strictEqual(withCount, 0); + + withoutTrailing(); + assert.strictEqual(withoutCount, 0); + + setTimeout(function() { + assert.strictEqual(withCount, 1); + assert.strictEqual(withoutCount, 0); + done(); + }, 64); }); - test('should return an unwrapped value when intuitively chaining', 1, function() { - if (!isNpm) { - strictEqual(_('a').isEqual('a'), true); - } - else { - skipTest(); - } - }); + QUnit.test('should support a `maxWait` option', function(assert) { + assert.expect(4); - test('should return a wrapped value when explicitly chaining', 1, function() { - if (!isNpm) { - ok(_('a').chain().isEqual('a') instanceof _); - } - else { - skipTest(); - } - }); + var done = assert.async(); - test('should perform comparisons between wrapped values', 4, function() { - if (!isNpm) { - var object1 = _({ 'a': 1, 'b': 2 }), - object2 = _({ 'a': 1, 'b': 2 }), - actual = object1.isEqual(object2); + var callCount = 0; - strictEqual(actual, true); - strictEqual(_.isEqual(_(actual), _(true)), true); + var debounced = _.debounce(function(value) { + ++callCount; + return value; + }, 32, { 'maxWait': 64 }); - object1 = _({ 'a': 1, 'b': 2 }); - object2 = _({ 'a': 1, 'b': 1 }); + debounced(); + debounced(); + assert.strictEqual(callCount, 0); - actual = object1.isEqual(object2); - strictEqual(actual, false); - strictEqual(_.isEqual(_(actual), _(false)), true); - } - else { - skipTest(4); - } + setTimeout(function() { + assert.strictEqual(callCount, 1); + debounced(); + debounced(); + assert.strictEqual(callCount, 1); + }, 128); + + setTimeout(function() { + assert.strictEqual(callCount, 2); + done(); + }, 256); }); - test('should perform comparisons between wrapped and non-wrapped values', 4, function() { - if (!isNpm) { - var object1 = _({ 'a': 1, 'b': 2 }), - object2 = { 'a': 1, 'b': 2 }; + QUnit.test('should support `maxWait` in a tight loop', function(assert) { + assert.expect(1); - strictEqual(object1.isEqual(object2), true); - strictEqual(_.isEqual(object1, object2), true); + var done = assert.async(); - object1 = _({ 'a': 1, 'b': 2 }); - object2 = { 'a': 1, 'b': 1 }; + var limit = (argv || isPhantom) ? 1000 : 320, + withCount = 0, + withoutCount = 0; - strictEqual(object1.isEqual(object2), false); - strictEqual(_.isEqual(object1, object2), false); - } - else { - skipTest(4); - } - }); + var withMaxWait = _.debounce(function() { + withCount++; + }, 64, { 'maxWait': 128 }); - test('should return `true` for like-objects from different documents', 1, function() { - // ensure `_._object` is assigned (unassigned in Opera 10.00) - if (_._object) { - var object = { 'a': 1, 'b': 2, 'c': 3 }; - strictEqual(_.isEqual(object, _._object), true); - } - else { - skipTest(); + var withoutMaxWait = _.debounce(function() { + withoutCount++; + }, 96); + + var start = +new Date; + while ((new Date - start) < limit) { + withMaxWait(); + withoutMaxWait(); } + var actual = [Boolean(withoutCount), Boolean(withCount)]; + setTimeout(function() { + assert.deepEqual(actual, [false, true]); + done(); + }, 1); }); - }()); - /*--------------------------------------------------------------------------*/ + QUnit.test('should queue a trailing call for subsequent debounced calls after `maxWait`', function(assert) { + assert.expect(1); - QUnit.module('lodash.isFinite'); + var done = assert.async(); - (function() { - test('should return `true` for finite values', 5, function() { - strictEqual(_.isFinite(0), true); - strictEqual(_.isFinite(1), true); - strictEqual(_.isFinite(3.14), true); - strictEqual(_.isFinite(-1), true); - strictEqual(_.isFinite(new Number(0)), true); - }); + var callCount = 0; - test('should return `false` for non-finite values', 3, function() { - strictEqual(_.isFinite(NaN), false); - strictEqual(_.isFinite(Infinity), false); - strictEqual(_.isFinite(-Infinity), false); - }); + var debounced = _.debounce(function() { + ++callCount; + }, 200, { 'maxWait': 200 }); + + debounced(); - test('should return `false` for non-numeric values', 8, function() { - strictEqual(_.isFinite(null), false); - strictEqual(_.isFinite(undefined), false); - strictEqual(_.isFinite([]), false); - strictEqual(_.isFinite(true), false); - strictEqual(_.isFinite(new Date), false); - strictEqual(_.isFinite(''), false); - strictEqual(_.isFinite(' '), false); - strictEqual(_.isFinite('2px'), false); + setTimeout(debounced, 190); + setTimeout(debounced, 200); + setTimeout(debounced, 210); + + setTimeout(function() { + assert.strictEqual(callCount, 2); + done(); + }, 500); }); - test('should return `true` for numeric string values', 3, function() { - strictEqual(_.isFinite('2'), true); - strictEqual(_.isFinite('0'), true); - strictEqual(_.isFinite('08'), true); + QUnit.test('should cancel `maxDelayed` when `delayed` is invoked', function(assert) { + assert.expect(2); + + var done = assert.async(); + + var callCount = 0; + + var debounced = _.debounce(function() { + callCount++; + }, 32, { 'maxWait': 64 }); + + debounced(); + + setTimeout(function() { + debounced(); + assert.strictEqual(callCount, 1); + }, 128); + + setTimeout(function() { + assert.strictEqual(callCount, 2); + done(); + }, 192); }); - test('should work with numbers from another realm', 1, function() { - if (_._object) { - strictEqual(_.isFinite(_._number), true); - } - else { - skipTest(); + QUnit.test('should invoke the trailing call with the correct arguments and `this` binding', function(assert) { + assert.expect(2); + + var done = assert.async(); + + var actual, + callCount = 0, + object = {}; + + var debounced = _.debounce(function(value) { + actual = [this]; + push.apply(actual, arguments); + return ++callCount != 2; + }, 32, { 'leading': true, 'maxWait': 64 }); + + while (true) { + if (!debounced.call(object, 'a')) { + break; + } } + setTimeout(function() { + assert.strictEqual(callCount, 2); + assert.deepEqual(actual, [object, 'a']); + done(); + }, 64); }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.isFunction'); + QUnit.module('lodash.deburr'); (function() { - var args = arguments; + QUnit.test('should convert Latin Unicode letters to basic Latin', function(assert) { + assert.expect(1); - test('should return `true` for functions', 1, function() { - strictEqual(_.isFunction(_), true); + var actual = lodashStable.map(burredLetters, _.deburr); + assert.deepEqual(actual, deburredLetters); }); - test('should return `false` for non functions', 9, function() { - var expected = _.map(falsey, function() { return false; }); - - var actual = _.map(falsey, function(value, index) { - return index ? _.isFunction(value) : _.isFunction(); - }); + QUnit.test('should not deburr Latin mathematical operators', function(assert) { + assert.expect(1); - strictEqual(_.isFunction(args), false); - strictEqual(_.isFunction([1, 2, 3]), false); - strictEqual(_.isFunction(true), false); - strictEqual(_.isFunction(new Date), false); - strictEqual(_.isFunction({ 'a': 1 }), false); - strictEqual(_.isFunction(0), false); - strictEqual(_.isFunction(/x/), false); - strictEqual(_.isFunction('a'), false); + var operators = ['\xd7', '\xf7'], + actual = lodashStable.map(operators, _.deburr); - deepEqual(actual, expected); + assert.deepEqual(actual, operators); }); - test('should work with functions from another realm', 1, function() { - if (_._object) { - strictEqual(_.isFunction(_._function), true); - } - else { - skipTest(); - } + QUnit.test('should deburr combining diacritical marks', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(comboMarks, lodashStable.constant('ei')); + + var actual = lodashStable.map(comboMarks, function(chr) { + return _.deburr('e' + chr + 'i'); + }); + + assert.deepEqual(actual, expected); }); - }(1, 2, 3)); + }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.isNaN'); + QUnit.module('lodash.defaults'); (function() { - var args = arguments; + QUnit.test('should assign source properties if missing on `object`', function(assert) { + assert.expect(1); - test('should return `true` for NaNs', 2, function() { - strictEqual(_.isNaN(NaN), true); - strictEqual(_.isNaN(new Number(NaN)), true); + var actual = _.defaults({ 'a': 1 }, { 'a': 2, 'b': 2 }); + assert.deepEqual(actual, { 'a': 1, 'b': 2 }); }); - test('should return `false` for non NaNs', 10, function() { - var expected = _.map(falsey, function(value) { return value !== value; }); + QUnit.test('should accept multiple sources', function(assert) { + assert.expect(2); - var actual = _.map(falsey, function(value, index) { - return index ? _.isNaN(value) : _.isNaN(); - }); + var expected = { 'a': 1, 'b': 2, 'c': 3 }, + actual = _.defaults({ 'a': 1, 'b': 2 }, { 'b': 3 }, { 'c': 3 }); - strictEqual(_.isNaN(args), false); - strictEqual(_.isNaN([1, 2, 3]), false); - strictEqual(_.isNaN(true), false); - strictEqual(_.isNaN(new Date), false); - strictEqual(_.isNaN(_), false); - strictEqual(_.isNaN({ 'a': 1 }), false); - strictEqual(_.isNaN(0), false); - strictEqual(_.isNaN(/x/), false); - strictEqual(_.isNaN('a'), false); + assert.deepEqual(actual, expected); - deepEqual(actual, expected); + actual = _.defaults({ 'a': 1, 'b': 2 }, { 'b': 3, 'c': 3 }, { 'c': 2 }); + assert.deepEqual(actual, expected); }); - test('should work with NaNs from another realm', 1, function() { - if (_._object) { - strictEqual(_.isNaN(_._nan), true); - } - else { - skipTest(); - } + QUnit.test('should not overwrite `null` values', function(assert) { + assert.expect(1); + + var actual = _.defaults({ 'a': null }, { 'a': 1 }); + assert.strictEqual(actual.a, null); }); - }(1, 2, 3)); - /*--------------------------------------------------------------------------*/ + QUnit.test('should overwrite `undefined` values', function(assert) { + assert.expect(1); - QUnit.module('lodash.isNull'); + var actual = _.defaults({ 'a': undefined }, { 'a': 1 }); + assert.strictEqual(actual.a, 1); + }); - (function() { - var args = arguments; + QUnit.test('should assign `undefined` values', function(assert) { + assert.expect(1); - test('should return `true` for nulls', 1, function() { - strictEqual(_.isNull(null), true); + var source = { 'a': undefined, 'b': 1 }, + actual = _.defaults({}, source); + + assert.deepEqual(actual, { 'a': undefined, 'b': 1 }); }); - test('should return `false` for non nulls', 10, function() { - var expected = _.map(falsey, function(value) { return value === null; }); + QUnit.test('should assign properties that shadow those on `Object.prototype`', function(assert) { + assert.expect(2); - var actual = _.map(falsey, function(value, index) { - return index ? _.isNull(value) : _.isNull(); - }); + var object = { + 'constructor': objectProto.constructor, + 'hasOwnProperty': objectProto.hasOwnProperty, + 'isPrototypeOf': objectProto.isPrototypeOf, + 'propertyIsEnumerable': objectProto.propertyIsEnumerable, + 'toLocaleString': objectProto.toLocaleString, + 'toString': objectProto.toString, + 'valueOf': objectProto.valueOf + }; - strictEqual(_.isNull(args), false); - strictEqual(_.isNull([1, 2, 3]), false); - strictEqual(_.isNull(true), false); - strictEqual(_.isNull(new Date), false); - strictEqual(_.isNull(_), false); - strictEqual(_.isNull({ 'a': 1 }), false); - strictEqual(_.isNull(0), false); - strictEqual(_.isNull(/x/), false); - strictEqual(_.isNull('a'), false); + var source = { + 'constructor': 1, + 'hasOwnProperty': 2, + 'isPrototypeOf': 3, + 'propertyIsEnumerable': 4, + 'toLocaleString': 5, + 'toString': 6, + 'valueOf': 7 + }; - deepEqual(actual, expected); - }); + var expected = lodashStable.clone(source); + assert.deepEqual(_.defaults({}, source), expected); - test('should work with nulls from another realm', 1, function() { - if (_._object) { - strictEqual(_.isNull(_._null), true); - } - else { - skipTest(); - } + expected = lodashStable.clone(object); + assert.deepEqual(_.defaults({}, object, source), expected); }); - }(1, 2, 3)); + }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.isNumber'); + QUnit.module('lodash.defaultsDeep'); (function() { - var args = arguments; - - test('should return `true` for numbers', 2, function() { - strictEqual(_.isNumber(0), true); - strictEqual(_.isNumber(new Number(0)), true); - }); + QUnit.test('should deep assign source properties if missing on `object`', function(assert) { + assert.expect(1); - test('should return `false` for non numbers', 9, function() { - var expected = _.map(falsey, function(value) { return typeof value == 'number'; }); + var object = { 'a': { 'b': 2 }, 'd': 4 }, + source = { 'a': { 'b': 3, 'c': 3 }, 'e': 5 }, + expected = { 'a': { 'b': 2, 'c': 3 }, 'd': 4, 'e': 5 }; - var actual = _.map(falsey, function(value, index) { - return index ? _.isNumber(value) : _.isNumber(); - }); + assert.deepEqual(_.defaultsDeep(object, source), expected); + }); - strictEqual(_.isNumber(args), false); - strictEqual(_.isNumber([1, 2, 3]), false); - strictEqual(_.isNumber(true), false); - strictEqual(_.isNumber(new Date), false); - strictEqual(_.isNumber(_), false); - strictEqual(_.isNumber({ 'a': 1 }), false); - strictEqual(_.isNumber(/x/), false); - strictEqual(_.isNumber('a'), false); + QUnit.test('should accept multiple sources', function(assert) { + assert.expect(2); - deepEqual(actual, expected); - }); + var source1 = { 'a': { 'b': 3 } }, + source2 = { 'a': { 'c': 3 } }, + source3 = { 'a': { 'b': 3, 'c': 3 } }, + source4 = { 'a': { 'c': 4 } }, + expected = { 'a': { 'b': 2, 'c': 3 } }; - test('should work with numbers from another realm', 1, function() { - if (_._object) { - strictEqual(_.isNumber(_._number), true); - } - else { - skipTest(); - } + assert.deepEqual(_.defaultsDeep({ 'a': { 'b': 2 } }, source1, source2), expected); + assert.deepEqual(_.defaultsDeep({ 'a': { 'b': 2 } }, source3, source4), expected); }); - test('should avoid `[xpconnect wrapped native prototype]` in Firefox', 1, function() { - strictEqual(_.isNumber(+"2"), true); - }); - }(1, 2, 3)); + QUnit.test('should not overwrite `null` values', function(assert) { + assert.expect(1); - /*--------------------------------------------------------------------------*/ + var object = { 'a': { 'b': null } }, + source = { 'a': { 'b': 2 } }, + actual = _.defaultsDeep(object, source); - QUnit.module('lodash.isObject'); + assert.strictEqual(actual.a.b, null); + }); - (function() { - var args = arguments; + QUnit.test('should not overwrite regexp values', function(assert) { + assert.expect(1); - test('should return `true` for objects', 10, function() { - strictEqual(_.isObject(args), true); - strictEqual(_.isObject([1, 2, 3]), true); - strictEqual(_.isObject(new Boolean(false)), true); - strictEqual(_.isObject(new Date), true); - strictEqual(_.isObject(_), true); - strictEqual(_.isObject({ 'a': 1 }), true); - strictEqual(_.isObject(new Number(0)), true); - strictEqual(_.isObject(/x/), true); - strictEqual(_.isObject(new String('a')), true); + var object = { 'a': { 'b': /x/ } }, + source = { 'a': { 'b': /y/ } }, + actual = _.defaultsDeep(object, source); - if (document) { - strictEqual(_.isObject(body), true); - } else { - skipTest(1); - } + assert.deepEqual(actual.a.b, /x/); }); - test('should return `false` for non objects', 1, function() { - var values = falsey.concat('a', true), - expected = _.map(values, function() { return false; }); + QUnit.test('should not convert function properties to objects', function(assert) { + assert.expect(2); - var actual = _.map(values, function(value, index) { - return index ? _.isObject(value) : _.isObject(); - }); + var actual = _.defaultsDeep({}, { 'a': noop }); + assert.strictEqual(actual.a, noop); - deepEqual(actual, expected); + actual = _.defaultsDeep({}, { 'a': { 'b': noop } }); + assert.strictEqual(actual.a.b, noop); }); - test('should work with objects from another realm', 8, function() { - if (_._element) { - strictEqual(_.isObject(_._element), true); - } - else { - skipTest(); - } - if (_._object) { - strictEqual(_.isObject(_._object), true); - strictEqual(_.isObject(_._boolean), true); - strictEqual(_.isObject(_._date), true); - strictEqual(_.isObject(_._function), true); - strictEqual(_.isObject(_._number), true); - strictEqual(_.isObject(_._regexp), true); - strictEqual(_.isObject(_._string), true); - } - else { - skipTest(7); - } + QUnit.test('should overwrite `undefined` values', function(assert) { + assert.expect(1); + + var object = { 'a': { 'b': undefined } }, + source = { 'a': { 'b': 2 } }, + actual = _.defaultsDeep(object, source); + + assert.strictEqual(actual.a.b, 2); }); - test('should avoid V8 bug #2291', 1, function() { - // trigger V8 bug - // http://code.google.com/p/v8/issues/detail?id=2291 - var obj = {}, - str = 'foo'; + QUnit.test('should assign `undefined` values', function(assert) { + assert.expect(1); - // 1: Useless comparison statement, this is half the trigger - obj == obj; - // 2: Initial check with object, this is the other half of the trigger - _.isObject(obj); + var source = { 'a': undefined, 'b': { 'c': undefined, 'd': 1 } }, + expected = lodashStable.cloneDeep(source), + actual = _.defaultsDeep({}, source); - equal(_.isObject(str), false); + assert.deepEqual(actual, expected); }); - }(1, 2, 3)); - /*--------------------------------------------------------------------------*/ + QUnit.test('should merge sources containing circular references', function(assert) { + assert.expect(2); - QUnit.module('lodash.isPlainObject'); + var object = { + 'foo': { 'b': { 'c': { 'd': {} } } }, + 'bar': { 'a': 2 } + }; - (function() { - var element = document && document.createElement('div'); + var source = { + 'foo': { 'b': { 'c': { 'd': {} } } }, + 'bar': {} + }; - test('should detect plain objects', 5, function() { - function Foo(a) { - this.a = 1; - } + object.foo.b.c.d = object; + source.foo.b.c.d = source; + source.bar.b = source.foo.b; - strictEqual(_.isPlainObject(new Foo(1)), false); - strictEqual(_.isPlainObject([1, 2, 3]), false); - strictEqual(_.isPlainObject({ 'a': 1 }), true); + var actual = _.defaultsDeep(object, source); - if (create) { - strictEqual(_.isPlainObject(create(null)), true); - } else { - skipTest(); - } - if (element) { - strictEqual(_.isPlainObject(element), false); - } else { - skipTest(); - } + assert.strictEqual(actual.bar.b, actual.foo.b); + assert.strictEqual(actual.foo.b.c.d, actual.foo.b.c.d.foo.b.c.d); }); - test('should return `true` for plain objects with a custom `valueOf` property', 2, function() { - strictEqual(_.isPlainObject({ 'valueOf': 0 }), true); + QUnit.test('should not modify sources', function(assert) { + assert.expect(3); - if (element) { - var valueOf = element.valueOf; - element.valueOf = 0; - strictEqual(_.isPlainObject(element), false); - element.valueOf = valueOf; - } - else { - skipTest(); - } - }); + var source1 = { 'a': 1, 'b': { 'c': 2 } }, + source2 = { 'b': { 'c': 3, 'd': 3 } }, + actual = _.defaultsDeep({}, source1, source2); - test('should return `true` for empty objects', 1, function() { - strictEqual(_.isPlainObject({}), true); + assert.deepEqual(actual, { 'a': 1, 'b': { 'c': 2, 'd': 3 } }); + assert.deepEqual(source1, { 'a': 1, 'b': { 'c': 2 } }); + assert.deepEqual(source2, { 'b': { 'c': 3, 'd': 3 } }); }); - test('should return `false` for Object objects without a [[Class]] of "Object"', 4, function() { - strictEqual(_.isPlainObject(arguments), false); - strictEqual(_.isPlainObject(Error), false); - strictEqual(_.isPlainObject(Math), false); - strictEqual(_.isPlainObject(root), false); + QUnit.test('should not attempt a merge of a string into an array', function(assert) { + assert.expect(1); + + var actual = _.defaultsDeep({ 'a': ['abc'] }, { 'a': 'abc' }); + assert.deepEqual(actual.a, ['abc']); }); - test('should return `false` for non objects', 3, function() { - var expected = _.map(falsey, function() { return false; }); + QUnit.test('should not indirectly merge `Object` properties', function(assert) { + assert.expect(1); - var actual = _.map(falsey, function(value, index) { - return index ? _.isPlainObject(value) : _.isPlainObject(); - }); + _.defaultsDeep({}, { 'constructor': { 'a': 1 } }); - strictEqual(_.isPlainObject(true), false); - strictEqual(_.isPlainObject('a'), false); - deepEqual(actual, expected); - }); + var actual = 'a' in Object; + delete Object.a; - test('should work with objects from another realm', 1, function() { - if (_._object) { - strictEqual(_.isPlainObject(_._object), true); - } - else { - skipTest(); - } + assert.notOk(actual); }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.isRegExp'); + QUnit.module('lodash.defaultTo'); (function() { - var args = arguments; - - test('should return `true` for regexes', 2, function() { - strictEqual(_.isRegExp(/x/), true); - strictEqual(_.isRegExp(RegExp('x')), true); - }); - - test('should return `false` for non regexes', 9, function() { - var expected = _.map(falsey, function(value) { return false; }); + QUnit.test('should return a default value if `value` is `NaN` or nullish', function(assert) { + assert.expect(1); - var actual = _.map(falsey, function(value, index) { - return index ? _.isRegExp(value) : _.isRegExp(); + var expected = lodashStable.map(falsey, function(value) { + return (value == null || value !== value) ? 1 : value; }); - strictEqual(_.isRegExp(args), false); - strictEqual(_.isRegExp([1, 2, 3]), false); - strictEqual(_.isRegExp(true), false); - strictEqual(_.isRegExp(new Date), false); - strictEqual(_.isRegExp(_), false); - strictEqual(_.isRegExp({ 'a': 1 }), false); - strictEqual(_.isRegExp(0), false); - strictEqual(_.isRegExp('a'), false); - - deepEqual(actual, expected); - }); + var actual = lodashStable.map(falsey, function(value) { + return _.defaultTo(value, 1); + }); - test('should work with regexes from another realm', 1, function() { - if (_._object) { - strictEqual(_.isRegExp(_._regexp), true); - } - else { - skipTest(); - } + assert.deepEqual(actual, expected); }); - }(1, 2, 3)); + }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.isString'); + QUnit.module('lodash.defer'); (function() { - var args = arguments; + QUnit.test('should defer `func` execution', function(assert) { + assert.expect(1); - test('should return `true` for strings', 2, function() { - strictEqual(_.isString('a'), true); - strictEqual(_.isString(new String('a')), true); + var done = assert.async(); + + var pass = false; + _.defer(function() { pass = true; }); + + setTimeout(function() { + assert.ok(pass); + done(); + }, 32); }); - test('should return `false` for non strings', 9, function() { - var expected = _.map(falsey, function(value) { return value === ''; }); + QUnit.test('should provide additional arguments to `func`', function(assert) { + assert.expect(1); - var actual = _.map(falsey, function(value, index) { - return index ? _.isString(value) : _.isString(); - }); + var done = assert.async(); - strictEqual(_.isString(args), false); - strictEqual(_.isString([1, 2, 3]), false); - strictEqual(_.isString(true), false); - strictEqual(_.isString(new Date), false); - strictEqual(_.isString(_), false); - strictEqual(_.isString({ '0': 1, 'length': 1 }), false); - strictEqual(_.isString(0), false); - strictEqual(_.isString(/x/), false); + var args; + + _.defer(function() { + args = slice.call(arguments); + }, 1, 2); - deepEqual(actual, expected); + setTimeout(function() { + assert.deepEqual(args, [1, 2]); + done(); + }, 32); }); - test('should work with strings from another realm', 1, function() { - if (_._object) { - strictEqual(_.isString(_._string), true); - } - else { - skipTest(); - } + QUnit.test('should be cancelable', function(assert) { + assert.expect(1); + + var done = assert.async(); + + var pass = true, + timerId = _.defer(function() { pass = false; }); + + clearTimeout(timerId); + + setTimeout(function() { + assert.ok(pass); + done(); + }, 32); }); - }(1, 2, 3)); + }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.isUndefined'); + QUnit.module('lodash.delay'); (function() { - var args = arguments; + QUnit.test('should delay `func` execution', function(assert) { + assert.expect(2); + + var done = assert.async(); + + var pass = false; + _.delay(function() { pass = true; }, 32); + + setTimeout(function() { + assert.notOk(pass); + }, 1); - test('should return `true` for `undefined` values', 2, function() { - strictEqual(_.isUndefined(), true); - strictEqual(_.isUndefined(undefined), true); + setTimeout(function() { + assert.ok(pass); + done(); + }, 64); }); - test('should return `false` for non `undefined` values', 10, function() { - var expected = _.map(falsey, function(value) { return value === undefined; }); + QUnit.test('should provide additional arguments to `func`', function(assert) { + assert.expect(1); - var actual = _.map(falsey, function(value, index) { - return _.isUndefined(value); - }); + var done = assert.async(); + + var args; - strictEqual(_.isUndefined(args), false); - strictEqual(_.isUndefined([1, 2, 3]), false); - strictEqual(_.isUndefined(true), false); - strictEqual(_.isUndefined(new Date), false); - strictEqual(_.isUndefined(_), false); - strictEqual(_.isUndefined({ 'a': 1 }), false); - strictEqual(_.isUndefined(0), false); - strictEqual(_.isUndefined(/x/), false); - strictEqual(_.isUndefined('a'), false); + _.delay(function() { + args = slice.call(arguments); + }, 32, 1, 2); - deepEqual(actual, expected); + setTimeout(function() { + assert.deepEqual(args, [1, 2]); + done(); + }, 64); }); - test('should work with `undefined` from another realm', 1, function() { - if (_._object) { - strictEqual(_.isUndefined(_._undefined), true); - } - else { - skipTest(); - } + QUnit.test('should use a default `wait` of `0`', function(assert) { + assert.expect(2); + + var done = assert.async(); + + var pass = false; + _.delay(function() { pass = true; }); + + assert.notOk(pass); + + setTimeout(function() { + assert.ok(pass); + done(); + }, 0); }); - }(1, 2, 3)); - /*--------------------------------------------------------------------------*/ + QUnit.test('should be cancelable', function(assert) { + assert.expect(1); - QUnit.module('isType checks'); + var done = assert.async(); - (function() { - test('should return `false` for subclassed values', 7, function() { - var funcs = [ - 'isArray', 'isBoolean', 'isDate', 'isFunction', - 'isNumber', 'isRegExp', 'isString' - ]; + var pass = true, + timerId = _.delay(function() { pass = false; }, 32); - _.forEach(funcs, function(methodName) { - function Foo() {} - Foo.prototype = root[methodName.slice(2)].prototype; + clearTimeout(timerId); - var object = new Foo; - if (toString.call(object) == '[object Object]') { - strictEqual(_[methodName](object), false, '`_.' + methodName + '` returns `false`'); - } else { - skipTest(); - } - }); + setTimeout(function() { + assert.ok(pass); + done(); + }, 64); }); - test('should not error on host objects (test in IE)', 12, function() { - try { - var xml = new ActiveXObject('Microsoft.XMLDOM'); - } catch(e) { } + QUnit.test('should work with mocked `setTimeout`', function(assert) { + assert.expect(1); - if (xml) { - var funcs = [ - 'isArray', 'isArguments', 'isBoolean', 'isDate', 'isElement', 'isFunction', - 'isObject', 'isNull', 'isNumber', 'isRegExp', 'isString', 'isUndefined' - ]; + if (!isPhantom) { + var pass = false, + setTimeout = root.setTimeout; - _.forEach(funcs, function(methodName) { - var pass = true; - try { - _[methodName](xml); - } catch(e) { - pass = false; - } - ok(pass, '`_.' + methodName + '` should not error'); - }); + setProperty(root, 'setTimeout', function(func) { func(); }); + _.delay(function() { pass = true; }, 32); + setProperty(root, 'setTimeout', setTimeout); + + assert.ok(pass); } else { - skipTest(12) + skipAssert(assert); } }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.keys'); + QUnit.module('difference methods'); - (function() { - var args = arguments; - - test('should return the keys of an object', 1, function() { - var object = { 'a': 1, 'b': 1 }; - deepEqual(_.keys(object), ['a', 'b']); - }); + lodashStable.each(['difference', 'differenceBy', 'differenceWith'], function(methodName) { + var func = _[methodName]; - test('should work with sparse arrays', 1, function() { - var array = [1]; - array[2] = 3; - deepEqual(_.keys(array), ['0', '2']); - }); + QUnit.test('`_.' + methodName + '` should return the difference of two arrays', function(assert) { + assert.expect(1); - test('should work with `arguments` objects (test in IE < 9)', 1, function() { - if (!isPhantomPage) { - deepEqual(_.keys(args), ['0', '1', '2']); - } else { - skipTest(); - } + var actual = func([2, 1], [2, 3]); + assert.deepEqual(actual, [1]); }); - test('fixes the JScript [[DontEnum]] bug (test in IE < 9)', 2, function() { - function Foo() {} - Foo.prototype.a = 1; + QUnit.test('`_.' + methodName + '` should return the difference of multiple arrays', function(assert) { + assert.expect(1); - deepEqual(_.keys(Foo.prototype), ['a']); - deepEqual(_.keys(shadowedObject).sort(), shadowedProps); + var actual = func([2, 1, 2, 3], [3, 4], [3, 2]); + assert.deepEqual(actual, [1]); }); - test('skips the prototype property of functions (test in Firefox < 3.6, Opera > 9.50 - Opera < 11.60, and Safari < 5.1)', 2, function() { - function Foo() {} - Foo.prototype.c = 3; + QUnit.test('`_.' + methodName + '` should treat `-0` as `0`', function(assert) { + assert.expect(2); - Foo.a = 1; - Foo.b = 2; + var array = [-0, 0]; + + var actual = lodashStable.map(array, function(value) { + return func(array, [value]); + }); - var expected = ['a', 'b']; - deepEqual(_.keys(Foo), expected); + assert.deepEqual(actual, [[], []]); - Foo.prototype = { 'c': 3 }; - deepEqual(_.keys(Foo), expected); + actual = lodashStable.map(func([-0, 1], [1]), lodashStable.toString); + assert.deepEqual(actual, ['0']); }); - }(1, 2, 3)); - /*--------------------------------------------------------------------------*/ + QUnit.test('`_.' + methodName + '` should match `NaN`', function(assert) { + assert.expect(1); - QUnit.module('lodash.last'); + assert.deepEqual(func([1, NaN, 3], [NaN, 5, NaN]), [1, 3]); + }); - (function() { - var array = [1, 2, 3]; + QUnit.test('`_.' + methodName + '` should work with large arrays', function(assert) { + assert.expect(1); - var objects = [ - { 'a': 0, 'b': 0 }, - { 'a': 1, 'b': 1 }, - { 'a': 2, 'b': 2 } - ]; + var array1 = lodashStable.range(LARGE_ARRAY_SIZE + 1), + array2 = lodashStable.range(LARGE_ARRAY_SIZE), + a = {}, + b = {}, + c = {}; - test('should return the last element', 1, function() { - equal(_.last(array), 3); - }); + array1.push(a, b, c); + array2.push(b, c, a); - test('should return the last two elements', 1, function() { - deepEqual(_.last(array, 2), [2, 3]); + assert.deepEqual(func(array1, array2), [LARGE_ARRAY_SIZE]); }); - test('should return an empty array when `n` < `1`', 3, function() { - _.forEach([0, -1, -2], function(n) { - deepEqual(_.last(array, n), []); - }); - }); + QUnit.test('`_.' + methodName + '` should work with large arrays of `-0` as `0`', function(assert) { + assert.expect(2); - test('should return all elements when `n` >= `array.length`', 2, function() { - _.forEach([3, 4], function(n) { - deepEqual(_.last(array, n), array); - }); - }); + var array = [-0, 0]; - test('should return `undefined` when querying empty arrays', 1, function() { - strictEqual(_.last([]), undefined); - }); + var actual = lodashStable.map(array, function(value) { + var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, lodashStable.constant(value)); + return func(array, largeArray); + }); - test('should work when used as `callback` for `_.map`', 1, function() { - var array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]], - actual = _.map(array, _.last); + assert.deepEqual(actual, [[], []]); - deepEqual(actual, [3, 6, 9]); + var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, stubOne); + actual = lodashStable.map(func([-0, 1], largeArray), lodashStable.toString); + assert.deepEqual(actual, ['0']); }); - test('should work with a `callback`', 1, function() { - var actual = _.last(array, function(num) { - return num > 1; - }); + QUnit.test('`_.' + methodName + '` should work with large arrays of `NaN`', function(assert) { + assert.expect(1); - deepEqual(actual, [2, 3]); + var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, stubNaN); + assert.deepEqual(func([1, NaN, 3], largeArray), [1, 3]); }); - test('should pass the correct `callback` arguments', 1, function() { - var args; + QUnit.test('`_.' + methodName + '` should work with large arrays of objects', function(assert) { + assert.expect(1); - _.last(array, function() { - args || (args = slice.call(arguments)); - }); + var object1 = {}, + object2 = {}, + largeArray = lodashStable.times(LARGE_ARRAY_SIZE, lodashStable.constant(object1)); - deepEqual(args, [3, 2, array]); + assert.deepEqual(func([object1, object2], largeArray), [object2]); }); - test('should support the `thisArg` argument', 1, function() { - var actual = _.last(array, function(num, index) { - return this[index] > 1; - }, array); + QUnit.test('`_.' + methodName + '` should ignore values that are not array-like', function(assert) { + assert.expect(3); - deepEqual(actual, [2, 3]); - }); + var array = [1, null, 3]; - test('should chain when passing `n`, `callback`, or `thisArg`', 3, function() { - if (!isNpm) { - var actual = _(array).last(2); + assert.deepEqual(func(args, 3, { '0': 1 }), [1, 2, 3]); + assert.deepEqual(func(null, array, 1), []); + assert.deepEqual(func(array, args, null), [null]); + }); + }); - ok(actual instanceof _); + /*--------------------------------------------------------------------------*/ - actual = _(array).last(function(num) { - return num > 1; - }); + QUnit.module('lodash.differenceBy'); - ok(actual instanceof _); + (function() { + QUnit.test('should accept an `iteratee`', function(assert) { + assert.expect(2); - actual = _(array).last(function(num, index) { - return this[index] > 1; - }, array); + var actual = _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor); + assert.deepEqual(actual, [1.2]); - ok(actual instanceof _); - } - else { - skipTest(3); - } + actual = _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x'); + assert.deepEqual(actual, [{ 'x': 2 }]); }); - test('should not chain when arguments are not provided', 1, function() { - if (!isNpm) { - var actual = _(array).last(); - equal(actual, 3); - } - else { - skipTest(); - } - }); + QUnit.test('should provide correct `iteratee` arguments', function(assert) { + assert.expect(1); - test('should work with an object for `callback`', 1, function() { - deepEqual(_.last(objects, { 'b': 2 }), objects.slice(-1)); - }); + var args; + + _.differenceBy([2.1, 1.2], [2.3, 3.4], function() { + args || (args = slice.call(arguments)); + }); - test('should work with a string for `callback`', 1, function() { - deepEqual(_.last(objects, 'b'), objects.slice(-2)); + assert.deepEqual(args, [2.3]); }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.lastIndexOf'); + QUnit.module('lodash.differenceWith'); (function() { - var array = [1, 2, 3, 1, 2, 3]; - - test('should return the index of the last matched value', 1, function() { - equal(_.lastIndexOf(array, 3), 5); - }); + QUnit.test('should work with a `comparator`', function(assert) { + assert.expect(1); - test('should return `-1` for an unmatched value', 1, function() { - equal(_.lastIndexOf(array, 4), -1); - }); + var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }], + actual = _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], lodashStable.isEqual); - test('should work with a positive `fromIndex`', 1, function() { - strictEqual(_.lastIndexOf(array, 1, 2), 0); + assert.deepEqual(actual, [objects[1]]); }); - test('should work with `fromIndex` >= `array.length`', 4, function() { - equal(_.lastIndexOf(array, undefined, 6), -1); - equal(_.lastIndexOf(array, 1, 6), 3); - equal(_.lastIndexOf(array, undefined, 8), -1); - equal(_.lastIndexOf(array, 1, 8), 3); - }); + QUnit.test('should preserve the sign of `0`', function(assert) { + assert.expect(1); - test('should work with a negative `fromIndex`', 1, function() { - strictEqual(_.lastIndexOf(array, 2, -3), 1); - }); + var array = [-0, 1], + largeArray = lodashStable.times(LARGE_ARRAY_SIZE, stubOne), + others = [[1], largeArray], + expected = lodashStable.map(others, lodashStable.constant(['-0'])); - test('should work with a negative `fromIndex` <= `-array.length`', 2, function() { - strictEqual(_.lastIndexOf(array, 1, -6), 0); - equal(_.lastIndexOf(array, 2, -8), -1); - }); + var actual = lodashStable.map(others, function(other) { + return lodashStable.map(_.differenceWith(array, other, lodashStable.eq), lodashStable.toString); + }); - test('should ignore non-number `fromIndex` values', 2, function() { - equal(_.lastIndexOf([1, 2, 3], 3, '1'), 2); - equal(_.lastIndexOf([1, 2, 3], 3, true), 2); + assert.deepEqual(actual, expected); }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('indexOf methods'); + QUnit.module('lodash.divide'); (function() { - _.forEach(['indexOf', 'lastIndexOf'], function(methodName) { - var func = _[methodName]; + QUnit.test('should divide two numbers', function(assert) { + assert.expect(3); - test('`_.' + methodName + '` should accept a falsey `array` argument', 1, function() { - var expected = _.map(falsey, function() { return -1; }); + assert.strictEqual(_.divide(6, 4), 1.5); + assert.strictEqual(_.divide(-6, 4), -1.5); + assert.strictEqual(_.divide(-6, -4), 1.5); + }); - var actual = _.map(falsey, function(value, index) { - try { - return index ? func(value) : func(); - } catch(e) { } - }); + QUnit.test('should coerce arguments to numbers', function(assert) { + assert.expect(2); - deepEqual(actual, expected); - }); + assert.strictEqual(_.divide('6', '4'), 1.5); + assert.deepEqual(_.divide('x', 'y'), NaN); }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.map'); + QUnit.module('lodash.drop'); (function() { var array = [1, 2, 3]; - test('should pass the correct `callback` arguments', 1, function() { - var args; - - _.map(array, function() { - args || (args = slice.call(arguments)); - }); + QUnit.test('should drop the first two elements', function(assert) { + assert.expect(1); - deepEqual(args, [1, 0, array]); + assert.deepEqual(_.drop(array, 2), [3]); }); - test('should support the `thisArg` argument', 2, function() { - function callback(num, index) { - return this[index] + num; - } + QUnit.test('should treat falsey `n` values, except `undefined`, as `0`', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(falsey, function(value) { + return value === undefined ? [2, 3] : array; + }); - var actual = _.map([1], callback, [2]); - deepEqual(actual, [3]); + var actual = lodashStable.map(falsey, function(n) { + return _.drop(array, n); + }); - actual = _.map({ 'a': 1 }, callback, { 'a': 2 }); - deepEqual(actual, [3]); + assert.deepEqual(actual, expected); }); - test('should iterate over own properties of objects', 1, function() { - function Foo() { this.a = 1; } - Foo.prototype.b = 2; + QUnit.test('should return all elements when `n` < `1`', function(assert) { + assert.expect(3); - var actual = _.map(new Foo, function(value, key) { return key; }); - deepEqual(actual, ['a']); + lodashStable.each([0, -1, -Infinity], function(n) { + assert.deepEqual(_.drop(array, n), array); + }); }); - test('should work on an object with no `callback`', 1, function() { - var actual = _.map({ 'a': 1, 'b': 2, 'c': 3 }); - deepEqual(actual, array); - }); + QUnit.test('should return an empty array when `n` >= `length`', function(assert) { + assert.expect(4); - test('should handle object arguments with non-numeric length properties', 1, function() { - if (defineProperty) { - var object = {}; - defineProperty(object, 'length', { 'value': 'x' }); - deepEqual(_.map(object, _.identity), []); - } else { - skipTest(); - } + lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(n) { + assert.deepEqual(_.drop(array, n), []); + }); }); - test('should return a wrapped value when chaining', 1, function() { - if (!isNpm) { - ok(_(array).map(noop) instanceof _); - } - else { - skipTest(); - } + QUnit.test('should coerce `n` to an integer', function(assert) { + assert.expect(1); + + assert.deepEqual(_.drop(array, 1.6), [2, 3]); }); - test('should treat a nodelist as an array-like object', 1, function() { - if (document) { - var actual = _.map(document.getElementsByTagName('body'), function(element) { - return element.nodeName.toLowerCase(); - }); + QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) { + assert.expect(1); - deepEqual(actual, ['body']); - } - else { - skipTest(); - } + var array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]], + actual = lodashStable.map(array, _.drop); + + assert.deepEqual(actual, [[2, 3], [5, 6], [8, 9]]); }); - test('should accept a falsey `array` argument', 1, function() { - var expected = _.map(falsey, function() { return []; }); + QUnit.test('should work in a lazy sequence', function(assert) { + assert.expect(6); - var actual = _.map(falsey, function(value, index) { - try { - return index ? _.map(value) : _.map(); - } catch(e) { } - }); + if (!isNpm) { + var array = lodashStable.range(1, LARGE_ARRAY_SIZE + 1), + predicate = function(value) { values.push(value); return isEven(value); }, + values = [], + actual = _(array).drop(2).drop().value(); - deepEqual(actual, expected); - }); + assert.deepEqual(actual, array.slice(3)); + + actual = _(array).filter(predicate).drop(2).drop().value(); + assert.deepEqual(values, array); + assert.deepEqual(actual, _.drop(_.drop(_.filter(array, predicate), 2))); + + actual = _(array).drop(2).dropRight().drop().dropRight(2).value(); + assert.deepEqual(actual, _.dropRight(_.drop(_.dropRight(_.drop(array, 2))), 2)); + + values = []; - test('should be aliased', 1, function() { - strictEqual(_.collect, _.map); + actual = _(array).drop().filter(predicate).drop(2).dropRight().drop().dropRight(2).value(); + assert.deepEqual(values, array.slice(1)); + assert.deepEqual(actual, _.dropRight(_.drop(_.dropRight(_.drop(_.filter(_.drop(array), predicate), 2))), 2)); + } + else { + skipAssert(assert, 6); + } }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.mapValues'); + QUnit.module('lodash.dropRight'); (function() { - var object = { 'a': 1, 'b': 2, 'c': 3 }; + var array = [1, 2, 3]; - test('should pass the correct `callback` arguments', 1, function() { - var args; + QUnit.test('should drop the last two elements', function(assert) { + assert.expect(1); - _.mapValues(object, function() { - args || (args = slice.call(arguments)); + assert.deepEqual(_.dropRight(array, 2), [1]); + }); + + QUnit.test('should treat falsey `n` values, except `undefined`, as `0`', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(falsey, function(value) { + return value === undefined ? [1, 2] : array; + }); + + var actual = lodashStable.map(falsey, function(n) { + return _.dropRight(array, n); }); - deepEqual(args, [1, 'a', object]); + assert.deepEqual(actual, expected); }); - test('should support the `thisArg` argument', 2, function() { - function callback(num, key) { - return this[key] + num; - } + QUnit.test('should return all elements when `n` < `1`', function(assert) { + assert.expect(3); + + lodashStable.each([0, -1, -Infinity], function(n) { + assert.deepEqual(_.dropRight(array, n), array); + }); + }); - var actual = _.mapValues({ 'a': 1 }, callback, { 'a': 2 }); - deepEqual(actual, { 'a': 3 }); + QUnit.test('should return an empty array when `n` >= `length`', function(assert) { + assert.expect(4); - actual = _.mapValues([1], callback, [2]); - deepEqual(actual, { '0': 3 }); + lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(n) { + assert.deepEqual(_.dropRight(array, n), []); + }); }); - test('should iterate over own properties of objects', 1, function() { - function Foo() { this.a = 1; } - Foo.prototype.b = 2; + QUnit.test('should coerce `n` to an integer', function(assert) { + assert.expect(1); - var actual = _.mapValues(new Foo, function(value, key) { return key; }); - deepEqual(actual, { 'a': 'a' }); + assert.deepEqual(_.dropRight(array, 1.6), [1, 2]); }); - test('should work on an object with no `callback`', 1, function() { - var actual = _.mapValues({ 'a': 1, 'b': 2, 'c': 3 }); - deepEqual(actual, object); + QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) { + assert.expect(1); + + var array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]], + actual = lodashStable.map(array, _.dropRight); + + assert.deepEqual(actual, [[1, 2], [4, 5], [7, 8]]); }); - test('should return a wrapped value when chaining', 1, function() { + QUnit.test('should work in a lazy sequence', function(assert) { + assert.expect(6); + if (!isNpm) { - ok(_(object).mapValues(noop) instanceof _); - } - else { - skipTest(); - } - }); + var array = lodashStable.range(1, LARGE_ARRAY_SIZE + 1), + predicate = function(value) { values.push(value); return isEven(value); }, + values = [], + actual = _(array).dropRight(2).dropRight().value(); - test('should accept a falsey `object` argument', 1, function() { - var expected = _.map(falsey, function() { return {}; }); + assert.deepEqual(actual, array.slice(0, -3)); - var actual = _.map(falsey, function(value, index) { - try { - return index ? _.mapValues(value) : _.mapValues(); - } catch(e) { } - }); + actual = _(array).filter(predicate).dropRight(2).dropRight().value(); + assert.deepEqual(values, array); + assert.deepEqual(actual, _.dropRight(_.dropRight(_.filter(array, predicate), 2))); - deepEqual(actual, expected); + actual = _(array).dropRight(2).drop().dropRight().drop(2).value(); + assert.deepEqual(actual, _.drop(_.dropRight(_.drop(_.dropRight(array, 2))), 2)); + + values = []; + + actual = _(array).dropRight().filter(predicate).dropRight(2).drop().dropRight().drop(2).value(); + assert.deepEqual(values, array.slice(0, -1)); + assert.deepEqual(actual, _.drop(_.dropRight(_.drop(_.dropRight(_.filter(_.dropRight(array), predicate), 2))), 2)); + } + else { + skipAssert(assert, 6); + } }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.max'); + QUnit.module('lodash.dropRightWhile'); (function() { - test('should return the largest value from a collection', 1, function() { - equal(3, _.max([1, 2, 3])); - }); - - test('should return `-Infinity` for empty collections', 1, function() { - var expected = _.map(empties, function() { return -Infinity; }); + var array = [1, 2, 3, 4]; - var actual = _.map(empties, function(value) { - try { - return _.max(value); - } catch(e) { } - }); - - deepEqual(actual, expected); - }); + var objects = [ + { 'a': 0, 'b': 0 }, + { 'a': 1, 'b': 1 }, + { 'a': 2, 'b': 2 } + ]; - test('should return `-Infinity` for non-numeric collection values', 1, function() { - var collections = [['a', 'b'], { 'a': 'a', 'b': 'b' }], - expected = _.map(collections, function() { return -Infinity; }); + QUnit.test('should drop elements while `predicate` returns truthy', function(assert) { + assert.expect(1); - var actual = _.map(collections, function(value) { - try { - return _.max(value); - } catch(e) { } + var actual = _.dropRightWhile(array, function(n) { + return n > 2; }); - deepEqual(actual, expected); + assert.deepEqual(actual, [1, 2]); }); - }()); - /*--------------------------------------------------------------------------*/ + QUnit.test('should provide correct `predicate` arguments', function(assert) { + assert.expect(1); - QUnit.module('lodash.memoize'); + var args; - (function() { - test('should memoize results based on the first argument passed', 2, function() { - var memoized = _.memoize(function(a, b, c) { - return a + b + c; + _.dropRightWhile(array, function() { + args = slice.call(arguments); }); - equal(memoized(1, 2, 3), 6); - equal(memoized(1, 3, 5), 6); + assert.deepEqual(args, [4, 3, array]); }); - test('should support a `resolver` argument', 2, function() { - function func(a, b, c) { - return a + b + c; - } + QUnit.test('should work with `_.matches` shorthands', function(assert) { + assert.expect(1); - var memoized = _.memoize(func, func); - equal(memoized(1, 2, 3), 6); - equal(memoized(1, 3, 5), 9); + assert.deepEqual(_.dropRightWhile(objects, { 'b': 2 }), objects.slice(0, 2)); }); - test('should not set a `this` binding', 2, function() { - var memoized = _.memoize(function(a, b, c) { - return a + this.b + this.c; - }); + QUnit.test('should work with `_.matchesProperty` shorthands', function(assert) { + assert.expect(1); - var object = { 'b': 2, 'c': 3, 'memoized': memoized }; - equal(object.memoized(1), 6); - equal(object.memoized(2), 7); + assert.deepEqual(_.dropRightWhile(objects, ['b', 2]), objects.slice(0, 2)); }); - test('should check cache for own properties', 1, function() { - var actual = [], - memoized = _.memoize(_.identity); - - _.forEach(shadowedProps, function(value) { - actual.push(memoized(value)); - }); + QUnit.test('should work with `_.property` shorthands', function(assert) { + assert.expect(1); - deepEqual(actual, shadowedProps); + assert.deepEqual(_.dropRightWhile(objects, 'b'), objects.slice(0, 1)); }); - test('should expose a `cache` object on the `memoized` function', 2, function() { - var memoized = _.memoize(_.identity, _.identity); + QUnit.test('should return a wrapped value when chaining', function(assert) { + assert.expect(2); - memoized('x'); - equal(memoized.cache.x, 'x'); + if (!isNpm) { + var wrapped = _(array).dropRightWhile(function(n) { + return n > 2; + }); - memoized.cache.x = 'y'; - equal(memoized('x'), 'y'); + assert.ok(wrapped instanceof _); + assert.deepEqual(wrapped.value(), [1, 2]); + } + else { + skipAssert(assert, 2); + } }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.merge'); + QUnit.module('lodash.dropWhile'); (function() { - var args = arguments; - - test('should merge `source` into the destination object', 1, function() { - var names = { - 'characters': [ - { 'name': 'barney' }, - { 'name': 'fred' } - ] - }; + var array = [1, 2, 3, 4]; - var ages = { - 'characters': [ - { 'age': 36 }, - { 'age': 40 } - ] - }; + var objects = [ + { 'a': 2, 'b': 2 }, + { 'a': 1, 'b': 1 }, + { 'a': 0, 'b': 0 } + ]; - var heights = { - 'characters': [ - { 'height': '5\'4"' }, - { 'height': '5\'5"' } - ] - }; + QUnit.test('should drop elements while `predicate` returns truthy', function(assert) { + assert.expect(1); - var expected = { - 'characters': [ - { 'name': 'barney', 'age': 36, 'height': '5\'4"' }, - { 'name': 'fred', 'age': 40, 'height': '5\'5"' } - ] - }; + var actual = _.dropWhile(array, function(n) { + return n < 3; + }); - deepEqual(_.merge(names, ages, heights), expected); + assert.deepEqual(actual, [3, 4]); }); - test('should merge sources containing circular references', 1, function() { - var object = { - 'foo': { 'a': 1 }, - 'bar': { 'a': 2 } - }; + QUnit.test('should provide correct `predicate` arguments', function(assert) { + assert.expect(1); - var source = { - 'foo': { 'b': { 'foo': { 'c': { } } } }, - 'bar': { } - }; + var args; - source.foo.b.foo.c = source; - source.bar.b = source.foo.b; + _.dropWhile(array, function() { + args = slice.call(arguments); + }); - var actual = _.merge(object, source); - ok(actual.bar.b === actual.foo.b && actual.foo.b.foo.c === actual.foo.b.foo.c.foo.b.foo.c); + assert.deepEqual(args, [1, 0, array]); }); - test('should not treat `arguments` objects as plain objects', 1, function() { - var object = { - 'args': args - }; - - var source = { - 'args': { '3': 4 } - }; + QUnit.test('should work with `_.matches` shorthands', function(assert) { + assert.expect(1); - var actual = _.merge(object, source); - equal(_.isArguments(actual.args), false); + assert.deepEqual(_.dropWhile(objects, { 'b': 2 }), objects.slice(1)); }); - test('should work with four arguments', 1, function() { - var expected = { 'a': 4 }; - deepEqual(_.merge({ 'a': 1 }, { 'a': 2 }, { 'a': 3 }, expected), expected); - }); + QUnit.test('should work with `_.matchesProperty` shorthands', function(assert) { + assert.expect(1); - test('should assign `null` values', 1, function() { - var actual = _.merge({ 'a': 1 }, { 'a': null }); - strictEqual(actual.a, null); + assert.deepEqual(_.dropWhile(objects, ['b', 2]), objects.slice(1)); }); - test('should not assign `undefined` values', 1, function() { - var actual = _.merge({ 'a': 1 }, { 'a': undefined }); - strictEqual(actual.a, 1); - }); + QUnit.test('should work with `_.property` shorthands', function(assert) { + assert.expect(1); - test('should handle merging if `callback` returns `undefined`', 1, function() { - var actual = _.merge({ 'a': { 'b': [1, 1] } }, { 'a': { 'b': [0] } }, function() {}); - deepEqual(actual, { 'a': { 'b': [0, 1] } }); + assert.deepEqual(_.dropWhile(objects, 'b'), objects.slice(2)); }); - test('should defer to `callback` when it returns a value other than `undefined`', 1, function() { - var actual = _.merge({ 'a': { 'b': [0, 1] } }, { 'a': { 'b': [2] } }, function(a, b) { - return _.isArray(a) ? a.concat(b) : undefined; - }); - deepEqual(actual, { 'a': { 'b': [0, 1, 2] } }); + QUnit.test('should work in a lazy sequence', function(assert) { + assert.expect(3); + + if (!isNpm) { + var array = lodashStable.range(1, LARGE_ARRAY_SIZE + 3), + predicate = function(n) { return n < 3; }, + expected = _.dropWhile(array, predicate), + wrapped = _(array).dropWhile(predicate); + + assert.deepEqual(wrapped.value(), expected); + assert.deepEqual(wrapped.reverse().value(), expected.slice().reverse()); + assert.strictEqual(wrapped.last(), _.last(expected)); + } + else { + skipAssert(assert, 3); + } }); - test('should pass the correct values to `callback`', 1, function() { - var argsList = [], - array = [1, 2], - object = { 'b': 2 }; + QUnit.test('should work in a lazy sequence with `drop`', function(assert) { + assert.expect(1); - _.merge({ 'a': array }, { 'a': object }, function(a, b) { - argsList.push(slice.call(arguments)); - }); + if (!isNpm) { + var array = lodashStable.range(1, LARGE_ARRAY_SIZE + 3); + + var actual = _(array) + .dropWhile(function(n) { return n == 1; }) + .drop() + .dropWhile(function(n) { return n == 3; }) + .value(); - deepEqual(argsList, [[array, object], [undefined, 2]]); + assert.deepEqual(actual, array.slice(3)); + } + else { + skipAssert(assert); + } }); - }(1, 2, 3)); + }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.min'); + QUnit.module('lodash.endsWith'); (function() { - test('should return the smallest value from a collection', 1, function() { - equal(1, _.min([1, 2, 3])); + var string = 'abc'; + + QUnit.test('should return `true` if a string ends with `target`', function(assert) { + assert.expect(1); + + assert.strictEqual(_.endsWith(string, 'c'), true); }); - test('should return `Infinity` for empty collections', 1, function() { - var expected = _.map(empties, function() { return Infinity; }); + QUnit.test('should return `false` if a string does not end with `target`', function(assert) { + assert.expect(1); - var actual = _.map(empties, function(value) { - try { - return _.min(value); - } catch(e) { } - }); + assert.strictEqual(_.endsWith(string, 'b'), false); + }); - deepEqual(actual, expected); + QUnit.test('should work with a `position`', function(assert) { + assert.expect(1); + + assert.strictEqual(_.endsWith(string, 'b', 2), true); }); - test('should return `Infinity` for non-numeric collection values', 1, function() { - var collections = [['a', 'b'], { 'a': 'a', 'b': 'b' }], - expected = _.map(collections, function() { return Infinity; }); + QUnit.test('should work with `position` >= `length`', function(assert) { + assert.expect(4); - var actual = _.map(collections, function(value) { - try { - return _.min(value); - } catch(e) { } + lodashStable.each([3, 5, MAX_SAFE_INTEGER, Infinity], function(position) { + assert.strictEqual(_.endsWith(string, 'c', position), true); }); - - deepEqual(actual, expected); }); - }()); - - /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.max and lodash.min'); + QUnit.test('should treat falsey `position` values, except `undefined`, as `0`', function(assert) { + assert.expect(1); - _.forEach(['max', 'min'], function(methodName) { - var array = [1, 2, 3], - func = _[methodName]; + var expected = lodashStable.map(falsey, stubTrue); - test('`_.' + methodName + '` should work with Date objects', 1, function() { - var now = new Date, - past = new Date(0); + var actual = lodashStable.map(falsey, function(position) { + return _.endsWith(string, position === undefined ? 'c' : '', position); + }); - equal(func([now, past]), methodName == 'max' ? now : past); + assert.deepEqual(actual, expected); }); - test('`_.' + methodName + '` should work with a `callback` argument', 1, function() { - var actual = func(array, function(num) { - return -num; + QUnit.test('should treat a negative `position` as `0`', function(assert) { + assert.expect(6); + + lodashStable.each([-1, -3, -Infinity], function(position) { + assert.ok(lodashStable.every(string, function(chr) { + return !_.endsWith(string, chr, position); + })); + assert.strictEqual(_.endsWith(string, '', position), true); }); + }); + + QUnit.test('should coerce `position` to an integer', function(assert) { + assert.expect(1); - equal(actual, methodName == 'max' ? 1 : 3); + assert.strictEqual(_.endsWith(string, 'ab', 2.2), true); }); + }()); - test('`_.' + methodName + '` should pass the correct `callback` arguments when iterating an array', 1, function() { - var args; + /*--------------------------------------------------------------------------*/ - func(array, function() { - args || (args = slice.call(arguments)); - }); + QUnit.module('lodash.eq'); + + (function() { + QUnit.test('should perform a `SameValueZero` comparison of two values', function(assert) { + assert.expect(11); - deepEqual(args, [1, 0, array]); + assert.strictEqual(_.eq(), true); + assert.strictEqual(_.eq(undefined), true); + assert.strictEqual(_.eq(0, -0), true); + assert.strictEqual(_.eq(NaN, NaN), true); + assert.strictEqual(_.eq(1, 1), true); + + assert.strictEqual(_.eq(null, undefined), false); + assert.strictEqual(_.eq(1, Object(1)), false); + assert.strictEqual(_.eq(1, '1'), false); + assert.strictEqual(_.eq(1, '1'), false); + + var object = { 'a': 1 }; + assert.strictEqual(_.eq(object, object), true); + assert.strictEqual(_.eq(object, { 'a': 1 }), false); }); + }()); - test('`_.' + methodName + '` should pass the correct `callback` arguments when iterating an object', 1, function() { - var args, - object = { 'a': 1, 'b': 2 }, - firstKey = _.first(_.keys(object)); + /*--------------------------------------------------------------------------*/ - var expected = firstKey == 'a' - ? [1, 'a', object] - : [2, 'b', object]; + QUnit.module('lodash.escape'); - func(object, function() { - args || (args = slice.call(arguments)); - }, 0); + (function() { + var escaped = '&<>"'/', + unescaped = '&<>"\'/'; - deepEqual(args, expected); - }); + escaped += escaped; + unescaped += unescaped; - test('`_.' + methodName + '` should support the `thisArg` argument', 1, function() { - var actual = func(array, function(num, index) { - return -this[index]; - }, array); + QUnit.test('should escape values', function(assert) { + assert.expect(1); - equal(actual, methodName == 'max' ? 1 : 3); + assert.strictEqual(_.escape(unescaped), escaped); }); - test('`_.' + methodName + '` should work when used as `callback` for `_.map`', 1, function() { - var array = [[2, 3, 1], [5, 6, 4], [8, 9, 7]], - actual = _.map(array, func); + QUnit.test('should handle strings with nothing to escape', function(assert) { + assert.expect(1); - deepEqual(actual, methodName == 'max' ? [3, 6, 9] : [1, 4, 7]); + assert.strictEqual(_.escape('abc'), 'abc'); }); - test('`_.' + methodName + '` should iterate an object', 1, function() { - var actual = func({ 'a': 1, 'b': 2, 'c': 3 }); - equal(actual, methodName == 'max' ? 3 : 1); + QUnit.test('should escape the same characters unescaped by `_.unescape`', function(assert) { + assert.expect(1); + + assert.strictEqual(_.escape(_.unescape(escaped)), escaped); }); - test('`_.' + methodName + '` should iterate a string', 2, function() { - _.forEach(['abc', Object('abc')], function(value) { - var actual = func(value); - equal(actual, methodName == 'max' ? 'c' : 'a'); + lodashStable.each(['`', '/'], function(chr) { + QUnit.test('should not escape the "' + chr + '" character', function(assert) { + assert.expect(1); + + assert.strictEqual(_.escape(chr), chr); }); }); + }()); - test('`_.' + methodName + '` should resolve the correct value when provided an array containing only one value', 1, function() { - if (!isNpm) { - var actual = _([40])[methodName]().value(); - strictEqual(actual, 40); - } - else { - skipTest(); - } + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.escapeRegExp'); + + (function() { + var escaped = '\\^\\$\\.\\*\\+\\?\$\$\\[\\]\\{\\}\\|\\\\', + unescaped = '^$.*+?()[]{}|\\'; + + QUnit.test('should escape values', function(assert) { + assert.expect(1); + + assert.strictEqual(_.escapeRegExp(unescaped + unescaped), escaped + escaped); + }); + + QUnit.test('should handle strings with nothing to escape', function(assert) { + assert.expect(1); + + assert.strictEqual(_.escapeRegExp('abc'), 'abc'); }); - test('`_.' + methodName + '` should work with extremely large arrays', 1, function() { - var array = _.range(0, 5e5); - equal(func(array), methodName == 'max' ? 499999 : 0); + QUnit.test('should return an empty string for empty values', function(assert) { + assert.expect(1); + + var values = [, null, undefined, ''], + expected = lodashStable.map(values, stubString); + + var actual = lodashStable.map(values, function(value, index) { + return index ? _.escapeRegExp(value) : _.escapeRegExp(); + }); + + assert.deepEqual(actual, expected); }); - }); + }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.mixin'); + QUnit.module('lodash.every'); (function() { - function wrapper(value) { - if (!(this instanceof wrapper)) { - return new wrapper(value); - } - this.__wrapped__ = value; - } - - var value = ['a'], - source = { 'a': function(array) { return array[0]; } }; + QUnit.test('should return `true` if `predicate` returns truthy for all elements', function(assert) { + assert.expect(1); - test('should accept an `object` argument', 1, function() { - var lodash = {}; - _.mixin(lodash, source); - strictEqual(lodash.a(value), 'a'); + assert.strictEqual(lodashStable.every([true, 1, 'a'], identity), true); }); - test('should accept a function `object` argument', 2, function() { - _.mixin(wrapper, source); + QUnit.test('should return `true` for empty collections', function(assert) { + assert.expect(1); - var wrapped = wrapper(value), - actual = wrapped.a(); + var expected = lodashStable.map(empties, stubTrue); - strictEqual(actual.__wrapped__, 'a'); - ok(actual instanceof wrapper); + var actual = lodashStable.map(empties, function(value) { + try { + return _.every(value, identity); + } catch (e) {} + }); - delete wrapper.a; - delete wrapper.prototype.a; + assert.deepEqual(actual, expected); }); - test('should mixin `source` methods into lodash', 4, function() { - if (!isNpm) { - _.mixin({ - 'a': 'a', - 'A': function(string) { return string.toUpperCase(); } - }); + QUnit.test('should return `false` as soon as `predicate` returns falsey', function(assert) { + assert.expect(2); + + var count = 0; - equal('a' in _, false); - equal('a' in _.prototype, false); + assert.strictEqual(_.every([true, null, true], function(value) { + count++; + return value; + }), false); - delete _.a; - delete _.prototype.a; + assert.strictEqual(count, 2); + }); - equal(_.A('a'), 'A'); - equal(_('a').A().value(), 'A'); + QUnit.test('should work with collections of `undefined` values (test in IE < 9)', function(assert) { + assert.expect(1); - delete _.A; - delete _.prototype.A; - } - else { - skipTest(4); - } + assert.strictEqual(_.every([undefined, undefined, undefined], identity), false); }); - test('should accept an `options` argument', 16, function() { - function message(func, chain) { - return (func === _ ? 'lodash' : 'provided') + ' function should ' + (chain ? '' : 'not ') + 'chain'; - } + QUnit.test('should use `_.identity` when `predicate` is nullish', function(assert) { + assert.expect(2); - _.forEach([_, wrapper], function(func) { - _.forEach([false, true, { 'chain': false }, { 'chain': true }], function(options) { - if (func === _) { - _.mixin(source, options); - } else { - _.mixin(func, source, options); - } - var wrapped = func(value), - actual = wrapped.a(); + var values = [, null, undefined], + expected = lodashStable.map(values, stubFalse); - if (options && (options === true || options.chain)) { - strictEqual(actual.__wrapped__, 'a', message(func, true)); - ok(actual instanceof func, message(func, true)); - } else { - strictEqual(actual, 'a', message(func, false)); - equal(actual instanceof func, false, message(func, false)); - } - delete func.a; - delete func.prototype.a; - }); + var actual = lodashStable.map(values, function(value, index) { + var array = [0]; + return index ? _.every(array, value) : _.every(array); }); - }); - test('should not error when passed non-object `options` values', 2, function() { - var pass = true; + assert.deepEqual(actual, expected); - try { - _.mixin({}, source, 1); - } catch(e) { - pass = false; - } - ok(pass); + expected = lodashStable.map(values, stubTrue); + actual = lodashStable.map(values, function(value, index) { + var array = [1]; + return index ? _.every(array, value) : _.every(array); + }); - pass = true; + assert.deepEqual(actual, expected); + }); - try { - _.mixin(source, 1); - } catch(e) { - pass = false; - } - delete _.a; - delete _.prototype.a; + QUnit.test('should work with `_.property` shorthands', function(assert) { + assert.expect(2); - ok(pass); + var objects = [{ 'a': 0, 'b': 1 }, { 'a': 1, 'b': 2 }]; + assert.strictEqual(_.every(objects, 'a'), false); + assert.strictEqual(_.every(objects, 'b'), true); }); - }()); - - /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.noop'); + QUnit.test('should work with `_.matches` shorthands', function(assert) { + assert.expect(2); - (function() { - test('should always return `undefined`', 1, function() { - var values = falsey.concat([], true, new Date, _, {}, /x/, 'a'), - expected = _.map(values, function() { return undefined; }); + var objects = [{ 'a': 0, 'b': 0 }, { 'a': 0, 'b': 1 }]; + assert.strictEqual(_.every(objects, { 'a': 0 }), true); + assert.strictEqual(_.every(objects, { 'b': 1 }), false); + }); - var actual = _.map(values, function(value, index) { - return index ? _.noop(value) : _.noop(); - }); + QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) { + assert.expect(1); - deepEqual(actual, expected); + var actual = lodashStable.map([[1]], _.every); + assert.deepEqual(actual, [true]); }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.now'); + QUnit.module('strict mode checks'); - (function() { - asyncTest('should return the number of milliseconds that have elapsed since the Unix epoch', 2, function() { - var stamp = +new Date, - actual = _.now(); + lodashStable.each(['assign', 'assignIn', 'bindAll', 'defaults', 'defaultsDeep', 'merge'], function(methodName) { + var func = _[methodName], + isBindAll = methodName == 'bindAll'; - ok(actual >= stamp); + QUnit.test('`_.' + methodName + '` should ' + (isStrict ? '' : 'not ') + 'throw strict mode errors', function(assert) { + assert.expect(1); - if (!(isRhino && isModularize)) { - setTimeout(function() { - ok(_.now() > actual); - QUnit.start(); - }, 32); - } - else { - skipTest(); - QUnit.start(); + var object = freeze({ 'a': undefined, 'b': function() {} }), + pass = !isStrict; + + try { + func(object, isBindAll ? 'b' : { 'a': 1 }); + } catch (e) { + pass = !pass; } + assert.ok(pass); }); - }()); + }); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.omit'); + QUnit.module('lodash.fill'); (function() { - var args = arguments, - object = { 'a': 1, 'b': 2, 'c': 3 }, - expected = { 'b': 2 }; - - test('should create an object with omitted properties', 2, function() { - deepEqual(_.omit(object, 'a'), { 'b': 2, 'c': 3 }); - deepEqual(_.omit(object, 'a', 'c'), expected); - }); + QUnit.test('should use a default `start` of `0` and a default `end` of `length`', function(assert) { + assert.expect(1); - test('should support picking an array of properties', 1, function() { - deepEqual(_.omit(object, ['a', 'c']), expected); + var array = [1, 2, 3]; + assert.deepEqual(_.fill(array, 'a'), ['a', 'a', 'a']); }); - test('should support picking an array of properties and individual properties', 1, function() { - deepEqual(_.omit(object, ['a'], 'c'), expected); - }); + QUnit.test('should use `undefined` for `value` if not given', function(assert) { + assert.expect(2); - test('should iterate over inherited properties', 1, function() { - function Foo() {} - Foo.prototype = object; + var array = [1, 2, 3], + actual = _.fill(array); - deepEqual(_.omit(new Foo, 'a', 'c'), expected); + assert.deepEqual(actual, Array(3)); + assert.ok(lodashStable.every(actual, function(value, index) { + return index in actual; + })); }); - test('should work with `arguments` objects as secondary arguments', 1, function() { - deepEqual(_.omit(object, args), expected); - }); + QUnit.test('should work with a positive `start`', function(assert) { + assert.expect(1); - test('should work with an array `object` argument', 1, function() { - deepEqual(_.omit([1, 2, 3], '0', '2'), { '1': 2 }); + var array = [1, 2, 3]; + assert.deepEqual(_.fill(array, 'a', 1), [1, 'a', 'a']); }); - test('should work with a `callback` argument', 1, function() { - var actual = _.omit(object, function(num) { - return num != 2; - }); + QUnit.test('should work with a `start` >= `length`', function(assert) { + assert.expect(4); - deepEqual(actual, expected); + lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(start) { + var array = [1, 2, 3]; + assert.deepEqual(_.fill(array, 'a', start), [1, 2, 3]); + }); }); - test('should pass the correct `callback` arguments', 1, function() { - var args, - object = { 'a': 1, 'b': 2 }, - lastKey = _.keys(object).pop(); + QUnit.test('should treat falsey `start` values as `0`', function(assert) { + assert.expect(1); - var expected = lastKey == 'b' - ? [1, 'a', object] - : [2, 'b', object]; + var expected = lodashStable.map(falsey, lodashStable.constant(['a', 'a', 'a'])); - _.omit(object, function() { - args || (args = slice.call(arguments)); + var actual = lodashStable.map(falsey, function(start) { + var array = [1, 2, 3]; + return _.fill(array, 'a', start); }); - deepEqual(args, expected); + assert.deepEqual(actual, expected); }); - test('should correctly set the `this` binding', 1, function() { - var actual = _.omit(object, function(num) { - return num != this.b; - }, { 'b': 2 }); + QUnit.test('should work with a negative `start`', function(assert) { + assert.expect(1); - deepEqual(actual, expected); + var array = [1, 2, 3]; + assert.deepEqual(_.fill(array, 'a', -1), [1, 2, 'a']); }); - }('a', 'c')); - /*--------------------------------------------------------------------------*/ + QUnit.test('should work with a negative `start` <= negative `length`', function(assert) { + assert.expect(3); - QUnit.module('lodash.once'); + lodashStable.each([-3, -4, -Infinity], function(start) { + var array = [1, 2, 3]; + assert.deepEqual(_.fill(array, 'a', start), ['a', 'a', 'a']); + }); + }); - (function() { - test('should execute `func` once', 1, function() { - var count = 0, - func = _.once(function() { count++; }); + QUnit.test('should work with `start` >= `end`', function(assert) { + assert.expect(2); - func(); - func(); - strictEqual(count, 1); + lodashStable.each([2, 3], function(start) { + var array = [1, 2, 3]; + assert.deepEqual(_.fill(array, 'a', start, 2), [1, 2, 3]); + }); }); - test('should not set a `this` binding', 1, function() { - var func = _.once(function() { this.count++; }), - object = { 'count': 0, 'once': func }; + QUnit.test('should work with a positive `end`', function(assert) { + assert.expect(1); - object.once(); - object.once(); - strictEqual(object.count, 1); + var array = [1, 2, 3]; + assert.deepEqual(_.fill(array, 'a', 0, 1), ['a', 2, 3]); }); - test('should ignore recursive calls', 1, function() { - var count = 0; + QUnit.test('should work with a `end` >= `length`', function(assert) { + assert.expect(4); - var func = _.once(function() { - count++; - func(); + lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(end) { + var array = [1, 2, 3]; + assert.deepEqual(_.fill(array, 'a', 0, end), ['a', 'a', 'a']); }); - - func(); - strictEqual(count, 1); }); - test('should not throw more than once', 2, function() { - var pass = true; + QUnit.test('should treat falsey `end` values, except `undefined`, as `0`', function(assert) { + assert.expect(1); - var func = _.once(function() { - throw new Error; + var expected = lodashStable.map(falsey, function(value) { + return value === undefined ? ['a', 'a', 'a'] : [1, 2, 3]; }); - raises(function() { func(); }, Error); + var actual = lodashStable.map(falsey, function(end) { + var array = [1, 2, 3]; + return _.fill(array, 'a', 0, end); + }); - try { - func(); - } catch(e) { - pass = false; - } - ok(pass); + assert.deepEqual(actual, expected); }); - }()); - /*--------------------------------------------------------------------------*/ - - QUnit.module('lodash.pairs'); + QUnit.test('should work with a negative `end`', function(assert) { + assert.expect(1); - (function() { - test('should create a two dimensional array of an object\'s key-value pairs', 1, function() { - var object = { 'a': 1, 'b': 2 }; - deepEqual(_.pairs(object), [['a', 1], ['b', 2]]); + var array = [1, 2, 3]; + assert.deepEqual(_.fill(array, 'a', 0, -1), ['a', 'a', 3]); }); - test('should work with an object that has a `length` property', 1, function() { - var object = { '0': 'a', '1': 'b', 'length': 2 }; - deepEqual(_.pairs(object), [['0', 'a'], ['1', 'b'], ['length', 2]]); + QUnit.test('should work with a negative `end` <= negative `length`', function(assert) { + assert.expect(3); + + lodashStable.each([-3, -4, -Infinity], function(end) { + var array = [1, 2, 3]; + assert.deepEqual(_.fill(array, 'a', 0, end), [1, 2, 3]); + }); }); - }()); - /*--------------------------------------------------------------------------*/ + QUnit.test('should coerce `start` and `end` to integers', function(assert) { + assert.expect(1); - QUnit.module('lodash.parseInt'); + var positions = [[0.1, 1.6], ['0', 1], [0, '1'], ['1'], [NaN, 1], [1, NaN]]; - (function() { - test('should parse strings with leading whitespace and zeros with a `radix` of 10 by default (test in Chrome, Firefox, and Opera)', 2, function() { - var whitespace = ' \x09\x0B\x0C\xA0\ufeff\x0A\x0D\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000'; - equal(_.parseInt('08'), 8); - equal(_.parseInt(whitespace + '08'), 8); + var actual = lodashStable.map(positions, function(pos) { + var array = [1, 2, 3]; + return _.fill.apply(_, [array, 'a'].concat(pos)); + }); + + assert.deepEqual(actual, [['a', 2, 3], ['a', 2, 3], ['a', 2, 3], [1, 'a', 'a'], ['a', 2, 3], [1, 2, 3]]); }); - test('should use a radix of `10`, for non-hexadecimals, if `radix` is `undefined` or `0`', 3, function() { - equal(_.parseInt('10', 0), 10); - equal(_.parseInt('10'), 10); - equal(_.parseInt('10', undefined), 10); + QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) { + assert.expect(1); + + var array = [[1, 2], [3, 4]], + actual = lodashStable.map(array, _.fill); + + assert.deepEqual(actual, [[0, 0], [1, 1]]); }); - test('should use a radix of `16`, for hexadecimals, if `radix` is `undefined` or `0`', 3, function() { - equal(_.parseInt('0x20', 0), 32); - equal(_.parseInt('0x20'), 32); - equal(_.parseInt('0x20', undefined), 32); + QUnit.test('should return a wrapped value when chaining', function(assert) { + assert.expect(3); + + if (!isNpm) { + var array = [1, 2, 3], + wrapped = _(array).fill('a'), + actual = wrapped.value(); + + assert.ok(wrapped instanceof _); + assert.strictEqual(actual, array); + assert.deepEqual(actual, ['a', 'a', 'a']); + } + else { + skipAssert(assert, 3); + } }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('partial methods'); + QUnit.module('lodash.filter'); - _.forEach(['partial', 'partialRight'], function(methodName) { - var func = _[methodName], - isPartial = methodName == 'partial'; + (function() { + var array = [1, 2, 3]; - test('`_.' + methodName + '` partially applies without additional arguments', 1, function() { - var arg = 'a', - fn = function(x) { return x; }; + QUnit.test('should return elements `predicate` returns truthy for', function(assert) { + assert.expect(1); - equal(func(fn, arg)(), arg); + assert.deepEqual(_.filter(array, isEven), [2]); }); + }()); - test('`_.' + methodName + '` partially applies with additional arguments', 1, function() { - var arg1 = 'a', - arg2 = 'b', - expected = [arg1, arg2], - fn = function(x, y) { return [x, y]; }; + /*--------------------------------------------------------------------------*/ - if (!isPartial) { - expected.reverse(); - } - deepEqual(func(fn, arg1)(arg2), expected); - }); + lodashStable.each(['find', 'findIndex', 'findKey', 'findLast', 'findLastIndex', 'findLastKey'], function(methodName) { + QUnit.module('lodash.' + methodName); - test('`_.' + methodName + '` works without partially applying arguments, without additional arguments', 1, function() { - var fn = function() { return arguments.length; }; - strictEqual(func(fn)(), 0); - }); + var array = [1, 2, 3, 4], + func = _[methodName]; - test('`_.' + methodName + '` works without partially applying arguments, with additional arguments', 1, function() { - var arg = 'a', - fn = function(x) { return x; }; + var objects = [ + { 'a': 0, 'b': 0 }, + { 'a': 1, 'b': 1 }, + { 'a': 2, 'b': 2 } + ]; - equal(func(fn)(arg), arg); - }); + var expected = ({ + 'find': [objects[1], undefined, objects[2]], + 'findIndex': [1, -1, 2], + 'findKey': ['1', undefined, '2'], + 'findLast': [objects[2], undefined, objects[2]], + 'findLastIndex': [2, -1, 2], + 'findLastKey': ['2', undefined, '2'] + })[methodName]; - test('`_.' + methodName + '` should not alter the `this` binding', 3, function() { - var object = { 'a': 1 }, - fn = function() { return this.a; }; + QUnit.test('`_.' + methodName + '` should return the found value', function(assert) { + assert.expect(1); + + assert.strictEqual(func(objects, function(object) { return object.a; }), expected[0]); + }); - strictEqual(func(_.bind(fn, object))(), object.a); - strictEqual(_.bind(func(fn), object)(), object.a); + QUnit.test('`_.' + methodName + '` should return `' + expected[1] + '` if value is not found', function(assert) { + assert.expect(1); - object.fn = func(fn); - strictEqual(object.fn(), object.a); + assert.strictEqual(func(objects, function(object) { return object.a === 3; }), expected[1]); }); - test('`_.' + methodName + '` returns a function with a `length` of `0`', 1, function() { - var fn = function(a, b, c) {}, - actual = func(fn, 'a'); + QUnit.test('`_.' + methodName + '` should work with `_.matches` shorthands', function(assert) { + assert.expect(1); - strictEqual(actual.length, 0); + assert.strictEqual(func(objects, { 'b': 2 }), expected[2]); }); - test('ensure `new bound` is an instance of `func`', 2, function() { - function Foo(value) { - return value && object; - } - var bound = func(Foo), - object = {}; + QUnit.test('`_.' + methodName + '` should work with `_.matchesProperty` shorthands', function(assert) { + assert.expect(1); - ok(new bound instanceof Foo); - strictEqual(new bound(true), object); + assert.strictEqual(func(objects, ['b', 2]), expected[2]); }); - test('`_.' + methodName + '` should clone `__bindData__` for created functions', 3, function() { - function greet(greeting, name) { - return greeting + ' ' + name; - } - var par1 = func(greet, 'hi'), - par2 = func(par1, 'barney'), - par3 = func(par1, 'pebbles'); + QUnit.test('`_.' + methodName + '` should work with `_.property` shorthands', function(assert) { + assert.expect(1); - equal(par1('fred'), isPartial ? 'hi fred' : 'fred hi') - equal(par2(), isPartial ? 'hi barney' : 'barney hi'); - equal(par3(), isPartial ? 'hi pebbles' : 'pebbles hi'); + assert.strictEqual(func(objects, 'b'), expected[0]); }); - }); - /*--------------------------------------------------------------------------*/ + QUnit.test('`_.' + methodName + '` should return `' + expected[1] + '` for empty collections', function(assert) { + assert.expect(1); - QUnit.module('lodash.partialRight'); + var emptyValues = lodashStable.endsWith(methodName, 'Index') ? lodashStable.reject(empties, lodashStable.isPlainObject) : empties, + expecting = lodashStable.map(emptyValues, lodashStable.constant(expected[1])); - (function() { - test('should work as a deep `_.defaults`', 1, function() { - var object = { 'a': { 'b': 1 } }, - source = { 'a': { 'b': 2, 'c': 3 } }, - expected = { 'a': { 'b': 1, 'c': 3 } }; + var actual = lodashStable.map(emptyValues, function(value) { + try { + return func(value, { 'a': 3 }); + } catch (e) {} + }); - var deepDefaults = _.partialRight(_.merge, _.defaults); - deepEqual(deepDefaults(object, source), expected); + assert.deepEqual(actual, expecting); }); - }()); - /*--------------------------------------------------------------------------*/ + QUnit.test('`_.' + methodName + '` should return an unwrapped value when implicitly chaining', function(assert) { + assert.expect(1); - QUnit.module('methods using `createWrapper`'); + var expected = ({ + 'find': 1, + 'findIndex': 0, + 'findKey': '0', + 'findLast': 4, + 'findLastIndex': 3, + 'findLastKey': '3' + })[methodName]; - (function() { - test('combinations of partial functions should work', 1, function() { - function func() { - return slice.call(arguments); + if (!isNpm) { + assert.strictEqual(_(array)[methodName](), expected); + } + else { + skipAssert(assert); } - var a = _.partial(func), - b = _.partialRight(a, 3), - c = _.partial(b, 1); - - deepEqual(c(2), [1, 2, 3]); }); - test('combinations of bound and partial functions should work', 3, function() { - function func() { - var result = [this.x]; - push.apply(result, arguments); - return result; - } - var expected = [1, 2, 3, 4], - object = { 'func': func, 'x': 1 }; + QUnit.test('`_.' + methodName + '` should return a wrapped value when explicitly chaining', function(assert) { + assert.expect(1); - var a = _.bindKey(object, 'func'), - b = _.partialRight(a, 4), - c = _.partial(b, 2); + if (!isNpm) { + assert.ok(_(array).chain()[methodName]() instanceof _); + } + else { + skipAssert(assert); + } + }); - deepEqual(c(3), expected); + QUnit.test('`_.' + methodName + '` should not execute immediately when explicitly chaining', function(assert) { + assert.expect(1); - a = _.bind(func, object); - b = _.partialRight(a, 4); - c = _.partial(b, 2); + if (!isNpm) { + var wrapped = _(array).chain()[methodName](); + assert.strictEqual(wrapped.__wrapped__, array); + } + else { + skipAssert(assert); + } + }); - deepEqual(c(3), expected); + QUnit.test('`_.' + methodName + '` should work in a lazy sequence', function(assert) { + assert.expect(2); - a = _.partial(func, 2); - b = _.bind(a, object); - c = _.partialRight(b, 4); + if (!isNpm) { + var largeArray = lodashStable.range(1, LARGE_ARRAY_SIZE + 1), + smallArray = array; - deepEqual(c(3), expected); - }); + lodashStable.times(2, function(index) { + var array = index ? largeArray : smallArray, + wrapped = _(array).filter(isEven); - test('recursively bound functions should work', 1, function() { - function func() { - return this.x; + assert.strictEqual(wrapped[methodName](), func(lodashStable.filter(array, isEven))); + }); + } + else { + skipAssert(assert, 2); } - var a = _.bind(func, { 'x': 1 }), - b = _.bind(a, { 'x': 2 }), - c = _.bind(b, { 'x': 3 }); - - strictEqual(c(), 1); }); - }()); + }); - /*--------------------------------------------------------------------------*/ + _.each(['find', 'findIndex', 'findLast', 'findLastIndex'], function(methodName) { + var func = _[methodName]; - QUnit.module('lodash.pick'); + QUnit.test('`_.' + methodName + '` should provide correct `predicate` arguments for arrays', function(assert) { + assert.expect(1); - (function() { - var args = arguments, - object = { 'a': 1, 'b': 2, 'c': 3 }, - expected = { 'a': 1, 'c': 3 }; + var args, + array = ['a']; - test('should create an object of picked properties', 2, function() { - deepEqual(_.pick(object, 'a'), { 'a': 1 }); - deepEqual(_.pick(object, 'a', 'c'), expected); - }); + func(array, function() { + args || (args = slice.call(arguments)); + }); - test('should support picking an array of properties', 1, function() { - deepEqual(_.pick(object, ['a', 'c']), expected); + assert.deepEqual(args, ['a', 0, array]); }); + }); - test('should support picking an array of properties and individual properties', 1, function() { - deepEqual(_.pick(object, ['a'], 'c'), expected); - }); + _.each(['find', 'findKey', 'findLast', 'findLastKey'], function(methodName) { + var func = _[methodName]; - test('should iterate over inherited properties', 1, function() { - function Foo() {} - Foo.prototype = object; + QUnit.test('`_.' + methodName + '` should work with an object for `collection`', function(assert) { + assert.expect(1); - deepEqual(_.pick(new Foo, 'a', 'c'), expected); - }); + var actual = func({ 'a': 1, 'b': 2, 'c': 3 }, function(n) { + return n < 3; + }); - test('should work with `arguments` objects as secondary arguments', 1, function() { - deepEqual(_.pick(object, args), expected); - }); + var expected = ({ + 'find': 1, + 'findKey': 'a', + 'findLast': 2, + 'findLastKey': 'b' + })[methodName]; - test('should work with an array `object` argument', 1, function() { - deepEqual(_.pick([1, 2, 3], '1'), { '1': 2 }); + assert.strictEqual(actual, expected); }); - test('should work with a `callback` argument', 1, function() { - var actual = _.pick(object, function(num) { - return num != 2; - }); - - deepEqual(actual, expected); - }); + QUnit.test('`_.' + methodName + '` should provide correct `predicate` arguments for objects', function(assert) { + assert.expect(1); - test('should pass the correct `callback` arguments', 1, function() { var args, - object = { 'a': 1, 'b': 2 }, - lastKey = _.keys(object).pop(); + object = { 'a': 1 }; - var expected = lastKey == 'b' - ? [1, 'a', object] - : [2, 'b', object]; - - _.pick(object, function() { + func(object, function() { args || (args = slice.call(arguments)); }); - deepEqual(args, expected); + assert.deepEqual(args, [1, 'a', object]); }); - - test('should correctly set the `this` binding', 1, function() { - var actual = _.pick(object, function(num) { - return num != this.b; - }, { 'b': 2 }); - - deepEqual(actual, expected); - }); - }('a', 'c')); + }); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.pluck'); + QUnit.module('lodash.find and lodash.findLast'); - (function() { - test('should return an array of property values from each element of a collection', 1, function() { - var objects = [{ 'name': 'barney', 'age': 36 }, { 'name': 'fred', 'age': 40 }], - actual = _.pluck(objects, 'name'); + lodashStable.each(['find', 'findLast'], function(methodName) { + var isFind = methodName == 'find'; - deepEqual(actual, ['barney', 'fred']); - }); + QUnit.test('`_.' + methodName + '` should support shortcut fusion', function(assert) { + assert.expect(3); - test('should work with an object for `collection`', 1, function() { - var object = { 'a': [1], 'b': [1, 2], 'c': [1, 2, 3] }; - deepEqual(_.pluck(object, 'length'), [1, 2, 3]); + if (!isNpm) { + var findCount = 0, + mapCount = 0, + array = lodashStable.range(1, LARGE_ARRAY_SIZE + 1), + iteratee = function(value) { mapCount++; return square(value); }, + predicate = function(value) { findCount++; return isEven(value); }, + actual = _(array).map(iteratee)[methodName](predicate); + + assert.strictEqual(findCount, isFind ? 2 : 1); + assert.strictEqual(mapCount, isFind ? 2 : 1); + assert.strictEqual(actual, isFind ? 4 : square(LARGE_ARRAY_SIZE)); + } + else { + skipAssert(assert, 3); + } }); - }()); + }); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.property'); + QUnit.module('lodash.find and lodash.includes'); - (function() { - test('should create a function that plucks a property value of a given object', 3, function() { - var object = { 'a': 1, 'b': 2 }, - actual = _.property('a'); + lodashStable.each(['includes', 'find'], function(methodName) { + var func = _[methodName], + isIncludes = methodName == 'includes', + resolve = methodName == 'find' ? lodashStable.curry(lodashStable.eq) : identity; - equal(actual.length, 1); - strictEqual(actual(object), 1); + lodashStable.each({ + 'an `arguments` object': args, + 'an array': [1, 2, 3] + }, + function(collection, key) { + var values = lodashStable.toArray(collection); - actual = _.property('b'); - strictEqual(actual(object), 2); - }); + QUnit.test('`_.' + methodName + '` should work with ' + key + ' and a positive `fromIndex`', function(assert) { + assert.expect(1); - test('should work with non-string `prop` arguments', 1, function() { - var array = [1, 2, 3], - actual = _.property(1); + var expected = [ + isIncludes || values[2], + isIncludes ? false : undefined + ]; - equal(actual(array), 2); - }); - }()); + var actual = [ + func(collection, resolve(values[2]), 2), + func(collection, resolve(values[1]), 2) + ]; - /*--------------------------------------------------------------------------*/ + assert.deepEqual(actual, expected); + }); - QUnit.module('lodash.pull'); + QUnit.test('`_.' + methodName + '` should work with ' + key + ' and a `fromIndex` >= `length`', function(assert) { + assert.expect(1); - (function() { - test('should modify and return the array', 2, function() { - var array = [1, 2, 3], - actual = _.pull(array, 1, 3); + var indexes = [4, 6, Math.pow(2, 32), Infinity]; - deepEqual(array, [2]); - ok(actual === array); - }); + var expected = lodashStable.map(indexes, function() { + var result = isIncludes ? false : undefined; + return [result, result, result]; + }); - test('should preserve holes in arrays', 2, function() { - var array = [1, 2, 3, 4]; - delete array[1]; - delete array[3]; + var actual = lodashStable.map(indexes, function(fromIndex) { + return [ + func(collection, resolve(1), fromIndex), + func(collection, resolve(undefined), fromIndex), + func(collection, resolve(''), fromIndex) + ]; + }); - _.pull(array, 1); - equal(0 in array, false); - equal(2 in array, false); - }); + assert.deepEqual(actual, expected); + }); - test('should treat holes as `undefined`', 1, function() { - var array = [1, 2, 3]; - delete array[1]; + QUnit.test('`_.' + methodName + '` should work with ' + key + ' and treat falsey `fromIndex` values as `0`', function(assert) { + assert.expect(1); - _.pull(array, undefined); - deepEqual(array, [1, 3]); - }); - }()); + var expected = lodashStable.map(falsey, lodashStable.constant(isIncludes || values[0])); - /*--------------------------------------------------------------------------*/ + var actual = lodashStable.map(falsey, function(fromIndex) { + return func(collection, resolve(values[0]), fromIndex); + }); - QUnit.module('lodash.random'); + assert.deepEqual(actual, expected); + }); - (function() { - var array = Array(1000); + QUnit.test('`_.' + methodName + '` should work with ' + key + ' and coerce `fromIndex` to an integer', function(assert) { + assert.expect(1); - test('should return `0` or `1` when arguments are not provided', 1, function() { - var actual = _.random(); - ok(actual === 0 || actual === 1); - }); + var expected = [ + isIncludes || values[0], + isIncludes || values[0], + isIncludes ? false : undefined + ]; - test('supports not passing a `max` argument', 1, function() { - var actual = _.random(5); - ok(_.some(array, function() { - return _.random(5) != 5; - })); - }); + var actual = [ + func(collection, resolve(values[0]), 0.1), + func(collection, resolve(values[0]), NaN), + func(collection, resolve(values[0]), '1') + ]; - test('supports large integer values', 2, function() { - var min = Math.pow(2, 31), - max = Math.pow(2, 62); + assert.deepEqual(actual, expected); + }); - ok(_.every(array, function() { - return _.random(min, max) >= min; - })); + QUnit.test('`_.' + methodName + '` should work with ' + key + ' and a negative `fromIndex`', function(assert) { + assert.expect(1); - ok(_.some(array, function() { - return _.random(Number.MAX_VALUE) > 0; - })); - }); + var expected = [ + isIncludes || values[2], + isIncludes ? false : undefined + ]; - test('should coerce arguments to numbers', 1, function() { - strictEqual(_.random('1', '1'), 1); - }); + var actual = [ + func(collection, resolve(values[2]), -1), + func(collection, resolve(values[1]), -1) + ]; - test('should support floats', 2, function() { - var min = 1.5, - max = 1.6, - actual = _.random(min, max); + assert.deepEqual(actual, expected); + }); - ok(actual % 1); - ok(actual >= min && actual <= max); - }); + QUnit.test('`_.' + methodName + '` should work with ' + key + ' and a negative `fromIndex` <= `-length`', function(assert) { + assert.expect(1); - test('supports passing a `floating` argument', 3, function() { - var actual = _.random(true); - ok(actual % 1 && actual >= 0 && actual <= 1); + var indexes = [-4, -6, -Infinity], + expected = lodashStable.map(indexes, lodashStable.constant(isIncludes || values[0])); - actual = _.random(2, true); - ok(actual % 1 && actual >= 0 && actual <= 2); + var actual = lodashStable.map(indexes, function(fromIndex) { + return func(collection, resolve(values[0]), fromIndex); + }); - actual = _.random(2, 4, true); - ok(actual % 1 && actual >= 2 && actual <= 4); + assert.deepEqual(actual, expected); + }); }); - }()); + }); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.range'); + QUnit.module('lodash.findIndex and lodash.indexOf'); - (function() { - var func = _.range; + lodashStable.each(['findIndex', 'indexOf'], function(methodName) { + var array = [1, 2, 3, 1, 2, 3], + func = _[methodName], + resolve = methodName == 'findIndex' ? lodashStable.curry(lodashStable.eq) : identity; - test('should work when passing a single `end` argument', 1, function() { - deepEqual(_.range(4), [0, 1, 2, 3]); - }); + QUnit.test('`_.' + methodName + '` should return the index of the first matched value', function(assert) { + assert.expect(1); - test('should work when passing `start` and `end` arguments', 1, function() { - deepEqual(_.range(1, 5), [1, 2, 3, 4]); + assert.strictEqual(func(array, resolve(3)), 2); }); - test('should work when passing `start`, `end`, and `step` arguments', 1, function() { - deepEqual(_.range(0, 20, 5), [0, 5, 10, 15]); - }); + QUnit.test('`_.' + methodName + '` should work with a positive `fromIndex`', function(assert) { + assert.expect(1); - test('should support a `step` of `0`', 1, function() { - deepEqual(_.range(1, 4, 0), [1, 1, 1]); + assert.strictEqual(func(array, resolve(1), 2), 3); }); - test('should work when passing `step` larger than `end`', 1, function() { - deepEqual(_.range(1, 5, 20), [1]); - }); + QUnit.test('`_.' + methodName + '` should work with a `fromIndex` >= `length`', function(assert) { + assert.expect(1); - test('should work when passing a negative `step` argument', 2, function() { - deepEqual(_.range(0, -4, -1), [0, -1, -2, -3]); - deepEqual(_.range(21, 10, -3), [21, 18, 15, 12]); - }); + var values = [6, 8, Math.pow(2, 32), Infinity], + expected = lodashStable.map(values, lodashStable.constant([-1, -1, -1])); - test('should treat falsey `start` arguments as `0`', 13, function() { - _.forEach(falsey, function(value, index) { - if (index) { - deepEqual(_.range(value), []); - deepEqual(_.range(value, 1), [0]); - } else { - deepEqual(_.range(), []); - } + var actual = lodashStable.map(values, function(fromIndex) { + return [ + func(array, resolve(undefined), fromIndex), + func(array, resolve(1), fromIndex), + func(array, resolve(''), fromIndex) + ]; }); + + assert.deepEqual(actual, expected); }); - test('should coerce arguments to numbers', 1, function() { - var actual = [func('0',1), func('1'), func(0, 1, '1')]; - deepEqual(actual, [[0], [0], [0]]); + QUnit.test('`_.' + methodName + '` should work with a negative `fromIndex`', function(assert) { + assert.expect(1); + + assert.strictEqual(func(array, resolve(2), -3), 4); }); - }()); - /*--------------------------------------------------------------------------*/ + QUnit.test('`_.' + methodName + '` should work with a negative `fromIndex` <= `-length`', function(assert) { + assert.expect(1); - QUnit.module('lodash.reduce'); + var values = [-6, -8, -Infinity], + expected = lodashStable.map(values, stubZero); - (function() { - var array = [1, 2, 3]; + var actual = lodashStable.map(values, function(fromIndex) { + return func(array, resolve(1), fromIndex); + }); - test('should use the first element of a collection as the default `accumulator`', 1, function() { - strictEqual(_.reduce(array), 1); + assert.deepEqual(actual, expected); }); - test('should pass the correct `callback` arguments when iterating an array', 2, function() { - var args; - - _.reduce(array, function() { - args || (args = slice.call(arguments)); - }, 0); + QUnit.test('`_.' + methodName + '` should treat falsey `fromIndex` values as `0`', function(assert) { + assert.expect(1); - deepEqual(args, [0, 1, 0, array]); + var expected = lodashStable.map(falsey, stubZero); - args = null; - _.reduce(array, function() { - args || (args = slice.call(arguments)); + var actual = lodashStable.map(falsey, function(fromIndex) { + return func(array, resolve(1), fromIndex); }); - deepEqual(args, [1, 2, 1, array]); + assert.deepEqual(actual, expected); }); - test('should pass the correct `callback` arguments when iterating an object', 2, function() { - var args, - object = { 'a': 1, 'b': 2 }, - firstKey = _.first(_.keys(object)); - - var expected = firstKey == 'a' - ? [0, 1, 'a', object] - : [0, 2, 'b', object]; - - _.reduce(object, function() { - args || (args = slice.call(arguments)); - }, 0); + QUnit.test('`_.' + methodName + '` should coerce `fromIndex` to an integer', function(assert) { + assert.expect(1); - deepEqual(args, expected); + assert.strictEqual(func(array, resolve(2), 1.2), 1); + }); + }); - args = null; - expected = firstKey == 'a' - ? [1, 2, 'b', object] - : [2, 1, 'a', object]; + /*--------------------------------------------------------------------------*/ - _.reduce(object, function() { - args || (args = slice.call(arguments)); - }); + QUnit.module('lodash.findLast'); - deepEqual(args, expected); - }); + (function() { + var resolve = lodashStable.curry(lodashStable.eq); - _.forEach({ - 'literal': 'abc', - 'object': Object('abc') + lodashStable.each({ + 'an `arguments` object': args, + 'an array': [1, 2, 3] }, function(collection, key) { - test('should work with a string ' + key + ' for `collection` (test in IE < 9)', 2, function() { - var args; + var values = lodashStable.toArray(collection); - var actual = _.reduce(collection, function(accumulator, value) { - args || (args = slice.call(arguments)); - return accumulator + value; - }); + QUnit.test('should work with ' + key + ' and a positive `fromIndex`', function(assert) { + assert.expect(1); + + var expected = [ + values[1], + undefined + ]; - deepEqual(args, ['a', 'b', 1, collection]); - equal(actual, 'abc'); + var actual = [ + _.findLast(collection, resolve(values[1]), 1), + _.findLast(collection, resolve(values[2]), 1) + ]; + + assert.deepEqual(actual, expected); }); - }); - test('should be aliased', 2, function() { - strictEqual(_.foldl, _.reduce); - strictEqual(_.inject, _.reduce); - }); - }()); + QUnit.test('should work with ' + key + ' and a `fromIndex` >= `length`', function(assert) { + assert.expect(1); - /*--------------------------------------------------------------------------*/ + var indexes = [4, 6, Math.pow(2, 32), Infinity]; - QUnit.module('lodash.reduceRight'); + var expected = lodashStable.map(indexes, lodashStable.constant([values[0], undefined, undefined])); - (function() { - var array = [1, 2, 3]; + var actual = lodashStable.map(indexes, function(fromIndex) { + return [ + _.findLast(collection, resolve(1), fromIndex), + _.findLast(collection, resolve(undefined), fromIndex), + _.findLast(collection, resolve(''), fromIndex) + ]; + }); - test('should use the last element of a collection as the default `accumulator`', 1, function() { - equal(_.reduceRight(array), 3); - }); + assert.deepEqual(actual, expected); + }); - test('should pass the correct `callback` arguments when iterating an array', 2, function() { - var args; + QUnit.test('should work with ' + key + ' and treat falsey `fromIndex` values correctly', function(assert) { + assert.expect(1); - _.reduceRight(array, function() { - args || (args = slice.call(arguments)); - }, 0); + var expected = lodashStable.map(falsey, function(value) { + return value === undefined ? values[3] : undefined; + }); - deepEqual(args, [0, 3, 2, array]); + var actual = lodashStable.map(falsey, function(fromIndex) { + return _.findLast(collection, resolve(values[3]), fromIndex); + }); - args = null; - _.reduceRight(array, function() { - args || (args = slice.call(arguments)); + assert.deepEqual(actual, expected); }); - deepEqual(args, [3, 2, 1, array]); - }); + QUnit.test('should work with ' + key + ' and coerce `fromIndex` to an integer', function(assert) { + assert.expect(1); - test('should pass the correct `callback` arguments when iterating an object', 2, function() { - var args, - object = { 'a': 1, 'b': 2 }, - lastKey = _.last(_.keys(object)); + var expected = [ + values[0], + values[0], + undefined + ]; - var expected = lastKey == 'b' - ? [0, 2, 'b', object] - : [0, 1, 'a', object]; + var actual = [ + _.findLast(collection, resolve(values[0]), 0.1), + _.findLast(collection, resolve(values[0]), NaN), + _.findLast(collection, resolve(values[2]), '1') + ]; - _.reduceRight(object, function() { - args || (args = slice.call(arguments)); - }, 0); + assert.deepEqual(actual, expected); + }); - deepEqual(args, expected); + QUnit.test('should work with ' + key + ' and a negative `fromIndex`', function(assert) { + assert.expect(1); - args = null; - expected = lastKey == 'b' - ? [2, 1, 'a', object] - : [1, 2, 'b', object]; + var expected = [ + values[1], + undefined + ]; - _.reduceRight(object, function() { - args || (args = slice.call(arguments)); + var actual = [ + _.findLast(collection, resolve(values[1]), -2), + _.findLast(collection, resolve(values[2]), -2) + ]; + + assert.deepEqual(actual, expected); }); - deepEqual(args, expected); - }); + QUnit.test('should work with ' + key + ' and a negative `fromIndex` <= `-length`', function(assert) { + assert.expect(1); - _.forEach({ - 'literal': 'abc', - 'object': Object('abc') - }, - function(collection, key) { - test('should work with a string ' + key + ' for `collection` (test in IE < 9)', 2, function() { - var args; + var indexes = [-4, -6, -Infinity], + expected = lodashStable.map(indexes, lodashStable.constant(values[0])); - var actual = _.reduceRight(collection, function(accumulator, value) { - args || (args = slice.call(arguments)); - return accumulator + value; + var actual = lodashStable.map(indexes, function(fromIndex) { + return _.findLast(collection, resolve(values[0]), fromIndex); }); - deepEqual(args, ['c', 'b', 1, collection]); - equal(actual, 'cba'); + assert.deepEqual(actual, expected); }); }); - - test('should be aliased', 1, function() { - strictEqual(_.foldr, _.reduceRight); - }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('reduce methods'); + QUnit.module('lodash.flip'); - _.forEach(['reduce', 'reduceRight'], function(methodName) { - var array = [1, 2, 3], - func = _[methodName]; + (function() { + function fn() { + return slice.call(arguments); + } - test('`_.' + methodName + '` should reduce a collection to a single value', 1, function() { - var actual = func(['a', 'b', 'c'], function(accumulator, value) { - return accumulator + value; - }, ''); + QUnit.test('should flip arguments provided to `func`', function(assert) { + assert.expect(1); - equal(actual, methodName == 'reduce' ? 'abc' : 'cba'); + var flipped = _.flip(fn); + assert.deepEqual(flipped('a', 'b', 'c', 'd'), ['d', 'c', 'b', 'a']); }); + }()); - test('`_.' + methodName + '` should support the `thisArg` argument', 1, function() { - var actual = func(array, function(sum, num, index) { - return sum + this[index]; - }, 0, array); + /*--------------------------------------------------------------------------*/ - deepEqual(actual, 6); - }); + QUnit.module('lodash.flatMapDepth'); - test('`_.' + methodName + '` should return an unwrapped value when chaining', 1, function() { - if (!isNpm) { - var actual = _(array)[methodName](function(sum, num) { - return sum + num; - }); + (function() { + var array = [1, [2, [3, [4]], 5]]; - equal(actual, 6); - } - else { - skipTest(); - } + QUnit.test('should use a default `depth` of `1`', function(assert) { + assert.expect(1); + + assert.deepEqual(_.flatMapDepth(array, identity), [1, 2, [3, [4]], 5]); }); - test('`_.' + methodName + '` should support empty or falsey collections without an initial `accumulator` value', 1, function() { - var actual = [], - expected = _.map(empties, function() { return undefined; }); + QUnit.test('should use `_.identity` when `iteratee` is nullish', function(assert) { + assert.expect(1); - _.forEach(empties, function(value) { - try { - actual.push(func(value, noop)); - } catch(e) { } + var values = [, null, undefined], + expected = lodashStable.map(values, lodashStable.constant([1, 2, [3, [4]], 5])); + + var actual = lodashStable.map(values, function(value, index) { + return index ? _.flatMapDepth(array, value) : _.flatMapDepth(array); }); - deepEqual(actual, expected); + assert.deepEqual(actual, expected); }); - test('`_.' + methodName + '` should support empty or falsey collections with an initial `accumulator` value', 1, function() { - var expected = _.map(empties, function() { return 'x'; }); + QUnit.test('should treat a `depth` of < `1` as a shallow clone', function(assert) { + assert.expect(2); - var actual = _.map(empties, function(value) { - try { - return func(value, noop, 'x'); - } catch(e) { } + lodashStable.each([-1, 0], function(depth) { + assert.deepEqual(_.flatMapDepth(array, identity, depth), [1, [2, [3, [4]], 5]]); }); - - deepEqual(actual, expected); }); - test('`_.' + methodName + '` should handle an initial `accumulator` value of `undefined`', 1, function() { - var actual = func([], noop, undefined); - strictEqual(actual, undefined); + QUnit.test('should coerce `depth` to an integer', function(assert) { + assert.expect(1); + + assert.deepEqual(_.flatMapDepth(array, identity, 2.2), [1, 2, 3, [4], 5]); }); - }); + }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.reject'); + QUnit.module('flatMap methods'); - (function() { - test('should return elements the `callback` returns falsey for', 1, function() { - var actual = _.reject([1, 2, 3], function(num) { - return num % 2; - }); + lodashStable.each(['flatMap', 'flatMapDeep', 'flatMapDepth'], function(methodName) { + var func = _[methodName], + array = [1, 2, 3, 4]; - deepEqual(actual, [2]); - }); - }()); + function duplicate(n) { + return [n, n]; + } - /*--------------------------------------------------------------------------*/ + QUnit.test('`_.' + methodName + '` should map values in `array` to a new flattened array', function(assert) { + assert.expect(1); - QUnit.module('filter methods'); + var actual = func(array, duplicate), + expected = lodashStable.flatten(lodashStable.map(array, duplicate)); - _.forEach(['filter', 'reject'], function(methodNames) { - var func = _[methodNames]; + assert.deepEqual(actual, expected); + }); - test('`_.' + methodNames + '` should not modify the resulting value from within `callback`', 1, function() { - var actual = func([0], function(num, index, array) { - array[index] = 1; - return methodNames == 'filter'; - }); + QUnit.test('`_.' + methodName + '` should work with `_.property` shorthands', function(assert) { + assert.expect(1); - deepEqual(actual, [0]); + var objects = [{ 'a': [1, 2] }, { 'a': [3, 4] }]; + assert.deepEqual(func(objects, 'a'), array); }); - }); - /*--------------------------------------------------------------------------*/ + QUnit.test('`_.' + methodName + '` should iterate over own string keyed properties of objects', function(assert) { + assert.expect(1); - QUnit.module('lodash.remove'); + function Foo() { + this.a = [1, 2]; + } + Foo.prototype.b = [3, 4]; - (function() { - test('should modify the array and return removed elements', 2, function() { - var array = [1, 2, 3]; + var actual = func(new Foo, identity); + assert.deepEqual(actual, [1, 2]); + }); - var actual = _.remove(array, function(num) { - return num < 3; - }); + QUnit.test('`_.' + methodName + '` should use `_.identity` when `iteratee` is nullish', function(assert) { + assert.expect(2); - deepEqual(array, [3]); - deepEqual(actual, [1, 2]); - }); + var array = [[1, 2], [3, 4]], + object = { 'a': [1, 2], 'b': [3, 4] }, + values = [, null, undefined], + expected = lodashStable.map(values, lodashStable.constant([1, 2, 3, 4])); - test('should pass the correct `callback` arguments', 1, function() { - var args, - array = [1, 2, 3]; + lodashStable.each([array, object], function(collection) { + var actual = lodashStable.map(values, function(value, index) { + return index ? func(collection, value) : func(collection); + }); - _.remove(array, function() { - args || (args = slice.call(arguments)); + assert.deepEqual(actual, expected); }); - - deepEqual(args, [1, 0, array]); }); - test('should support the `thisArg` argument', 1, function() { - var array = [1, 2, 3]; + QUnit.test('`_.' + methodName + '` should accept a falsey `collection`', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(falsey, stubArray); - var actual = _.remove(array, function(num, index) { - return this[index] < 3; - }, array); + var actual = lodashStable.map(falsey, function(collection, index) { + try { + return index ? func(collection) : func(); + } catch (e) {} + }); - deepEqual(actual, [1, 2]); + assert.deepEqual(actual, expected); }); - test('should preserve holes in arrays', 2, function() { - var array = [1, 2, 3, 4]; - delete array[1]; - delete array[3]; + QUnit.test('`_.' + methodName + '` should treat number values for `collection` as empty', function(assert) { + assert.expect(1); - _.remove(array, function(num) { return num === 1; }); - equal(0 in array, false); - equal(2 in array, false); + assert.deepEqual(func(1), []); }); - test('should treat holes as `undefined`', 1, function() { - var array = [1, 2, 3]; - delete array[1]; + QUnit.test('`_.' + methodName + '` should work with objects with non-number length properties', function(assert) { + assert.expect(1); - _.remove(array, function(num) { return num == null; }); - deepEqual(array, [1, 3]); + var object = { 'length': [1, 2] }; + assert.deepEqual(func(object, identity), [1, 2]); }); - }()); + }); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.result'); + QUnit.module('lodash.flattenDepth'); (function() { - test('should resolve property values', 4, function() { - var object = { - 'a': 1, - 'b': 2, - 'c': function(){ return this.b; } - }; + var array = [1, [2, [3, [4]], 5]]; + + QUnit.test('should use a default `depth` of `1`', function(assert) { + assert.expect(1); - strictEqual(_.result(object, 'a'), 1); - strictEqual(_.result(object, 'b'), 2); - strictEqual(_.result(object, 'c'), 2); - strictEqual(_.result(object, 'd'), undefined); + assert.deepEqual(_.flattenDepth(array), [1, 2, [3, [4]], 5]); }); - test('should return `undefined` when provided a falsey `object` argument', 1, function() { - var actual = [], - expected = _.map(falsey, function() { return undefined; }); + QUnit.test('should treat a `depth` of < `1` as a shallow clone', function(assert) { + assert.expect(2); - _.forEach(falsey, function(value, index) { - try { - actual.push(index ? _.result(value) : _.result()); - } catch(e) { } + lodashStable.each([-1, 0], function(depth) { + assert.deepEqual(_.flattenDepth(array, depth), [1, [2, [3, [4]], 5]]); }); + }); + + QUnit.test('should coerce `depth` to an integer', function(assert) { + assert.expect(1); - deepEqual(actual, expected); + assert.deepEqual(_.flattenDepth(array, 2.2), [1, 2, 3, [4], 5]); }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.rest'); + QUnit.module('flatten methods'); (function() { - var array = [1, 2, 3]; + var array = [1, [2, [3, [4]], 5]], + methodNames = ['flatten', 'flattenDeep', 'flattenDepth']; - var objects = [ - { 'a': 2, 'b': 2 }, - { 'a': 1, 'b': 1 }, - { 'a': 0, 'b': 0 } - ]; - - test('should accept a falsey `array` argument', 1, function() { - var expected = _.map(falsey, function() { return []; }); + QUnit.test('should flatten `arguments` objects', function(assert) { + assert.expect(3); - var actual = _.map(falsey, function(value, index) { - try { - return index ? _.rest(value) : _.rest(); - } catch(e) { } - }); + var array = [args, [args]]; - deepEqual(actual, expected); + assert.deepEqual(_.flatten(array), [1, 2, 3, args]); + assert.deepEqual(_.flattenDeep(array), [1, 2, 3, 1, 2, 3]); + assert.deepEqual(_.flattenDepth(array, 2), [1, 2, 3, 1, 2, 3]); }); - test('should exclude the first element', 1, function() { - deepEqual(_.rest(array), [2, 3]); - }); + QUnit.test('should treat sparse arrays as dense', function(assert) { + assert.expect(6); - test('should exclude the first two elements', 1, function() { - deepEqual(_.rest(array, 2), [3]); - }); + var array = [[1, 2, 3], Array(3)], + expected = [1, 2, 3]; - test('should return all elements when `n` < `1`', 3, function() { - _.forEach([0, -1, -2], function(n) { - deepEqual(_.rest(array, n), [1, 2, 3]); - }); - }); + expected.push(undefined, undefined, undefined); - test('should return an empty array when `n` >= `array.length`', 2, function() { - _.forEach([3, 4], function(n) { - deepEqual(_.rest(array, n), []); + lodashStable.each(methodNames, function(methodName) { + var actual = _[methodName](array); + assert.deepEqual(actual, expected); + assert.ok('4' in actual); }); }); - test('should return an empty when querying empty arrays', 1, function() { - deepEqual(_.rest([]), []); - }); + QUnit.test('should flatten objects with a truthy `Symbol.isConcatSpreadable` value', function(assert) { + assert.expect(1); - test('should work when used as `callback` for `_.map`', 1, function() { - var array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]], - actual = _.map(array, _.rest); + if (Symbol && Symbol.isConcatSpreadable) { + var object = { '0': 'a', 'length': 1 }, + array = [object], + expected = lodashStable.map(methodNames, lodashStable.constant(['a'])); - deepEqual(actual, [[2, 3], [5, 6], [8, 9]]); - }); + object[Symbol.isConcatSpreadable] = true; - test('should work with a `callback`', 1, function() { - var actual = _.rest(array, function(num) { - return num < 3; - }); + var actual = lodashStable.map(methodNames, function(methodName) { + return _[methodName](array); + }); - deepEqual(actual, [3]); + assert.deepEqual(actual, expected); + } + else { + skipAssert(assert); + } }); - test('should pass the correct `callback` arguments', 1, function() { - var args; + QUnit.test('should work with extremely large arrays', function(assert) { + assert.expect(3); - _.rest(array, function() { - args || (args = slice.call(arguments)); + lodashStable.times(3, function(index) { + var expected = Array(5e5); + try { + var func = _.flatten; + if (index == 1) { + func = _.flattenDeep; + } else if (index == 2) { + func = _.flattenDepth; + } + assert.deepEqual(func([expected]), expected); + } catch (e) { + assert.ok(false, e.message); + } }); - - deepEqual(args, [1, 0, array]); }); - test('supports the `thisArg` argument', 1, function() { - var actual = _.rest(array, function(num, index) { - return this[index] < 3; - }, array); + QUnit.test('should work with empty arrays', function(assert) { + assert.expect(3); - deepEqual(actual, [3]); - }); + var array = [[], [[]], [[], [[[]]]]]; - test('should work with an object for `callback`', 1, function() { - deepEqual(_.rest(objects, { 'b': 2 }), objects.slice(-2)); + assert.deepEqual(_.flatten(array), [[], [], [[[]]]]); + assert.deepEqual(_.flattenDeep(array), []); + assert.deepEqual(_.flattenDepth(array, 2), [[[]]]); }); - test('should work with a string for `callback`', 1, function() { - deepEqual(_.rest(objects, 'b'), objects.slice(-1)); - }); + QUnit.test('should support flattening of nested arrays', function(assert) { + assert.expect(3); - test('should be aliased', 2, function() { - strictEqual(_.drop, _.rest); - strictEqual(_.tail, _.rest); + assert.deepEqual(_.flatten(array), [1, 2, [3, [4]], 5]); + assert.deepEqual(_.flattenDeep(array), [1, 2, 3, 4, 5]); + assert.deepEqual(_.flattenDepth(array, 2), [1, 2, 3, [4], 5]); }); - }()); + + QUnit.test('should return an empty array for non array-like objects', function(assert) { + assert.expect(3); + + var expected = [], + nonArray = { '0': 'a' }; + + assert.deepEqual(_.flatten(nonArray), expected); + assert.deepEqual(_.flattenDeep(nonArray), expected); + assert.deepEqual(_.flattenDepth(nonArray, 2), expected); + }); + + QUnit.test('should return a wrapped value when chaining', function(assert) { + assert.expect(6); + + if (!isNpm) { + var wrapped = _(array), + actual = wrapped.flatten(); + + assert.ok(actual instanceof _); + assert.deepEqual(actual.value(), [1, 2, [3, [4]], 5]); + + actual = wrapped.flattenDeep(); + + assert.ok(actual instanceof _); + assert.deepEqual(actual.value(), [1, 2, 3, 4, 5]); + + actual = wrapped.flattenDepth(2); + + assert.ok(actual instanceof _); + assert.deepEqual(actual.value(), [1, 2, 3, [4], 5]); + } + else { + skipAssert(assert, 6); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('flow methods'); + + lodashStable.each(['flow', 'flowRight'], function(methodName) { + var func = _[methodName], + isFlow = methodName == 'flow'; + + QUnit.test('`_.' + methodName + '` should supply each function with the return value of the previous', function(assert) { + assert.expect(1); + + var fixed = function(n) { return n.toFixed(1); }, + combined = isFlow ? func(add, square, fixed) : func(fixed, square, add); + + assert.strictEqual(combined(1, 2), '9.0'); + }); + + QUnit.test('`_.' + methodName + '` should return a new function', function(assert) { + assert.expect(1); + + assert.notStrictEqual(func(noop), noop); + }); + + QUnit.test('`_.' + methodName + '` should return an identity function when no arguments are given', function(assert) { + assert.expect(6); + + _.times(2, function(index) { + try { + var combined = index ? func([]) : func(); + assert.strictEqual(combined('a'), 'a'); + } catch (e) { + assert.ok(false, e.message); + } + assert.strictEqual(combined.length, 0); + assert.notStrictEqual(combined, identity); + }); + }); + + QUnit.test('`_.' + methodName + '` should work with a curried function and `_.head`', function(assert) { + assert.expect(1); + + var curried = _.curry(identity); + + var combined = isFlow + ? func(_.head, curried) + : func(curried, _.head); + + assert.strictEqual(combined([1]), 1); + }); + + QUnit.test('`_.' + methodName + '` should support shortcut fusion', function(assert) { + assert.expect(6); + + var filterCount, + mapCount, + array = lodashStable.range(LARGE_ARRAY_SIZE), + iteratee = function(value) { mapCount++; return square(value); }, + predicate = function(value) { filterCount++; return isEven(value); }; + + lodashStable.times(2, function(index) { + var filter1 = _.filter, + filter2 = _.curry(_.rearg(_.ary(_.filter, 2), 1, 0), 2), + filter3 = (_.filter = index ? filter2 : filter1, filter2(predicate)); + + var map1 = _.map, + map2 = _.curry(_.rearg(_.ary(_.map, 2), 1, 0), 2), + map3 = (_.map = index ? map2 : map1, map2(iteratee)); + + var take1 = _.take, + take2 = _.curry(_.rearg(_.ary(_.take, 2), 1, 0), 2), + take3 = (_.take = index ? take2 : take1, take2(2)); + + var combined = isFlow + ? func(map3, filter3, _.compact, take3) + : func(take3, _.compact, filter3, map3); + + filterCount = mapCount = 0; + assert.deepEqual(combined(array), [4, 16]); + + if (!isNpm && WeakMap && WeakMap.name) { + assert.strictEqual(filterCount, 5, 'filterCount'); + assert.strictEqual(mapCount, 5, 'mapCount'); + } + else { + skipAssert(assert, 2); + } + _.filter = filter1; + _.map = map1; + _.take = take1; + }); + }); + + QUnit.test('`_.' + methodName + '` should work with curried functions with placeholders', function(assert) { + assert.expect(1); + + var curried = _.curry(_.ary(_.map, 2), 2), + getProp = curried(curried.placeholder, 'a'), + objects = [{ 'a': 1 }, { 'a': 2 }, { 'a': 1 }]; + + var combined = isFlow + ? func(getProp, _.uniq) + : func(_.uniq, getProp); + + assert.deepEqual(combined(objects), [1, 2]); + }); + + QUnit.test('`_.' + methodName + '` should return a wrapped value when chaining', function(assert) { + assert.expect(1); + + if (!isNpm) { + var wrapped = _(noop)[methodName](); + assert.ok(wrapped instanceof _); + } + else { + skipAssert(assert); + } + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.forEach'); + + (function() { + QUnit.test('should be aliased', function(assert) { + assert.expect(1); + + assert.strictEqual(_.each, _.forEach); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.forEachRight'); + + (function() { + QUnit.test('should be aliased', function(assert) { + assert.expect(1); + + assert.strictEqual(_.eachRight, _.forEachRight); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('forIn methods'); + + lodashStable.each(['forIn', 'forInRight'], function(methodName) { + var func = _[methodName]; + + QUnit.test('`_.' + methodName + '` iterates over inherited string keyed properties', function(assert) { + assert.expect(1); + + function Foo() { + this.a = 1; + } + Foo.prototype.b = 2; + + var keys = []; + func(new Foo, function(value, key) { keys.push(key); }); + assert.deepEqual(keys.sort(), ['a', 'b']); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('forOwn methods'); + + lodashStable.each(['forOwn', 'forOwnRight'], function(methodName) { + var func = _[methodName]; + + QUnit.test('`_.' + methodName + '` should iterate over `length` properties', function(assert) { + assert.expect(1); + + var object = { '0': 'zero', '1': 'one', 'length': 2 }, + props = []; + + func(object, function(value, prop) { props.push(prop); }); + assert.deepEqual(props.sort(), ['0', '1', 'length']); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('iteration methods'); + + (function() { + var methods = [ + '_baseEach', + 'countBy', + 'every', + 'filter', + 'find', + 'findIndex', + 'findKey', + 'findLast', + 'findLastIndex', + 'findLastKey', + 'forEach', + 'forEachRight', + 'forIn', + 'forInRight', + 'forOwn', + 'forOwnRight', + 'groupBy', + 'keyBy', + 'map', + 'mapKeys', + 'mapValues', + 'maxBy', + 'minBy', + 'omitBy', + 'partition', + 'pickBy', + 'reject', + 'some' + ]; + + var arrayMethods = [ + 'findIndex', + 'findLastIndex', + 'maxBy', + 'minBy' + ]; + + var collectionMethods = [ + '_baseEach', + 'countBy', + 'every', + 'filter', + 'find', + 'findLast', + 'forEach', + 'forEachRight', + 'groupBy', + 'keyBy', + 'map', + 'partition', + 'reduce', + 'reduceRight', + 'reject', + 'some' + ]; + + var forInMethods = [ + 'forIn', + 'forInRight', + 'omitBy', + 'pickBy' + ]; + + var iterationMethods = [ + '_baseEach', + 'forEach', + 'forEachRight', + 'forIn', + 'forInRight', + 'forOwn', + 'forOwnRight' + ]; + + var objectMethods = [ + 'findKey', + 'findLastKey', + 'forIn', + 'forInRight', + 'forOwn', + 'forOwnRight', + 'mapKeys', + 'mapValues', + 'omitBy', + 'pickBy' + ]; + + var rightMethods = [ + 'findLast', + 'findLastIndex', + 'findLastKey', + 'forEachRight', + 'forInRight', + 'forOwnRight' + ]; + + var unwrappedMethods = [ + 'each', + 'eachRight', + 'every', + 'find', + 'findIndex', + 'findKey', + 'findLast', + 'findLastIndex', + 'findLastKey', + 'forEach', + 'forEachRight', + 'forIn', + 'forInRight', + 'forOwn', + 'forOwnRight', + 'max', + 'maxBy', + 'min', + 'minBy', + 'some' + ]; + + lodashStable.each(methods, function(methodName) { + var array = [1, 2, 3], + func = _[methodName], + isBy = /(^partition|By)$/.test(methodName), + isFind = /^find/.test(methodName), + isOmitPick = /^(?:omit|pick)By$/.test(methodName), + isSome = methodName == 'some'; + + QUnit.test('`_.' + methodName + '` should provide correct iteratee arguments', function(assert) { + assert.expect(1); + + if (func) { + var args, + expected = [1, 0, array]; + + func(array, function() { + args || (args = slice.call(arguments)); + }); + + if (lodashStable.includes(rightMethods, methodName)) { + expected[0] = 3; + expected[1] = 2; + } + if (lodashStable.includes(objectMethods, methodName)) { + expected[1] += ''; + } + if (isBy) { + expected.length = isOmitPick ? 2 : 1; + } + assert.deepEqual(args, expected); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.' + methodName + '` should treat sparse arrays as dense', function(assert) { + assert.expect(1); + + if (func) { + var array = [1]; + array[2] = 3; + + var expected = lodashStable.includes(objectMethods, methodName) + ? [[1, '0', array], [undefined, '1', array], [3, '2', array]] + : [[1, 0, array], [undefined, 1, array], [3, 2, array]]; + + if (isBy) { + expected = lodashStable.map(expected, function(args) { + return args.slice(0, isOmitPick ? 2 : 1); + }); + } + else if (lodashStable.includes(objectMethods, methodName)) { + expected = lodashStable.map(expected, function(args) { + args[1] += ''; + return args; + }); + } + if (lodashStable.includes(rightMethods, methodName)) { + expected.reverse(); + } + var argsList = []; + func(array, function() { + argsList.push(slice.call(arguments)); + return !(isFind || isSome); + }); + + assert.deepEqual(argsList, expected); + } + else { + skipAssert(assert); + } + }); + }); + + lodashStable.each(lodashStable.difference(methods, objectMethods), function(methodName) { + var array = [1, 2, 3], + func = _[methodName], + isEvery = methodName == 'every'; + + array.a = 1; + + QUnit.test('`_.' + methodName + '` should not iterate custom properties on arrays', function(assert) { + assert.expect(1); + + if (func) { + var keys = []; + func(array, function(value, key) { + keys.push(key); + return isEvery; + }); + + assert.notOk(lodashStable.includes(keys, 'a')); + } + else { + skipAssert(assert); + } + }); + }); + + lodashStable.each(lodashStable.difference(methods, unwrappedMethods), function(methodName) { + var array = [1, 2, 3], + isBaseEach = methodName == '_baseEach'; + + QUnit.test('`_.' + methodName + '` should return a wrapped value when implicitly chaining', function(assert) { + assert.expect(1); + + if (!(isBaseEach || isNpm)) { + var wrapped = _(array)[methodName](noop); + assert.ok(wrapped instanceof _); + } + else { + skipAssert(assert); + } + }); + }); + + lodashStable.each(unwrappedMethods, function(methodName) { + var array = [1, 2, 3]; + + QUnit.test('`_.' + methodName + '` should return an unwrapped value when implicitly chaining', function(assert) { + assert.expect(1); + + if (!isNpm) { + var actual = _(array)[methodName](noop); + assert.notOk(actual instanceof _); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.' + methodName + '` should return a wrapped value when explicitly chaining', function(assert) { + assert.expect(2); + + if (!isNpm) { + var wrapped = _(array).chain(), + actual = wrapped[methodName](noop); + + assert.ok(actual instanceof _); + assert.notStrictEqual(actual, wrapped); + } + else { + skipAssert(assert, 2); + } + }); + }); + + lodashStable.each(lodashStable.difference(methods, arrayMethods, forInMethods), function(methodName) { + var func = _[methodName]; + + QUnit.test('`_.' + methodName + '` iterates over own string keyed properties of objects', function(assert) { + assert.expect(1); + + function Foo() { + this.a = 1; + } + Foo.prototype.b = 2; + + if (func) { + var values = []; + func(new Foo, function(value) { values.push(value); }); + assert.deepEqual(values, [1]); + } + else { + skipAssert(assert); + } + }); + }); + + lodashStable.each(iterationMethods, function(methodName) { + var array = [1, 2, 3], + func = _[methodName]; + + QUnit.test('`_.' + methodName + '` should return the collection', function(assert) { + assert.expect(1); + + if (func) { + assert.strictEqual(func(array, Boolean), array); + } + else { + skipAssert(assert); + } + }); + }); + + lodashStable.each(collectionMethods, function(methodName) { + var func = _[methodName]; + + QUnit.test('`_.' + methodName + '` should use `isArrayLike` to determine whether a value is array-like', function(assert) { + assert.expect(3); + + if (func) { + var isIteratedAsObject = function(object) { + var result = false; + func(object, function() { result = true; }, 0); + return result; + }; + + var values = [-1, '1', 1.1, Object(1), MAX_SAFE_INTEGER + 1], + expected = lodashStable.map(values, stubTrue); + + var actual = lodashStable.map(values, function(length) { + return isIteratedAsObject({ 'length': length }); + }); + + var Foo = function(a) {}; + Foo.a = 1; + + assert.deepEqual(actual, expected); + assert.ok(isIteratedAsObject(Foo)); + assert.notOk(isIteratedAsObject({ 'length': 0 })); + } + else { + skipAssert(assert, 3); + } + }); + }); + + lodashStable.each(methods, function(methodName) { + var func = _[methodName], + isFind = /^find/.test(methodName), + isSome = methodName == 'some', + isReduce = /^reduce/.test(methodName); + + QUnit.test('`_.' + methodName + '` should ignore changes to `length`', function(assert) { + assert.expect(1); + + if (func) { + var count = 0, + array = [1]; + + func(array, function() { + if (++count == 1) { + array.push(2); + } + return !(isFind || isSome); + }, isReduce ? array : null); + + assert.strictEqual(count, 1); + } + else { + skipAssert(assert); + } + }); + }); + + lodashStable.each(lodashStable.difference(lodashStable.union(methods, collectionMethods), arrayMethods), function(methodName) { + var func = _[methodName], + isFind = /^find/.test(methodName), + isSome = methodName == 'some', + isReduce = /^reduce/.test(methodName); + + QUnit.test('`_.' + methodName + '` should ignore added `object` properties', function(assert) { + assert.expect(1); + + if (func) { + var count = 0, + object = { 'a': 1 }; + + func(object, function() { + if (++count == 1) { + object.b = 2; + } + return !(isFind || isSome); + }, isReduce ? object : null); + + assert.strictEqual(count, 1); + } + else { + skipAssert(assert); + } + }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('object assignments'); + + lodashStable.each(['assign', 'assignIn', 'defaults', 'defaultsDeep', 'merge'], function(methodName) { + var func = _[methodName], + isAssign = methodName == 'assign', + isDefaults = /^defaults/.test(methodName); + + QUnit.test('`_.' + methodName + '` should coerce primitives to objects', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(primitives, function(value) { + var object = Object(value); + object.a = 1; + return object; + }); + + var actual = lodashStable.map(primitives, function(value) { + return func(value, { 'a': 1 }); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should assign own ' + (isAssign ? '' : 'and inherited ') + 'string keyed source properties', function(assert) { + assert.expect(1); + + function Foo() { + this.a = 1; + } + Foo.prototype.b = 2; + + var expected = isAssign ? { 'a': 1 } : { 'a': 1, 'b': 2 }; + assert.deepEqual(func({}, new Foo), expected); + }); + + QUnit.test('`_.' + methodName + '` should not skip a trailing function source', function(assert) { + assert.expect(1); + + function fn() {} + fn.b = 2; + + assert.deepEqual(func({}, { 'a': 1 }, fn), { 'a': 1, 'b': 2 }); + }); + + QUnit.test('`_.' + methodName + '` should not error on nullish sources', function(assert) { + assert.expect(1); + + try { + assert.deepEqual(func({ 'a': 1 }, undefined, { 'b': 2 }, null), { 'a': 1, 'b': 2 }); + } catch (e) { + assert.ok(false, e.message); + } + }); + + QUnit.test('`_.' + methodName + '` should create an object when `object` is nullish', function(assert) { + assert.expect(2); + + var source = { 'a': 1 }, + values = [null, undefined], + expected = lodashStable.map(values, stubTrue); + + var actual = lodashStable.map(values, function(value) { + var object = func(value, source); + return object !== source && lodashStable.isEqual(object, source); + }); + + assert.deepEqual(actual, expected); + + actual = lodashStable.map(values, function(value) { + return lodashStable.isEqual(func(value), {}); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should work as an iteratee for methods like `_.reduce`', function(assert) { + assert.expect(2); + + var array = [{ 'a': 1 }, { 'b': 2 }, { 'c': 3 }], + expected = { 'a': isDefaults ? 0 : 1, 'b': 2, 'c': 3 }; + + function fn() {}; + fn.a = array[0]; + fn.b = array[1]; + fn.c = array[2]; + + assert.deepEqual(lodashStable.reduce(array, func, { 'a': 0 }), expected); + assert.deepEqual(lodashStable.reduce(fn, func, { 'a': 0 }), expected); + }); + + QUnit.test('`_.' + methodName + '` should not return the existing wrapped value when chaining', function(assert) { + assert.expect(1); + + if (!isNpm) { + var wrapped = _({ 'a': 1 }), + actual = wrapped[methodName]({ 'b': 2 }); + + assert.notStrictEqual(actual, wrapped); + } + else { + skipAssert(assert); + } + }); + }); + + lodashStable.each(['assign', 'assignIn', 'merge'], function(methodName) { + var func = _[methodName]; + + QUnit.test('`_.' + methodName + '` should not treat `object` as `source`', function(assert) { + assert.expect(1); + + function Foo() {} + Foo.prototype.a = 1; + + var actual = func(new Foo, { 'b': 2 }); + assert.notOk(_.has(actual, 'a')); + }); + }); + + lodashStable.each(['assign', 'assignIn', 'assignInWith', 'assignWith', 'defaults', 'defaultsDeep', 'merge', 'mergeWith'], function(methodName) { + var func = _[methodName]; + + QUnit.test('`_.' + methodName + '` should not assign values that are the same as their destinations', function(assert) { + assert.expect(4); + + lodashStable.each(['a', ['a'], { 'a': 1 }, NaN], function(value) { + var object = {}, + pass = true; + + defineProperty(object, 'a', { + 'configurable': true, + 'enumerable': true, + 'get': lodashStable.constant(value), + 'set': function() { pass = false; } + }); + + func(object, { 'a': value }); + assert.ok(pass); + }); + }); + }); + + lodashStable.each(['assignWith', 'assignInWith', 'mergeWith'], function(methodName) { + var func = _[methodName], + isMergeWith = methodName == 'mergeWith'; + + QUnit.test('`_.' + methodName + '` should provide correct `customizer` arguments', function(assert) { + assert.expect(3); + + var args, + object = { 'a': 1 }, + source = { 'a': 2 }, + expected = lodashStable.map([1, 2, 'a', object, source], lodashStable.cloneDeep); + + func(object, source, function() { + args || (args = lodashStable.map(slice.call(arguments, 0, 5), lodashStable.cloneDeep)); + }); + + assert.deepEqual(args, expected, 'primitive values'); + + var argsList = [], + objectValue = [1, 2], + sourceValue = { 'b': 2 }; + + object = { 'a': objectValue }; + source = { 'a': sourceValue }; + expected = [lodashStable.map([objectValue, sourceValue, 'a', object, source], lodashStable.cloneDeep)]; + + if (isMergeWith) { + expected.push(lodashStable.map([undefined, 2, 'b', objectValue, sourceValue], lodashStable.cloneDeep)); + } + func(object, source, function() { + argsList.push(lodashStable.map(slice.call(arguments, 0, 5), lodashStable.cloneDeep)); + }); + + assert.deepEqual(argsList, expected, 'object values'); + + args = undefined; + object = { 'a': 1 }; + source = { 'b': 2 }; + expected = lodashStable.map([undefined, 2, 'b', object, source], lodashStable.cloneDeep); + + func(object, source, function() { + args || (args = lodashStable.map(slice.call(arguments, 0, 5), lodashStable.cloneDeep)); + }); + + assert.deepEqual(args, expected, 'undefined properties'); + }); + + QUnit.test('`_.' + methodName + '` should not treat the second argument as a `customizer` callback', function(assert) { + assert.expect(2); + + function callback() {} + callback.b = 2; + + var actual = func({ 'a': 1 }, callback); + assert.deepEqual(actual, { 'a': 1, 'b': 2 }); + + actual = func({ 'a': 1 }, callback, { 'c': 3 }); + assert.deepEqual(actual, { 'a': 1, 'b': 2, 'c': 3 }); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('exit early'); + + lodashStable.each(['_baseEach', 'forEach', 'forEachRight', 'forIn', 'forInRight', 'forOwn', 'forOwnRight', 'transform'], function(methodName) { + var func = _[methodName]; + + QUnit.test('`_.' + methodName + '` can exit early when iterating arrays', function(assert) { + assert.expect(1); + + if (func) { + var array = [1, 2, 3], + values = []; + + func(array, function(value, other) { + values.push(lodashStable.isArray(value) ? other : value); + return false; + }); + + assert.deepEqual(values, [lodashStable.endsWith(methodName, 'Right') ? 3 : 1]); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.' + methodName + '` can exit early when iterating objects', function(assert) { + assert.expect(1); + + if (func) { + var object = { 'a': 1, 'b': 2, 'c': 3 }, + values = []; + + func(object, function(value, other) { + values.push(lodashStable.isArray(value) ? other : value); + return false; + }); + + assert.strictEqual(values.length, 1); + } + else { + skipAssert(assert); + } + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('`__proto__` property bugs'); + + (function() { + QUnit.test('should work with the "__proto__" key in internal data objects', function(assert) { + assert.expect(4); + + var stringLiteral = '__proto__', + stringObject = Object(stringLiteral), + expected = [stringLiteral, stringObject]; + + var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, function(count) { + return isEven(count) ? stringLiteral : stringObject; + }); + + assert.deepEqual(_.difference(largeArray, largeArray), []); + assert.deepEqual(_.intersection(largeArray, largeArray), expected); + assert.deepEqual(_.uniq(largeArray), expected); + assert.deepEqual(_.without.apply(_, [largeArray].concat(largeArray)), []); + }); + + QUnit.test('should treat "__proto__" as a regular key in assignments', function(assert) { + assert.expect(2); + + var methods = [ + 'assign', + 'assignIn', + 'defaults', + 'defaultsDeep', + 'merge' + ]; + + var source = create(null); + source.__proto__ = []; + + var expected = lodashStable.map(methods, stubFalse); + + var actual = lodashStable.map(methods, function(methodName) { + var result = _[methodName]({}, source); + return result instanceof Array; + }); + + assert.deepEqual(actual, expected); + + actual = _.groupBy([{ 'a': '__proto__' }], 'a'); + assert.notOk(actual instanceof Array); + }); + + QUnit.test('should not merge "__proto__" properties', function(assert) { + assert.expect(1); + + if (JSON) { + _.merge({}, JSON.parse('{"__proto__":{"a":1}}')); + + var actual = 'a' in objectProto; + delete objectProto.a; + + assert.notOk(actual); + } else { + skipAssert(assert); + } + }); + + QUnit.test('should not indirectly merge builtin prototype properties', function(assert) { + assert.expect(2); + + _.merge({}, { 'toString': { 'constructor': { 'prototype': { 'a': 1 } } } }); + + var actual = 'a' in funcProto; + delete funcProto.a; + + assert.notOk(actual); + + _.merge({}, { 'constructor': { 'prototype': { 'a': 1 } } }); + + actual = 'a' in objectProto; + delete objectProto.a; + + assert.notOk(actual); + }); + + QUnit.test('should not indirectly merge `Object` properties', function(assert) { + assert.expect(1); + + _.merge({}, { 'constructor': { 'a': 1 } }); + + var actual = 'a' in Object; + delete Object.a; + + assert.notOk(actual); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.fromPairs'); + + (function() { + QUnit.test('should accept a two dimensional array', function(assert) { + assert.expect(1); + + var array = [['a', 1], ['b', 2]], + object = { 'a': 1, 'b': 2 }, + actual = _.fromPairs(array); + + assert.deepEqual(actual, object); + }); + + QUnit.test('should accept a falsey `array`', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(falsey, stubObject); + + var actual = lodashStable.map(falsey, function(array, index) { + try { + return index ? _.fromPairs(array) : _.fromPairs(); + } catch (e) {} + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should not support deep paths', function(assert) { + assert.expect(1); + + var actual = _.fromPairs([['a.b', 1]]); + assert.deepEqual(actual, { 'a.b': 1 }); + }); + + QUnit.test('should support consuming the return value of `_.toPairs`', function(assert) { + assert.expect(1); + + var object = { 'a.b': 1 }; + assert.deepEqual(_.fromPairs(_.toPairs(object)), object); + }); + + QUnit.test('should work in a lazy sequence', function(assert) { + assert.expect(1); + + if (!isNpm) { + var array = lodashStable.times(LARGE_ARRAY_SIZE, function(index) { + return ['key' + index, index]; + }); + + var actual = _(array).fromPairs().map(square).filter(isEven).take().value(); + + assert.deepEqual(actual, _.take(_.filter(_.map(_.fromPairs(array), square), isEven))); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.functions'); + + (function() { + QUnit.test('should return the function names of an object', function(assert) { + assert.expect(1); + + var object = { 'a': 'a', 'b': identity, 'c': /x/, 'd': noop }, + actual = _.functions(object).sort(); + + assert.deepEqual(actual, ['b', 'd']); + }); + + QUnit.test('should not include inherited functions', function(assert) { + assert.expect(1); + + function Foo() { + this.a = identity; + this.b = 'b'; + } + Foo.prototype.c = noop; + + assert.deepEqual(_.functions(new Foo), ['a']); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.groupBy'); + + (function() { + var array = [6.1, 4.2, 6.3]; + + QUnit.test('should transform keys by `iteratee`', function(assert) { + assert.expect(1); + + var actual = _.groupBy(array, Math.floor); + assert.deepEqual(actual, { '4': [4.2], '6': [6.1, 6.3] }); + }); + + QUnit.test('should use `_.identity` when `iteratee` is nullish', function(assert) { + assert.expect(1); + + var array = [6, 4, 6], + values = [, null, undefined], + expected = lodashStable.map(values, lodashStable.constant({ '4': [4], '6': [6, 6] })); + + var actual = lodashStable.map(values, function(value, index) { + return index ? _.groupBy(array, value) : _.groupBy(array); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should work with `_.property` shorthands', function(assert) { + assert.expect(1); + + var actual = _.groupBy(['one', 'two', 'three'], 'length'); + assert.deepEqual(actual, { '3': ['one', 'two'], '5': ['three'] }); + }); + + QUnit.test('should only add values to own, not inherited, properties', function(assert) { + assert.expect(2); + + var actual = _.groupBy(array, function(n) { + return Math.floor(n) > 4 ? 'hasOwnProperty' : 'constructor'; + }); + + assert.deepEqual(actual.constructor, [4.2]); + assert.deepEqual(actual.hasOwnProperty, [6.1, 6.3]); + }); + + QUnit.test('should work with a number for `iteratee`', function(assert) { + assert.expect(2); + + var array = [ + [1, 'a'], + [2, 'a'], + [2, 'b'] + ]; + + assert.deepEqual(_.groupBy(array, 0), { '1': [[1, 'a']], '2': [[2, 'a'], [2, 'b']] }); + assert.deepEqual(_.groupBy(array, 1), { 'a': [[1, 'a'], [2, 'a']], 'b': [[2, 'b']] }); + }); + + QUnit.test('should work with an object for `collection`', function(assert) { + assert.expect(1); + + var actual = _.groupBy({ 'a': 6.1, 'b': 4.2, 'c': 6.3 }, Math.floor); + assert.deepEqual(actual, { '4': [4.2], '6': [6.1, 6.3] }); + }); + + QUnit.test('should work in a lazy sequence', function(assert) { + assert.expect(1); + + if (!isNpm) { + var array = lodashStable.range(LARGE_ARRAY_SIZE).concat( + lodashStable.range(Math.floor(LARGE_ARRAY_SIZE / 2), LARGE_ARRAY_SIZE), + lodashStable.range(Math.floor(LARGE_ARRAY_SIZE / 1.5), LARGE_ARRAY_SIZE) + ); + + var iteratee = function(value) { value.push(value[0]); return value; }, + predicate = function(value) { return isEven(value[0]); }, + actual = _(array).groupBy().map(iteratee).filter(predicate).take().value(); + + assert.deepEqual(actual, _.take(_.filter(lodashStable.map(_.groupBy(array), iteratee), predicate))); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.gt'); + + (function() { + QUnit.test('should return `true` if `value` > `other`', function(assert) { + assert.expect(2); + + assert.strictEqual(_.gt(3, 1), true); + assert.strictEqual(_.gt('def', 'abc'), true); + }); + + QUnit.test('should return `false` if `value` is <= `other`', function(assert) { + assert.expect(4); + + assert.strictEqual(_.gt(1, 3), false); + assert.strictEqual(_.gt(3, 3), false); + assert.strictEqual(_.gt('abc', 'def'), false); + assert.strictEqual(_.gt('def', 'def'), false); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.gte'); + + (function() { + QUnit.test('should return `true` if `value` >= `other`', function(assert) { + assert.expect(4); + + assert.strictEqual(_.gte(3, 1), true); + assert.strictEqual(_.gte(3, 3), true); + assert.strictEqual(_.gte('def', 'abc'), true); + assert.strictEqual(_.gte('def', 'def'), true); + }); + + QUnit.test('should return `false` if `value` is less than `other`', function(assert) { + assert.expect(2); + + assert.strictEqual(_.gte(1, 3), false); + assert.strictEqual(_.gte('abc', 'def'), false); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('has methods'); + + lodashStable.each(['has', 'hasIn'], function(methodName) { + var func = _[methodName], + isHas = methodName == 'has', + sparseArgs = toArgs([1]), + sparseArray = Array(1), + sparseString = Object('a'); + + delete sparseArgs[0]; + delete sparseString[0]; + + QUnit.test('`_.' + methodName + '` should check for own properties', function(assert) { + assert.expect(2); + + var object = { 'a': 1 }; + + lodashStable.each(['a', ['a']], function(path) { + assert.strictEqual(func(object, path), true); + }); + }); + + QUnit.test('`_.' + methodName + '` should not use the `hasOwnProperty` method of `object`', function(assert) { + assert.expect(1); + + var object = { 'hasOwnProperty': null, 'a': 1 }; + assert.strictEqual(func(object, 'a'), true); + }); + + QUnit.test('`_.' + methodName + '` should support deep paths', function(assert) { + assert.expect(4); + + var object = { 'a': { 'b': 2 } }; + + lodashStable.each(['a.b', ['a', 'b']], function(path) { + assert.strictEqual(func(object, path), true); + }); + + lodashStable.each(['a.a', ['a', 'a']], function(path) { + assert.strictEqual(func(object, path), false); + }); + }); + + QUnit.test('`_.' + methodName + '` should coerce `path` to a string', function(assert) { + assert.expect(2); + + function fn() {} + fn.toString = lodashStable.constant('fn'); + + var object = { 'null': 1 , 'undefined': 2, 'fn': 3, '[object Object]': 4 }, + paths = [null, undefined, fn, {}], + expected = lodashStable.map(paths, stubTrue); + + lodashStable.times(2, function(index) { + var actual = lodashStable.map(paths, function(path) { + return func(object, index ? [path] : path); + }); + + assert.deepEqual(actual, expected); + }); + }); + + QUnit.test('`_.' + methodName + '` should work with `arguments` objects', function(assert) { + assert.expect(1); + + assert.strictEqual(func(args, 1), true); + }); + + QUnit.test('`_.' + methodName + '` should work with a non-string `path`', function(assert) { + assert.expect(2); + + var array = [1, 2, 3]; + + lodashStable.each([1, [1]], function(path) { + assert.strictEqual(func(array, path), true); + }); + }); + + QUnit.test('`_.' + methodName + '` should preserve the sign of `0`', function(assert) { + assert.expect(1); + + var object = { '-0': 'a', '0': 'b' }, + props = [-0, Object(-0), 0, Object(0)], + expected = lodashStable.map(props, stubTrue); + + var actual = lodashStable.map(props, function(key) { + return func(object, key); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should work with a symbol `path`', function(assert) { + assert.expect(2); + + function Foo() {} + + if (Symbol) { + Foo.prototype[symbol] = 1; + + var symbol2 = Symbol('b'); + defineProperty(Foo.prototype, symbol2, { + 'configurable': true, + 'enumerable': false, + 'writable': true, + 'value': 2 + }); + + var object = isHas ? Foo.prototype : new Foo; + assert.strictEqual(func(object, symbol), true); + assert.strictEqual(func(object, symbol2), true); + } + else { + skipAssert(assert, 2); + } + }); + + QUnit.test('`_.' + methodName + '` should check for a key over a path', function(assert) { + assert.expect(2); + + var object = { 'a.b': 1 }; + + lodashStable.each(['a.b', ['a.b']], function(path) { + assert.strictEqual(func(object, path), true); + }); + }); + + QUnit.test('`_.' + methodName + '` should return `true` for indexes of sparse values', function(assert) { + assert.expect(1); + + var values = [sparseArgs, sparseArray, sparseString], + expected = lodashStable.map(values, stubTrue); + + var actual = lodashStable.map(values, function(value) { + return func(value, 0); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should return `true` for indexes of sparse values with deep paths', function(assert) { + assert.expect(1); + + var values = [sparseArgs, sparseArray, sparseString], + expected = lodashStable.map(values, lodashStable.constant([true, true])); + + var actual = lodashStable.map(values, function(value) { + return lodashStable.map(['a[0]', ['a', '0']], function(path) { + return func({ 'a': value }, path); + }); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should return `' + (isHas ? 'false' : 'true') + '` for inherited properties', function(assert) { + assert.expect(2); + + function Foo() {} + Foo.prototype.a = 1; + + lodashStable.each(['a', ['a']], function(path) { + assert.strictEqual(func(new Foo, path), !isHas); + }); + }); + + QUnit.test('`_.' + methodName + '` should return `' + (isHas ? 'false' : 'true') + '` for nested inherited properties', function(assert) { + assert.expect(2); + + function Foo() {} + Foo.prototype.a = { 'b': 1 }; + + lodashStable.each(['a.b', ['a', 'b']], function(path) { + assert.strictEqual(func(new Foo, path), !isHas); + }); + }); + + QUnit.test('`_.' + methodName + '` should return `false` when `object` is nullish', function(assert) { + assert.expect(2); + + var values = [null, undefined], + expected = lodashStable.map(values, stubFalse); + + lodashStable.each(['constructor', ['constructor']], function(path) { + var actual = lodashStable.map(values, function(value) { + return func(value, path); + }); + + assert.deepEqual(actual, expected); + }); + }); + + QUnit.test('`_.' + methodName + '` should return `false` for deep paths when `object` is nullish', function(assert) { + assert.expect(2); + + var values = [null, undefined], + expected = lodashStable.map(values, stubFalse); + + lodashStable.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], function(path) { + var actual = lodashStable.map(values, function(value) { + return func(value, path); + }); + + assert.deepEqual(actual, expected); + }); + }); + + QUnit.test('`_.' + methodName + '` should return `false` for nullish values of nested objects', function(assert) { + assert.expect(2); + + var values = [, null, undefined], + expected = lodashStable.map(values, stubFalse); + + lodashStable.each(['a.b', ['a', 'b']], function(path) { + var actual = lodashStable.map(values, function(value, index) { + var object = index ? { 'a': value } : {}; + return func(object, path); + }); + + assert.deepEqual(actual, expected); + }); + }); + + QUnit.test('`_.' + methodName + '` should return `false` over sparse values of deep paths', function(assert) { + assert.expect(1); + + var values = [sparseArgs, sparseArray, sparseString], + expected = lodashStable.map(values, lodashStable.constant([false, false])); + + var actual = lodashStable.map(values, function(value) { + return lodashStable.map(['a[0].b', ['a', '0', 'b']], function(path) { + return func({ 'a': value }, path); + }); + }); + + assert.deepEqual(actual, expected); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.head'); + + (function() { + var array = [1, 2, 3, 4]; + + QUnit.test('should return the first element', function(assert) { + assert.expect(1); + + assert.strictEqual(_.head(array), 1); + }); + + QUnit.test('should return `undefined` when querying empty arrays', function(assert) { + assert.expect(1); + + arrayProto[0] = 1; + assert.strictEqual(_.head([]), undefined); + arrayProto.length = 0; + }); + + QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) { + assert.expect(1); + + var array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]], + actual = lodashStable.map(array, _.head); + + assert.deepEqual(actual, [1, 4, 7]); + }); + + QUnit.test('should be aliased', function(assert) { + assert.expect(1); + + assert.strictEqual(_.first, _.head); + }); + + QUnit.test('should return an unwrapped value when implicitly chaining', function(assert) { + assert.expect(2); + + if (!isNpm) { + var wrapped = _(array); + assert.strictEqual(wrapped.head(), 1); + assert.strictEqual(wrapped.first(), 1); + } + else { + skipAssert(assert, 2); + } + }); + + QUnit.test('should return a wrapped value when explicitly chaining', function(assert) { + assert.expect(2); + + if (!isNpm) { + var wrapped = _(array).chain(); + assert.ok(wrapped.head() instanceof _); + assert.ok(wrapped.first() instanceof _); + } + else { + skipAssert(assert, 2); + } + }); + + QUnit.test('should not execute immediately when explicitly chaining', function(assert) { + assert.expect(2); + + if (!isNpm) { + var wrapped = _(array).chain(); + assert.strictEqual(wrapped.head().__wrapped__, array); + assert.strictEqual(wrapped.first().__wrapped__, array); + } + else { + skipAssert(assert, 2); + } + }); + + QUnit.test('should work in a lazy sequence', function(assert) { + assert.expect(4); + + if (!isNpm) { + var largeArray = lodashStable.range(LARGE_ARRAY_SIZE), + smallArray = array; + + lodashStable.each(['head', 'first'], function(methodName) { + lodashStable.times(2, function(index) { + var array = index ? largeArray : smallArray, + actual = _(array).filter(isEven)[methodName](); + + assert.strictEqual(actual, _[methodName](_.filter(array, isEven))); + }); + }); + } + else { + skipAssert(assert, 4); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.identity'); + + (function() { + QUnit.test('should return the first argument given', function(assert) { + assert.expect(1); + + var object = { 'name': 'fred' }; + assert.strictEqual(_.identity(object), object); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.includes'); + + (function() { + lodashStable.each({ + 'an `arguments` object': arguments, + 'an array': [1, 2, 3, 4], + 'an object': { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }, + 'a string': '1234' + }, + function(collection, key) { + QUnit.test('should work with ' + key + ' and return `true` for matched values', function(assert) { + assert.expect(1); + + assert.strictEqual(_.includes(collection, 3), true); + }); + + QUnit.test('should work with ' + key + ' and return `false` for unmatched values', function(assert) { + assert.expect(1); + + assert.strictEqual(_.includes(collection, 5), false); + }); + + QUnit.test('should work with ' + key + ' and floor `position` values', function(assert) { + assert.expect(1); + + assert.strictEqual(_.includes(collection, 2, 1.2), true); + }); + + QUnit.test('should work with ' + key + ' and return an unwrapped value implicitly when chaining', function(assert) { + assert.expect(1); + + if (!isNpm) { + assert.strictEqual(_(collection).includes(3), true); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should work with ' + key + ' and return a wrapped value when explicitly chaining', function(assert) { + assert.expect(1); + + if (!isNpm) { + assert.ok(_(collection).chain().includes(3) instanceof _); + } + else { + skipAssert(assert); + } + }); + }); + + lodashStable.each({ + 'literal': 'abc', + 'object': Object('abc') + }, + function(collection, key) { + QUnit.test('should work with a string ' + key + ' for `collection`', function(assert) { + assert.expect(2); + + assert.strictEqual(_.includes(collection, 'bc'), true); + assert.strictEqual(_.includes(collection, 'd'), false); + }); + }); + + QUnit.test('should return `false` for empty collections', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(empties, stubFalse); + + var actual = lodashStable.map(empties, function(value) { + try { + return _.includes(value); + } catch (e) {} + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should work with a string and a `fromIndex` >= `length`', function(assert) { + assert.expect(1); + + var string = '1234', + length = string.length, + indexes = [4, 6, Math.pow(2, 32), Infinity]; + + var expected = lodashStable.map(indexes, function(index) { + return [false, false, index == length]; + }); + + var actual = lodashStable.map(indexes, function(fromIndex) { + return [ + _.includes(string, 1, fromIndex), + _.includes(string, undefined, fromIndex), + _.includes(string, '', fromIndex) + ]; + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should match `NaN`', function(assert) { + assert.expect(1); + + assert.strictEqual(_.includes([1, NaN, 3], NaN), true); + }); + + QUnit.test('should match `-0` as `0`', function(assert) { + assert.expect(2); + + assert.strictEqual(_.includes([-0], 0), true); + assert.strictEqual(_.includes([0], -0), true); + }); + + QUnit.test('should work as an iteratee for methods like `_.every`', function(assert) { + assert.expect(1); + + var array = [2, 3, 1], + values = [1, 2, 3]; + + assert.ok(lodashStable.every(values, lodashStable.partial(_.includes, array))); + }); + }(1, 2, 3, 4)); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.initial'); + + (function() { + var array = [1, 2, 3]; + + QUnit.test('should accept a falsey `array`', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(falsey, stubArray); + + var actual = lodashStable.map(falsey, function(array, index) { + try { + return index ? _.initial(array) : _.initial(); + } catch (e) {} + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should exclude last element', function(assert) { + assert.expect(1); + + assert.deepEqual(_.initial(array), [1, 2]); + }); + + QUnit.test('should return an empty when querying empty arrays', function(assert) { + assert.expect(1); + + assert.deepEqual(_.initial([]), []); + }); + + QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) { + assert.expect(1); + + var array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]], + actual = lodashStable.map(array, _.initial); + + assert.deepEqual(actual, [[1, 2], [4, 5], [7, 8]]); + }); + + QUnit.test('should work in a lazy sequence', function(assert) { + assert.expect(4); + + if (!isNpm) { + var array = lodashStable.range(LARGE_ARRAY_SIZE), + values = []; + + var actual = _(array).initial().filter(function(value) { + values.push(value); + return false; + }) + .value(); + + assert.deepEqual(actual, []); + assert.deepEqual(values, _.initial(array)); + + values = []; + + actual = _(array).filter(function(value) { + values.push(value); + return isEven(value); + }) + .initial() + .value(); + + assert.deepEqual(actual, _.initial(lodashStable.filter(array, isEven))); + assert.deepEqual(values, array); + } + else { + skipAssert(assert, 4); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.inRange'); + + (function() { + QUnit.test('should work with an `end`', function(assert) { + assert.expect(3); + + assert.strictEqual(_.inRange(3, 5), true); + assert.strictEqual(_.inRange(5, 5), false); + assert.strictEqual(_.inRange(6, 5), false); + }); + + QUnit.test('should work with a `start` and `end`', function(assert) { + assert.expect(4); + + assert.strictEqual(_.inRange(1, 1, 5), true); + assert.strictEqual(_.inRange(3, 1, 5), true); + assert.strictEqual(_.inRange(0, 1, 5), false); + assert.strictEqual(_.inRange(5, 1, 5), false); + }); + + QUnit.test('should treat falsey `start` as `0`', function(assert) { + assert.expect(13); + + lodashStable.each(falsey, function(value, index) { + if (index) { + assert.strictEqual(_.inRange(0, value), false); + assert.strictEqual(_.inRange(0, value, 1), true); + } else { + assert.strictEqual(_.inRange(0), false); + } + }); + }); + + QUnit.test('should swap `start` and `end` when `start` > `end`', function(assert) { + assert.expect(2); + + assert.strictEqual(_.inRange(2, 5, 1), true); + assert.strictEqual(_.inRange(-3, -2, -6), true); + }); + + QUnit.test('should work with a floating point `n` value', function(assert) { + assert.expect(4); + + assert.strictEqual(_.inRange(0.5, 5), true); + assert.strictEqual(_.inRange(1.2, 1, 5), true); + assert.strictEqual(_.inRange(5.2, 5), false); + assert.strictEqual(_.inRange(0.5, 1, 5), false); + }); + + QUnit.test('should coerce arguments to finite numbers', function(assert) { + assert.expect(1); + + var actual = [ + _.inRange(0, '1'), + _.inRange(0, '0', 1), + _.inRange(0, 0, '1'), + _.inRange(0, NaN, 1), + _.inRange(-1, -1, NaN) + ]; + + assert.deepEqual(actual, lodashStable.map(actual, stubTrue)); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('intersection methods'); + + lodashStable.each(['intersection', 'intersectionBy', 'intersectionWith'], function(methodName) { + var func = _[methodName]; + + QUnit.test('`_.' + methodName + '` should return the intersection of two arrays', function(assert) { + assert.expect(1); + + var actual = func([2, 1], [2, 3]); + assert.deepEqual(actual, [2]); + }); + + QUnit.test('`_.' + methodName + '` should return the intersection of multiple arrays', function(assert) { + assert.expect(1); + + var actual = func([2, 1, 2, 3], [3, 4], [3, 2]); + assert.deepEqual(actual, [3]); + }); + + QUnit.test('`_.' + methodName + '` should return an array of unique values', function(assert) { + assert.expect(1); + + var actual = func([1, 1, 3, 2, 2], [5, 2, 2, 1, 4], [2, 1, 1]); + assert.deepEqual(actual, [1, 2]); + }); + + QUnit.test('`_.' + methodName + '` should work with a single array', function(assert) { + assert.expect(1); + + var actual = func([1, 1, 3, 2, 2]); + assert.deepEqual(actual, [1, 3, 2]); + }); + + QUnit.test('`_.' + methodName + '` should work with `arguments` objects', function(assert) { + assert.expect(2); + + var array = [0, 1, null, 3], + expected = [1, 3]; + + assert.deepEqual(func(array, args), expected); + assert.deepEqual(func(args, array), expected); + }); + + QUnit.test('`_.' + methodName + '` should treat `-0` as `0`', function(assert) { + assert.expect(1); + + var values = [-0, 0], + expected = lodashStable.map(values, lodashStable.constant(['0'])); + + var actual = lodashStable.map(values, function(value) { + return lodashStable.map(func(values, [value]), lodashStable.toString); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should match `NaN`', function(assert) { + assert.expect(1); + + var actual = func([1, NaN, 3], [NaN, 5, NaN]); + assert.deepEqual(actual, [NaN]); + }); + + QUnit.test('`_.' + methodName + '` should work with large arrays of `-0` as `0`', function(assert) { + assert.expect(1); + + var values = [-0, 0], + expected = lodashStable.map(values, lodashStable.constant(['0'])); + + var actual = lodashStable.map(values, function(value) { + var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, lodashStable.constant(value)); + return lodashStable.map(func(values, largeArray), lodashStable.toString); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should work with large arrays of `NaN`', function(assert) { + assert.expect(1); + + var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, stubNaN); + assert.deepEqual(func([1, NaN, 3], largeArray), [NaN]); + }); + + QUnit.test('`_.' + methodName + '` should work with large arrays of objects', function(assert) { + assert.expect(2); + + var object = {}, + largeArray = lodashStable.times(LARGE_ARRAY_SIZE, lodashStable.constant(object)); + + assert.deepEqual(func([object], largeArray), [object]); + assert.deepEqual(func(lodashStable.range(LARGE_ARRAY_SIZE), [1]), [1]); + }); + + QUnit.test('`_.' + methodName + '` should treat values that are not arrays or `arguments` objects as empty', function(assert) { + assert.expect(3); + + var array = [0, 1, null, 3]; + assert.deepEqual(func(array, 3, { '0': 1 }, null), []); + assert.deepEqual(func(null, array, null, [2, 3]), []); + assert.deepEqual(func(array, null, args, null), []); + }); + + QUnit.test('`_.' + methodName + '` should return a wrapped value when chaining', function(assert) { + assert.expect(2); + + if (!isNpm) { + var wrapped = _([1, 3, 2])[methodName]([5, 2, 1, 4]); + assert.ok(wrapped instanceof _); + assert.deepEqual(wrapped.value(), [1, 2]); + } + else { + skipAssert(assert, 2); + } + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.intersectionBy'); + + (function() { + QUnit.test('should accept an `iteratee`', function(assert) { + assert.expect(2); + + var actual = _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor); + assert.deepEqual(actual, [2.1]); + + actual = _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); + assert.deepEqual(actual, [{ 'x': 1 }]); + }); + + QUnit.test('should provide correct `iteratee` arguments', function(assert) { + assert.expect(1); + + var args; + + _.intersectionBy([2.1, 1.2], [2.3, 3.4], function() { + args || (args = slice.call(arguments)); + }); + + assert.deepEqual(args, [2.3]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.intersectionWith'); + + (function() { + QUnit.test('should work with a `comparator`', function(assert) { + assert.expect(1); + + var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }], + others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }], + actual = _.intersectionWith(objects, others, lodashStable.isEqual); + + assert.deepEqual(actual, [objects[0]]); + }); + + QUnit.test('should preserve the sign of `0`', function(assert) { + assert.expect(1); + + var array = [-0], + largeArray = lodashStable.times(LARGE_ARRAY_SIZE, stubZero), + others = [[0], largeArray], + expected = lodashStable.map(others, lodashStable.constant(['-0'])); + + var actual = lodashStable.map(others, function(other) { + return lodashStable.map(_.intersectionWith(array, other, lodashStable.eq), lodashStable.toString); + }); + + assert.deepEqual(actual, expected); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.invert'); + + (function() { + QUnit.test('should invert an object', function(assert) { + assert.expect(2); + + var object = { 'a': 1, 'b': 2 }, + actual = _.invert(object); + + assert.deepEqual(actual, { '1': 'a', '2': 'b' }); + assert.deepEqual(_.invert(actual), { 'a': '1', 'b': '2' }); + }); + + QUnit.test('should work with values that shadow keys on `Object.prototype`', function(assert) { + assert.expect(1); + + var object = { 'a': 'hasOwnProperty', 'b': 'constructor' }; + assert.deepEqual(_.invert(object), { 'hasOwnProperty': 'a', 'constructor': 'b' }); + }); + + QUnit.test('should work with an object that has a `length` property', function(assert) { + assert.expect(1); + + var object = { '0': 'a', '1': 'b', 'length': 2 }; + assert.deepEqual(_.invert(object), { 'a': '0', 'b': '1', '2': 'length' }); + }); + + QUnit.test('should return a wrapped value when chaining', function(assert) { + assert.expect(2); + + if (!isNpm) { + var object = { 'a': 1, 'b': 2 }, + wrapped = _(object).invert(); + + assert.ok(wrapped instanceof _); + assert.deepEqual(wrapped.value(), { '1': 'a', '2': 'b' }); + } + else { + skipAssert(assert, 2); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.invertBy'); + + (function() { + var object = { 'a': 1, 'b': 2, 'c': 1 }; + + QUnit.test('should transform keys by `iteratee`', function(assert) { + assert.expect(1); + + var expected = { 'group1': ['a', 'c'], 'group2': ['b'] }; + + var actual = _.invertBy(object, function(value) { + return 'group' + value; + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should use `_.identity` when `iteratee` is nullish', function(assert) { + assert.expect(1); + + var values = [, null, undefined], + expected = lodashStable.map(values, lodashStable.constant({ '1': ['a', 'c'], '2': ['b'] })); + + var actual = lodashStable.map(values, function(value, index) { + return index ? _.invertBy(object, value) : _.invertBy(object); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should only add multiple values to own, not inherited, properties', function(assert) { + assert.expect(1); + + var object = { 'a': 'hasOwnProperty', 'b': 'constructor' }, + expected = { 'hasOwnProperty': ['a'], 'constructor': ['b'] }; + + assert.ok(lodashStable.isEqual(_.invertBy(object), expected)); + }); + + QUnit.test('should return a wrapped value when chaining', function(assert) { + assert.expect(2); + + if (!isNpm) { + var wrapped = _(object).invertBy(); + + assert.ok(wrapped instanceof _); + assert.deepEqual(wrapped.value(), { '1': ['a', 'c'], '2': ['b'] }); + } + else { + skipAssert(assert, 2); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.invoke'); + + (function() { + QUnit.test('should invoke a method on `object`', function(assert) { + assert.expect(1); + + var object = { 'a': lodashStable.constant('A') }, + actual = _.invoke(object, 'a'); + + assert.strictEqual(actual, 'A'); + }); + + QUnit.test('should support invoking with arguments', function(assert) { + assert.expect(1); + + var object = { 'a': function(a, b) { return [a, b]; } }, + actual = _.invoke(object, 'a', 1, 2); + + assert.deepEqual(actual, [1, 2]); + }); + + QUnit.test('should not error on nullish elements', function(assert) { + assert.expect(1); + + var values = [null, undefined], + expected = lodashStable.map(values, noop); + + var actual = lodashStable.map(values, function(value) { + try { + return _.invoke(value, 'a.b', 1, 2); + } catch (e) {} + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should preserve the sign of `0`', function(assert) { + assert.expect(1); + + var object = { '-0': stubA, '0': stubB }, + props = [-0, Object(-0), 0, Object(0)]; + + var actual = lodashStable.map(props, function(key) { + return _.invoke(object, key); + }); + + assert.deepEqual(actual, ['a', 'a', 'b', 'b']); + }); + + QUnit.test('should support deep paths', function(assert) { + assert.expect(2); + + var object = { 'a': { 'b': function(a, b) { return [a, b]; } } }; + + lodashStable.each(['a.b', ['a', 'b']], function(path) { + var actual = _.invoke(object, path, 1, 2); + assert.deepEqual(actual, [1, 2]); + }); + }); + + QUnit.test('should invoke deep property methods with the correct `this` binding', function(assert) { + assert.expect(2); + + var object = { 'a': { 'b': function() { return this.c; }, 'c': 1 } }; + + lodashStable.each(['a.b', ['a', 'b']], function(path) { + assert.deepEqual(_.invoke(object, path), 1); + }); + }); + + QUnit.test('should return an unwrapped value when implicitly chaining', function(assert) { + assert.expect(1); + + if (!isNpm) { + var object = { 'a': stubOne }; + assert.strictEqual(_(object).invoke('a'), 1); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should return a wrapped value when explicitly chaining', function(assert) { + assert.expect(1); + + if (!isNpm) { + var object = { 'a': stubOne }; + assert.ok(_(object).chain().invoke('a') instanceof _); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.invokeMap'); + + (function() { + QUnit.test('should invoke a methods on each element of `collection`', function(assert) { + assert.expect(1); + + var array = ['a', 'b', 'c'], + actual = _.invokeMap(array, 'toUpperCase'); + + assert.deepEqual(actual, ['A', 'B', 'C']); + }); + + QUnit.test('should support invoking with arguments', function(assert) { + assert.expect(1); + + var array = [function() { return slice.call(arguments); }], + actual = _.invokeMap(array, 'call', null, 'a', 'b', 'c'); + + assert.deepEqual(actual, [['a', 'b', 'c']]); + }); + + QUnit.test('should work with a function for `methodName`', function(assert) { + assert.expect(1); + + var array = ['a', 'b', 'c']; + + var actual = _.invokeMap(array, function(left, right) { + return left + this.toUpperCase() + right; + }, '(', ')'); + + assert.deepEqual(actual, ['(A)', '(B)', '(C)']); + }); + + QUnit.test('should work with an object for `collection`', function(assert) { + assert.expect(1); + + var object = { 'a': 1, 'b': 2, 'c': 3 }, + actual = _.invokeMap(object, 'toFixed', 1); + + assert.deepEqual(actual, ['1.0', '2.0', '3.0']); + }); + + QUnit.test('should treat number values for `collection` as empty', function(assert) { + assert.expect(1); + + assert.deepEqual(_.invokeMap(1), []); + }); + + QUnit.test('should not error on nullish elements', function(assert) { + assert.expect(1); + + var array = ['a', null, undefined, 'd']; + + try { + var actual = _.invokeMap(array, 'toUpperCase'); + } catch (e) {} + + assert.deepEqual(actual, ['A', undefined, undefined, 'D']); + }); + + QUnit.test('should not error on elements with missing properties', function(assert) { + assert.expect(1); + + var objects = lodashStable.map([null, undefined, stubOne], function(value) { + return { 'a': value }; + }); + + var expected = lodashStable.map(objects, function(object) { + return object.a ? object.a() : undefined; + }); + + try { + var actual = _.invokeMap(objects, 'a'); + } catch (e) {} + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should invoke deep property methods with the correct `this` binding', function(assert) { + assert.expect(2); + + var object = { 'a': { 'b': function() { return this.c; }, 'c': 1 } }; + + lodashStable.each(['a.b', ['a', 'b']], function(path) { + assert.deepEqual(_.invokeMap([object], path), [1]); + }); + }); + + QUnit.test('should return a wrapped value when chaining', function(assert) { + assert.expect(4); + + if (!isNpm) { + var array = ['a', 'b', 'c'], + wrapped = _(array), + actual = wrapped.invokeMap('toUpperCase'); + + assert.ok(actual instanceof _); + assert.deepEqual(actual.valueOf(), ['A', 'B', 'C']); + + actual = wrapped.invokeMap(function(left, right) { + return left + this.toUpperCase() + right; + }, '(', ')'); + + assert.ok(actual instanceof _); + assert.deepEqual(actual.valueOf(), ['(A)', '(B)', '(C)']); + } + else { + skipAssert(assert, 4); + } + }); + + QUnit.test('should support shortcut fusion', function(assert) { + assert.expect(2); + + if (!isNpm) { + var count = 0, + method = function() { count++; return this.index; }; + + var array = lodashStable.times(LARGE_ARRAY_SIZE, function(index) { + return { 'index': index, 'method': method }; + }); + + var actual = _(array).invokeMap('method').take(1).value(); + + assert.strictEqual(count, 1); + assert.deepEqual(actual, [0]); + } + else { + skipAssert(assert, 2); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isArguments'); + + (function() { + QUnit.test('should return `true` for `arguments` objects', function(assert) { + assert.expect(2); + + assert.strictEqual(_.isArguments(args), true); + assert.strictEqual(_.isArguments(strictArgs), true); + }); + + QUnit.test('should return `false` for non `arguments` objects', function(assert) { + assert.expect(12); + + var expected = lodashStable.map(falsey, stubFalse); + + var actual = lodashStable.map(falsey, function(value, index) { + return index ? _.isArguments(value) : _.isArguments(); + }); + + assert.deepEqual(actual, expected); + + assert.strictEqual(_.isArguments([1, 2, 3]), false); + assert.strictEqual(_.isArguments(true), false); + assert.strictEqual(_.isArguments(new Date), false); + assert.strictEqual(_.isArguments(new Error), false); + assert.strictEqual(_.isArguments(_), false); + assert.strictEqual(_.isArguments(slice), false); + assert.strictEqual(_.isArguments({ '0': 1, 'callee': noop, 'length': 1 }), false); + assert.strictEqual(_.isArguments(1), false); + assert.strictEqual(_.isArguments(/x/), false); + assert.strictEqual(_.isArguments('a'), false); + assert.strictEqual(_.isArguments(symbol), false); + }); + + QUnit.test('should work with an `arguments` object from another realm', function(assert) { + assert.expect(1); + + if (realm.arguments) { + assert.strictEqual(_.isArguments(realm.arguments), true); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isArray'); + + (function() { + QUnit.test('should return `true` for arrays', function(assert) { + assert.expect(1); + + assert.strictEqual(_.isArray([1, 2, 3]), true); + }); + + QUnit.test('should return `false` for non-arrays', function(assert) { + assert.expect(12); + + var expected = lodashStable.map(falsey, stubFalse); + + var actual = lodashStable.map(falsey, function(value, index) { + return index ? _.isArray(value) : _.isArray(); + }); + + assert.deepEqual(actual, expected); + + assert.strictEqual(_.isArray(args), false); + assert.strictEqual(_.isArray(true), false); + assert.strictEqual(_.isArray(new Date), false); + assert.strictEqual(_.isArray(new Error), false); + assert.strictEqual(_.isArray(_), false); + assert.strictEqual(_.isArray(slice), false); + assert.strictEqual(_.isArray({ '0': 1, 'length': 1 }), false); + assert.strictEqual(_.isArray(1), false); + assert.strictEqual(_.isArray(/x/), false); + assert.strictEqual(_.isArray('a'), false); + assert.strictEqual(_.isArray(symbol), false); + }); + + QUnit.test('should work with an array from another realm', function(assert) { + assert.expect(1); + + if (realm.array) { + assert.strictEqual(_.isArray(realm.array), true); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isArrayBuffer'); + + (function() { + QUnit.test('should return `true` for array buffers', function(assert) { + assert.expect(1); + + if (ArrayBuffer) { + assert.strictEqual(_.isArrayBuffer(arrayBuffer), true); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should return `false` for non array buffers', function(assert) { + assert.expect(13); + + var expected = lodashStable.map(falsey, stubFalse); + + var actual = lodashStable.map(falsey, function(value, index) { + return index ? _.isArrayBuffer(value) : _.isArrayBuffer(); + }); + + assert.deepEqual(actual, expected); + + assert.strictEqual(_.isArrayBuffer(args), false); + assert.strictEqual(_.isArrayBuffer([1]), false); + assert.strictEqual(_.isArrayBuffer(true), false); + assert.strictEqual(_.isArrayBuffer(new Date), false); + assert.strictEqual(_.isArrayBuffer(new Error), false); + assert.strictEqual(_.isArrayBuffer(_), false); + assert.strictEqual(_.isArrayBuffer(slice), false); + assert.strictEqual(_.isArrayBuffer({ 'a': 1 }), false); + assert.strictEqual(_.isArrayBuffer(1), false); + assert.strictEqual(_.isArrayBuffer(/x/), false); + assert.strictEqual(_.isArrayBuffer('a'), false); + assert.strictEqual(_.isArrayBuffer(symbol), false); + }); + + QUnit.test('should work with array buffers from another realm', function(assert) { + assert.expect(1); + + if (realm.arrayBuffer) { + assert.strictEqual(_.isArrayBuffer(realm.arrayBuffer), true); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isArrayLike'); + + (function() { + QUnit.test('should return `true` for array-like values', function(assert) { + assert.expect(1); + + var values = [args, [1, 2, 3], { '0': 'a', 'length': 1 }, 'a'], + expected = lodashStable.map(values, stubTrue), + actual = lodashStable.map(values, _.isArrayLike); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should return `false` for non-arrays', function(assert) { + assert.expect(12); + + var expected = lodashStable.map(falsey, function(value) { + return value === ''; + }); + + var actual = lodashStable.map(falsey, function(value, index) { + return index ? _.isArrayLike(value) : _.isArrayLike(); + }); + + assert.deepEqual(actual, expected); + + assert.strictEqual(_.isArrayLike(true), false); + assert.strictEqual(_.isArrayLike(new Date), false); + assert.strictEqual(_.isArrayLike(new Error), false); + assert.strictEqual(_.isArrayLike(_), false); + assert.strictEqual(_.isArrayLike(asyncFunc), false); + assert.strictEqual(_.isArrayLike(genFunc), false); + assert.strictEqual(_.isArrayLike(slice), false); + assert.strictEqual(_.isArrayLike({ 'a': 1 }), false); + assert.strictEqual(_.isArrayLike(1), false); + assert.strictEqual(_.isArrayLike(/x/), false); + assert.strictEqual(_.isArrayLike(symbol), false); + }); + + QUnit.test('should work with an array from another realm', function(assert) { + assert.expect(1); + + if (realm.object) { + var values = [realm.arguments, realm.array, realm.string], + expected = lodashStable.map(values, stubTrue), + actual = lodashStable.map(values, _.isArrayLike); + + assert.deepEqual(actual, expected); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isBoolean'); + + (function() { + QUnit.test('should return `true` for booleans', function(assert) { + assert.expect(4); + + assert.strictEqual(_.isBoolean(true), true); + assert.strictEqual(_.isBoolean(false), true); + assert.strictEqual(_.isBoolean(Object(true)), true); + assert.strictEqual(_.isBoolean(Object(false)), true); + }); + + QUnit.test('should return `false` for non-booleans', function(assert) { + assert.expect(12); + + var expected = lodashStable.map(falsey, function(value) { + return value === false; + }); + + var actual = lodashStable.map(falsey, function(value, index) { + return index ? _.isBoolean(value) : _.isBoolean(); + }); + + assert.deepEqual(actual, expected); + + assert.strictEqual(_.isBoolean(args), false); + assert.strictEqual(_.isBoolean([1, 2, 3]), false); + assert.strictEqual(_.isBoolean(new Date), false); + assert.strictEqual(_.isBoolean(new Error), false); + assert.strictEqual(_.isBoolean(_), false); + assert.strictEqual(_.isBoolean(slice), false); + assert.strictEqual(_.isBoolean({ 'a': 1 }), false); + assert.strictEqual(_.isBoolean(1), false); + assert.strictEqual(_.isBoolean(/x/), false); + assert.strictEqual(_.isBoolean('a'), false); + assert.strictEqual(_.isBoolean(symbol), false); + }); + + QUnit.test('should work with a boolean from another realm', function(assert) { + assert.expect(1); + + if (realm.boolean) { + assert.strictEqual(_.isBoolean(realm.boolean), true); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isBuffer'); + + (function() { + QUnit.test('should return `true` for buffers', function(assert) { + assert.expect(1); + + if (Buffer) { + assert.strictEqual(_.isBuffer(new Buffer(2)), true); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should return `false` for non-buffers', function(assert) { + assert.expect(13); + + var expected = lodashStable.map(falsey, stubFalse); + + var actual = lodashStable.map(falsey, function(value, index) { + return index ? _.isBuffer(value) : _.isBuffer(); + }); + + assert.deepEqual(actual, expected); + + assert.strictEqual(_.isBuffer(args), false); + assert.strictEqual(_.isBuffer([1]), false); + assert.strictEqual(_.isBuffer(true), false); + assert.strictEqual(_.isBuffer(new Date), false); + assert.strictEqual(_.isBuffer(new Error), false); + assert.strictEqual(_.isBuffer(_), false); + assert.strictEqual(_.isBuffer(slice), false); + assert.strictEqual(_.isBuffer({ 'a': 1 }), false); + assert.strictEqual(_.isBuffer(1), false); + assert.strictEqual(_.isBuffer(/x/), false); + assert.strictEqual(_.isBuffer('a'), false); + assert.strictEqual(_.isBuffer(symbol), false); + }); + + QUnit.test('should return `false` if `Buffer` is not defined', function(assert) { + assert.expect(1); + + if (!isStrict && Buffer && lodashBizarro) { + assert.strictEqual(lodashBizarro.isBuffer(new Buffer(2)), false); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isDate'); + + (function() { + QUnit.test('should return `true` for dates', function(assert) { + assert.expect(1); + + assert.strictEqual(_.isDate(new Date), true); + }); + + QUnit.test('should return `false` for non-dates', function(assert) { + assert.expect(12); + + var expected = lodashStable.map(falsey, stubFalse); + + var actual = lodashStable.map(falsey, function(value, index) { + return index ? _.isDate(value) : _.isDate(); + }); + + assert.deepEqual(actual, expected); + + assert.strictEqual(_.isDate(args), false); + assert.strictEqual(_.isDate([1, 2, 3]), false); + assert.strictEqual(_.isDate(true), false); + assert.strictEqual(_.isDate(new Error), false); + assert.strictEqual(_.isDate(_), false); + assert.strictEqual(_.isDate(slice), false); + assert.strictEqual(_.isDate({ 'a': 1 }), false); + assert.strictEqual(_.isDate(1), false); + assert.strictEqual(_.isDate(/x/), false); + assert.strictEqual(_.isDate('a'), false); + assert.strictEqual(_.isDate(symbol), false); + }); + + QUnit.test('should work with a date object from another realm', function(assert) { + assert.expect(1); + + if (realm.date) { + assert.strictEqual(_.isDate(realm.date), true); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isElement'); + + (function() { + QUnit.test('should return `true` for elements', function(assert) { + assert.expect(1); + + if (document) { + assert.strictEqual(_.isElement(body), true); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should return `true` for non-plain objects', function(assert) { + assert.expect(1); + + function Foo() { + this.nodeType = 1; + } + + assert.strictEqual(_.isElement(new Foo), true); + }); + + QUnit.test('should return `false` for non DOM elements', function(assert) { + assert.expect(13); + + var expected = lodashStable.map(falsey, stubFalse); + + var actual = lodashStable.map(falsey, function(value, index) { + return index ? _.isElement(value) : _.isElement(); + }); + + assert.deepEqual(actual, expected); + + assert.strictEqual(_.isElement(args), false); + assert.strictEqual(_.isElement([1, 2, 3]), false); + assert.strictEqual(_.isElement(true), false); + assert.strictEqual(_.isElement(new Date), false); + assert.strictEqual(_.isElement(new Error), false); + assert.strictEqual(_.isElement(_), false); + assert.strictEqual(_.isElement(slice), false); + assert.strictEqual(_.isElement({ 'a': 1 }), false); + assert.strictEqual(_.isElement(1), false); + assert.strictEqual(_.isElement(/x/), false); + assert.strictEqual(_.isElement('a'), false); + assert.strictEqual(_.isElement(symbol), false); + }); + + QUnit.test('should return `false` for plain objects', function(assert) { + assert.expect(6); + + assert.strictEqual(_.isElement({ 'nodeType': 1 }), false); + assert.strictEqual(_.isElement({ 'nodeType': Object(1) }), false); + assert.strictEqual(_.isElement({ 'nodeType': true }), false); + assert.strictEqual(_.isElement({ 'nodeType': [1] }), false); + assert.strictEqual(_.isElement({ 'nodeType': '1' }), false); + assert.strictEqual(_.isElement({ 'nodeType': '001' }), false); + }); + + QUnit.test('should work with a DOM element from another realm', function(assert) { + assert.expect(1); + + if (realm.element) { + assert.strictEqual(_.isElement(realm.element), true); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isEmpty'); + + (function() { + QUnit.test('should return `true` for empty values', function(assert) { + assert.expect(10); + + var expected = lodashStable.map(empties, stubTrue), + actual = lodashStable.map(empties, _.isEmpty); + + assert.deepEqual(actual, expected); + + assert.strictEqual(_.isEmpty(true), true); + assert.strictEqual(_.isEmpty(slice), true); + assert.strictEqual(_.isEmpty(1), true); + assert.strictEqual(_.isEmpty(NaN), true); + assert.strictEqual(_.isEmpty(/x/), true); + assert.strictEqual(_.isEmpty(symbol), true); + assert.strictEqual(_.isEmpty(), true); + + if (Buffer) { + assert.strictEqual(_.isEmpty(new Buffer(0)), true); + assert.strictEqual(_.isEmpty(new Buffer(1)), false); + } + else { + skipAssert(assert, 2); + } + }); + + QUnit.test('should return `false` for non-empty values', function(assert) { + assert.expect(3); + + assert.strictEqual(_.isEmpty([0]), false); + assert.strictEqual(_.isEmpty({ 'a': 0 }), false); + assert.strictEqual(_.isEmpty('a'), false); + }); + + QUnit.test('should work with an object that has a `length` property', function(assert) { + assert.expect(1); + + assert.strictEqual(_.isEmpty({ 'length': 0 }), false); + }); + + QUnit.test('should work with `arguments` objects', function(assert) { + assert.expect(1); + + assert.strictEqual(_.isEmpty(args), false); + }); + + QUnit.test('should work with prototytpe objects', function(assert) { + assert.expect(2); + + function Foo() {} + Foo.prototype = { 'constructor': Foo }; + + assert.strictEqual(_.isEmpty(Foo.prototype), true); + + Foo.prototype.a = 1; + assert.strictEqual(_.isEmpty(Foo.prototype), false); + }); + + QUnit.test('should work with jQuery/MooTools DOM query collections', function(assert) { + assert.expect(1); + + function Foo(elements) { + push.apply(this, elements); + } + Foo.prototype = { 'length': 0, 'splice': arrayProto.splice }; + + assert.strictEqual(_.isEmpty(new Foo([])), true); + }); + + QUnit.test('should work with maps', function(assert) { + assert.expect(4); + + if (Map) { + lodashStable.each([new Map, realm.map], function(map) { + assert.strictEqual(_.isEmpty(map), true); + map.set('a', 1); + assert.strictEqual(_.isEmpty(map), false); + map.clear(); + }); + } + else { + skipAssert(assert, 4); + } + }); + + QUnit.test('should work with sets', function(assert) { + assert.expect(4); + + if (Set) { + lodashStable.each([new Set, realm.set], function(set) { + assert.strictEqual(_.isEmpty(set), true); + set.add(1); + assert.strictEqual(_.isEmpty(set), false); + set.clear(); + }); + } + else { + skipAssert(assert, 4); + } + }); + + QUnit.test('should not treat objects with negative lengths as array-like', function(assert) { + assert.expect(1); + + function Foo() {} + Foo.prototype.length = -1; + + assert.strictEqual(_.isEmpty(new Foo), true); + }); + + QUnit.test('should not treat objects with lengths larger than `MAX_SAFE_INTEGER` as array-like', function(assert) { + assert.expect(1); + + function Foo() {} + Foo.prototype.length = MAX_SAFE_INTEGER + 1; + + assert.strictEqual(_.isEmpty(new Foo), true); + }); + + QUnit.test('should not treat objects with non-number lengths as array-like', function(assert) { + assert.expect(1); + + assert.strictEqual(_.isEmpty({ 'length': '0' }), false); + }); + + QUnit.test('should return an unwrapped value when implicitly chaining', function(assert) { + assert.expect(1); + + if (!isNpm) { + assert.strictEqual(_({}).isEmpty(), true); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should return a wrapped value when explicitly chaining', function(assert) { + assert.expect(1); + + if (!isNpm) { + assert.ok(_({}).chain().isEmpty() instanceof _); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isEqual'); + + (function() { + var symbol1 = Symbol ? Symbol('a') : true, + symbol2 = Symbol ? Symbol('b') : false; + + QUnit.test('should compare primitives', function(assert) { + assert.expect(1); + + var pairs = [ + [1, 1, true], [1, Object(1), true], [1, '1', false], [1, 2, false], + [-0, -0, true], [0, 0, true], [0, Object(0), true], [Object(0), Object(0), true], [-0, 0, true], [0, '0', false], [0, null, false], + [NaN, NaN, true], [NaN, Object(NaN), true], [Object(NaN), Object(NaN), true], [NaN, 'a', false], [NaN, Infinity, false], + ['a', 'a', true], ['a', Object('a'), true], [Object('a'), Object('a'), true], ['a', 'b', false], ['a', ['a'], false], + [true, true, true], [true, Object(true), true], [Object(true), Object(true), true], [true, 1, false], [true, 'a', false], + [false, false, true], [false, Object(false), true], [Object(false), Object(false), true], [false, 0, false], [false, '', false], + [symbol1, symbol1, true], [symbol1, Object(symbol1), true], [Object(symbol1), Object(symbol1), true], [symbol1, symbol2, false], + [null, null, true], [null, undefined, false], [null, {}, false], [null, '', false], + [undefined, undefined, true], [undefined, null, false], [undefined, '', false] + ]; + + var expected = lodashStable.map(pairs, function(pair) { + return pair[2]; + }); + + var actual = lodashStable.map(pairs, function(pair) { + return _.isEqual(pair[0], pair[1]); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should compare arrays', function(assert) { + assert.expect(6); + + var array1 = [true, null, 1, 'a', undefined], + array2 = [true, null, 1, 'a', undefined]; + + assert.strictEqual(_.isEqual(array1, array2), true); + + array1 = [[1, 2, 3], new Date(2012, 4, 23), /x/, { 'e': 1 }]; + array2 = [[1, 2, 3], new Date(2012, 4, 23), /x/, { 'e': 1 }]; + + assert.strictEqual(_.isEqual(array1, array2), true); + + array1 = [1]; + array1[2] = 3; + + array2 = [1]; + array2[1] = undefined; + array2[2] = 3; + + assert.strictEqual(_.isEqual(array1, array2), true); + + array1 = [Object(1), false, Object('a'), /x/, new Date(2012, 4, 23), ['a', 'b', [Object('c')]], { 'a': 1 }]; + array2 = [1, Object(false), 'a', /x/, new Date(2012, 4, 23), ['a', Object('b'), ['c']], { 'a': 1 }]; + + assert.strictEqual(_.isEqual(array1, array2), true); + + array1 = [1, 2, 3]; + array2 = [3, 2, 1]; + + assert.strictEqual(_.isEqual(array1, array2), false); + + array1 = [1, 2]; + array2 = [1, 2, 3]; + + assert.strictEqual(_.isEqual(array1, array2), false); + }); + + QUnit.test('should treat arrays with identical values but different non-index properties as equal', function(assert) { + assert.expect(3); + + var array1 = [1, 2, 3], + array2 = [1, 2, 3]; + + array1.every = array1.filter = array1.forEach = + array1.indexOf = array1.lastIndexOf = array1.map = + array1.some = array1.reduce = array1.reduceRight = null; + + array2.concat = array2.join = array2.pop = + array2.reverse = array2.shift = array2.slice = + array2.sort = array2.splice = array2.unshift = null; + + assert.strictEqual(_.isEqual(array1, array2), true); + + array1 = [1, 2, 3]; + array1.a = 1; + + array2 = [1, 2, 3]; + array2.b = 1; + + assert.strictEqual(_.isEqual(array1, array2), true); + + array1 = /c/.exec('abcde'); + array2 = ['c']; + + assert.strictEqual(_.isEqual(array1, array2), true); + }); + + QUnit.test('should compare sparse arrays', function(assert) { + assert.expect(3); + + var array = Array(1); + + assert.strictEqual(_.isEqual(array, Array(1)), true); + assert.strictEqual(_.isEqual(array, [undefined]), true); + assert.strictEqual(_.isEqual(array, Array(2)), false); + }); + + QUnit.test('should compare plain objects', function(assert) { + assert.expect(5); + + var object1 = { 'a': true, 'b': null, 'c': 1, 'd': 'a', 'e': undefined }, + object2 = { 'a': true, 'b': null, 'c': 1, 'd': 'a', 'e': undefined }; + + assert.strictEqual(_.isEqual(object1, object2), true); + + object1 = { 'a': [1, 2, 3], 'b': new Date(2012, 4, 23), 'c': /x/, 'd': { 'e': 1 } }; + object2 = { 'a': [1, 2, 3], 'b': new Date(2012, 4, 23), 'c': /x/, 'd': { 'e': 1 } }; + + assert.strictEqual(_.isEqual(object1, object2), true); + + object1 = { 'a': 1, 'b': 2, 'c': 3 }; + object2 = { 'a': 3, 'b': 2, 'c': 1 }; + + assert.strictEqual(_.isEqual(object1, object2), false); + + object1 = { 'a': 1, 'b': 2, 'c': 3 }; + object2 = { 'd': 1, 'e': 2, 'f': 3 }; + + assert.strictEqual(_.isEqual(object1, object2), false); + + object1 = { 'a': 1, 'b': 2 }; + object2 = { 'a': 1, 'b': 2, 'c': 3 }; + + assert.strictEqual(_.isEqual(object1, object2), false); + }); + + QUnit.test('should compare objects regardless of key order', function(assert) { + assert.expect(1); + + var object1 = { 'a': 1, 'b': 2, 'c': 3 }, + object2 = { 'c': 3, 'a': 1, 'b': 2 }; + + assert.strictEqual(_.isEqual(object1, object2), true); + }); + + QUnit.test('should compare nested objects', function(assert) { + assert.expect(1); + + var object1 = { + 'a': [1, 2, 3], + 'b': true, + 'c': Object(1), + 'd': 'a', + 'e': { + 'f': ['a', Object('b'), 'c'], + 'g': Object(false), + 'h': new Date(2012, 4, 23), + 'i': noop, + 'j': 'a' + } + }; + + var object2 = { + 'a': [1, Object(2), 3], + 'b': Object(true), + 'c': 1, + 'd': Object('a'), + 'e': { + 'f': ['a', 'b', 'c'], + 'g': false, + 'h': new Date(2012, 4, 23), + 'i': noop, + 'j': 'a' + } + }; + + assert.strictEqual(_.isEqual(object1, object2), true); + }); + + QUnit.test('should compare object instances', function(assert) { + assert.expect(4); + + function Foo() { + this.a = 1; + } + Foo.prototype.a = 1; + + function Bar() { + this.a = 1; + } + Bar.prototype.a = 2; + + assert.strictEqual(_.isEqual(new Foo, new Foo), true); + assert.strictEqual(_.isEqual(new Foo, new Bar), false); + assert.strictEqual(_.isEqual({ 'a': 1 }, new Foo), false); + assert.strictEqual(_.isEqual({ 'a': 2 }, new Bar), false); + }); + + QUnit.test('should compare objects with constructor properties', function(assert) { + assert.expect(5); + + assert.strictEqual(_.isEqual({ 'constructor': 1 }, { 'constructor': 1 }), true); + assert.strictEqual(_.isEqual({ 'constructor': 1 }, { 'constructor': '1' }), false); + assert.strictEqual(_.isEqual({ 'constructor': [1] }, { 'constructor': [1] }), true); + assert.strictEqual(_.isEqual({ 'constructor': [1] }, { 'constructor': ['1'] }), false); + assert.strictEqual(_.isEqual({ 'constructor': Object }, {}), false); + }); + + QUnit.test('should compare arrays with circular references', function(assert) { + assert.expect(6); + + var array1 = [], + array2 = []; + + array1.push(array1); + array2.push(array2); + + assert.strictEqual(_.isEqual(array1, array2), true); + + array1.push('b'); + array2.push('b'); + + assert.strictEqual(_.isEqual(array1, array2), true); + + array1.push('c'); + array2.push('d'); + + assert.strictEqual(_.isEqual(array1, array2), false); + + array1 = ['a', 'b', 'c']; + array1[1] = array1; + array2 = ['a', ['a', 'b', 'c'], 'c']; + + assert.strictEqual(_.isEqual(array1, array2), false); + + array1 = [[[]]]; + array1[0][0][0] = array1; + array2 = []; + array2[0] = array2; + + assert.strictEqual(_.isEqual(array1, array2), false); + assert.strictEqual(_.isEqual(array2, array1), false); + }); + + QUnit.test('should have transitive equivalence for circular references of arrays', function(assert) { + assert.expect(3); + + var array1 = [], + array2 = [array1], + array3 = [array2]; + + array1[0] = array1; + + assert.strictEqual(_.isEqual(array1, array2), true); + assert.strictEqual(_.isEqual(array2, array3), true); + assert.strictEqual(_.isEqual(array1, array3), true); + }); + + QUnit.test('should compare objects with circular references', function(assert) { + assert.expect(6); + + var object1 = {}, + object2 = {}; + + object1.a = object1; + object2.a = object2; + + assert.strictEqual(_.isEqual(object1, object2), true); + + object1.b = 0; + object2.b = Object(0); + + assert.strictEqual(_.isEqual(object1, object2), true); + + object1.c = Object(1); + object2.c = Object(2); + + assert.strictEqual(_.isEqual(object1, object2), false); + + object1 = { 'a': 1, 'b': 2, 'c': 3 }; + object1.b = object1; + object2 = { 'a': 1, 'b': { 'a': 1, 'b': 2, 'c': 3 }, 'c': 3 }; + + assert.strictEqual(_.isEqual(object1, object2), false); + + object1 = {self: {self: {self: {}}}}; + object1.self.self.self = object1; + object2 = {self: {}}; + object2.self = object2; + + assert.strictEqual(_.isEqual(object1, object2), false); + assert.strictEqual(_.isEqual(object2, object1), false); + }); + + QUnit.test('should have transitive equivalence for circular references of objects', function(assert) { + assert.expect(3); + + var object1 = {}, + object2 = { 'a': object1 }, + object3 = { 'a': object2 }; + + object1.a = object1; + + assert.strictEqual(_.isEqual(object1, object2), true); + assert.strictEqual(_.isEqual(object2, object3), true); + assert.strictEqual(_.isEqual(object1, object3), true); + }); + + QUnit.test('should compare objects with multiple circular references', function(assert) { + assert.expect(3); + + var array1 = [{}], + array2 = [{}]; + + (array1[0].a = array1).push(array1); + (array2[0].a = array2).push(array2); + + assert.strictEqual(_.isEqual(array1, array2), true); + + array1[0].b = 0; + array2[0].b = Object(0); + + assert.strictEqual(_.isEqual(array1, array2), true); + + array1[0].c = Object(1); + array2[0].c = Object(2); + + assert.strictEqual(_.isEqual(array1, array2), false); + }); + + QUnit.test('should compare objects with complex circular references', function(assert) { + assert.expect(1); + + var object1 = { + 'foo': { 'b': { 'c': { 'd': {} } } }, + 'bar': { 'a': 2 } + }; + + var object2 = { + 'foo': { 'b': { 'c': { 'd': {} } } }, + 'bar': { 'a': 2 } + }; + + object1.foo.b.c.d = object1; + object1.bar.b = object1.foo.b; + + object2.foo.b.c.d = object2; + object2.bar.b = object2.foo.b; + + assert.strictEqual(_.isEqual(object1, object2), true); + }); + + QUnit.test('should compare objects with shared property values', function(assert) { + assert.expect(1); + + var object1 = { + 'a': [1, 2] + }; + + var object2 = { + 'a': [1, 2], + 'b': [1, 2] + }; + + object1.b = object1.a; + + assert.strictEqual(_.isEqual(object1, object2), true); + }); + + QUnit.test('should treat objects created by `Object.create(null)` like plain objects', function(assert) { + assert.expect(2); + + function Foo() { + this.a = 1; + } + Foo.prototype.constructor = null; + + var object1 = create(null); + object1.a = 1; + + var object2 = { 'a': 1 }; + + assert.strictEqual(_.isEqual(object1, object2), true); + assert.strictEqual(_.isEqual(new Foo, object2), false); + }); + + QUnit.test('should avoid common type coercions', function(assert) { + assert.expect(9); + + assert.strictEqual(_.isEqual(true, Object(false)), false); + assert.strictEqual(_.isEqual(Object(false), Object(0)), false); + assert.strictEqual(_.isEqual(false, Object('')), false); + assert.strictEqual(_.isEqual(Object(36), Object('36')), false); + assert.strictEqual(_.isEqual(0, ''), false); + assert.strictEqual(_.isEqual(1, true), false); + assert.strictEqual(_.isEqual(1337756400000, new Date(2012, 4, 23)), false); + assert.strictEqual(_.isEqual('36', 36), false); + assert.strictEqual(_.isEqual(36, '36'), false); + }); + + QUnit.test('should compare `arguments` objects', function(assert) { + assert.expect(2); + + var args1 = (function() { return arguments; }()), + args2 = (function() { return arguments; }()), + args3 = (function() { return arguments; }(1, 2)); + + assert.strictEqual(_.isEqual(args1, args2), true); + assert.strictEqual(_.isEqual(args1, args3), false); + }); + + QUnit.test('should treat `arguments` objects like `Object` objects', function(assert) { + assert.expect(4); + + var object = { '0': 1, '1': 2, '2': 3 }; + + function Foo() {} + Foo.prototype = object; + + assert.strictEqual(_.isEqual(args, object), true); + assert.strictEqual(_.isEqual(object, args), true); + assert.strictEqual(_.isEqual(args, new Foo), false); + assert.strictEqual(_.isEqual(new Foo, args), false); + }); + + QUnit.test('should compare array buffers', function(assert) { + assert.expect(2); + + if (ArrayBuffer) { + var buffer = new Int8Array([-1]).buffer; + + assert.strictEqual(_.isEqual(buffer, new Uint8Array([255]).buffer), true); + assert.strictEqual(_.isEqual(buffer, new ArrayBuffer(1)), false); + } + else { + skipAssert(assert, 2); + } + }); + + QUnit.test('should compare array views', function(assert) { + assert.expect(2); + + lodashStable.times(2, function(index) { + var ns = index ? realm : root; + + var pairs = lodashStable.map(arrayViews, function(type, viewIndex) { + var otherType = arrayViews[(viewIndex + 1) % arrayViews.length], + CtorA = ns[type] || function(n) { this.n = n; }, + CtorB = ns[otherType] || function(n) { this.n = n; }, + bufferA = ns[type] ? new ns.ArrayBuffer(8) : 8, + bufferB = ns[otherType] ? new ns.ArrayBuffer(8) : 8, + bufferC = ns[otherType] ? new ns.ArrayBuffer(16) : 16; + + return [new CtorA(bufferA), new CtorA(bufferA), new CtorB(bufferB), new CtorB(bufferC)]; + }); + + var expected = lodashStable.map(pairs, lodashStable.constant([true, false, false])); + + var actual = lodashStable.map(pairs, function(pair) { + return [_.isEqual(pair[0], pair[1]), _.isEqual(pair[0], pair[2]), _.isEqual(pair[2], pair[3])]; + }); + + assert.deepEqual(actual, expected); + }); + }); + + QUnit.test('should compare buffers', function(assert) { + assert.expect(3); + + if (Buffer) { + var buffer = new Buffer([1]); + + assert.strictEqual(_.isEqual(buffer, new Buffer([1])), true); + assert.strictEqual(_.isEqual(buffer, new Buffer([2])), false); + assert.strictEqual(_.isEqual(buffer, new Uint8Array([1])), false); + } + else { + skipAssert(assert, 3); + } + }); + + QUnit.test('should compare date objects', function(assert) { + assert.expect(4); + + var date = new Date(2012, 4, 23); + + assert.strictEqual(_.isEqual(date, new Date(2012, 4, 23)), true); + assert.strictEqual(_.isEqual(new Date('a'), new Date('b')), true); + assert.strictEqual(_.isEqual(date, new Date(2013, 3, 25)), false); + assert.strictEqual(_.isEqual(date, { 'getTime': lodashStable.constant(+date) }), false); + }); + + QUnit.test('should compare error objects', function(assert) { + assert.expect(1); + + var pairs = lodashStable.map([ + 'Error', + 'EvalError', + 'RangeError', + 'ReferenceError', + 'SyntaxError', + 'TypeError', + 'URIError' + ], function(type, index, errorTypes) { + var otherType = errorTypes[++index % errorTypes.length], + CtorA = root[type], + CtorB = root[otherType]; + + return [new CtorA('a'), new CtorA('a'), new CtorB('a'), new CtorB('b')]; + }); + + var expected = lodashStable.map(pairs, lodashStable.constant([true, false, false])); + + var actual = lodashStable.map(pairs, function(pair) { + return [_.isEqual(pair[0], pair[1]), _.isEqual(pair[0], pair[2]), _.isEqual(pair[2], pair[3])]; + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should compare functions', function(assert) { + assert.expect(2); + + function a() { return 1 + 2; } + function b() { return 1 + 2; } + + assert.strictEqual(_.isEqual(a, a), true); + assert.strictEqual(_.isEqual(a, b), false); + }); + + QUnit.test('should compare maps', function(assert) { + assert.expect(8); + + if (Map) { + lodashStable.each([[map, new Map], [map, realm.map]], function(maps) { + var map1 = maps[0], + map2 = maps[1]; + + map1.set('a', 1); + map2.set('b', 2); + assert.strictEqual(_.isEqual(map1, map2), false); + + map1.set('b', 2); + map2.set('a', 1); + assert.strictEqual(_.isEqual(map1, map2), true); + + map1.delete('a'); + map1.set('a', 1); + assert.strictEqual(_.isEqual(map1, map2), true); + + map2.delete('a'); + assert.strictEqual(_.isEqual(map1, map2), false); + + map1.clear(); + map2.clear(); + }); + } + else { + skipAssert(assert, 8); + } + }); + + QUnit.test('should compare maps with circular references', function(assert) { + assert.expect(2); + + if (Map) { + var map1 = new Map, + map2 = new Map; + + map1.set('a', map1); + map2.set('a', map2); + assert.strictEqual(_.isEqual(map1, map2), true); + + map1.set('b', 1); + map2.set('b', 2); + assert.strictEqual(_.isEqual(map1, map2), false); + } + else { + skipAssert(assert, 2); + } + }); + + QUnit.test('should compare promises by reference', function(assert) { + assert.expect(4); + + if (promise) { + lodashStable.each([[promise, Promise.resolve(1)], [promise, realm.promise]], function(promises) { + var promise1 = promises[0], + promise2 = promises[1]; + + assert.strictEqual(_.isEqual(promise1, promise2), false); + assert.strictEqual(_.isEqual(promise1, promise1), true); + }); + } + else { + skipAssert(assert, 4); + } + }); + + QUnit.test('should compare regexes', function(assert) { + assert.expect(5); + + assert.strictEqual(_.isEqual(/x/gim, /x/gim), true); + assert.strictEqual(_.isEqual(/x/gim, /x/mgi), true); + assert.strictEqual(_.isEqual(/x/gi, /x/g), false); + assert.strictEqual(_.isEqual(/x/, /y/), false); + assert.strictEqual(_.isEqual(/x/g, { 'global': true, 'ignoreCase': false, 'multiline': false, 'source': 'x' }), false); + }); + + QUnit.test('should compare sets', function(assert) { + assert.expect(8); + + if (Set) { + lodashStable.each([[set, new Set], [set, realm.set]], function(sets) { + var set1 = sets[0], + set2 = sets[1]; + + set1.add(1); + set2.add(2); + assert.strictEqual(_.isEqual(set1, set2), false); + + set1.add(2); + set2.add(1); + assert.strictEqual(_.isEqual(set1, set2), true); + + set1.delete(1); + set1.add(1); + assert.strictEqual(_.isEqual(set1, set2), true); + + set2.delete(1); + assert.strictEqual(_.isEqual(set1, set2), false); + + set1.clear(); + set2.clear(); + }); + } + else { + skipAssert(assert, 8); + } + }); + + QUnit.test('should compare sets with circular references', function(assert) { + assert.expect(2); + + if (Set) { + var set1 = new Set, + set2 = new Set; + + set1.add(set1); + set2.add(set2); + assert.strictEqual(_.isEqual(set1, set2), true); + + set1.add(1); + set2.add(2); + assert.strictEqual(_.isEqual(set1, set2), false); + } + else { + skipAssert(assert, 2); + } + }); + + QUnit.test('should compare symbol properties', function(assert) { + assert.expect(3); + + if (Symbol) { + var object1 = { 'a': 1 }, + object2 = { 'a': 1 }; + + object1[symbol1] = { 'a': { 'b': 2 } }; + object2[symbol1] = { 'a': { 'b': 2 } }; + + defineProperty(object2, symbol2, { + 'configurable': true, + 'enumerable': false, + 'writable': true, + 'value': 2 + }); + + assert.strictEqual(_.isEqual(object1, object2), true); + + object2[symbol1] = { 'a': 1 }; + assert.strictEqual(_.isEqual(object1, object2), false); + + delete object2[symbol1]; + object2[Symbol('a')] = { 'a': { 'b': 2 } }; + assert.strictEqual(_.isEqual(object1, object2), false); + } + else { + skipAssert(assert, 3); + } + }); + + QUnit.test('should compare wrapped values', function(assert) { + assert.expect(32); + + var stamp = +new Date; + + var values = [ + [[1, 2], [1, 2], [1, 2, 3]], + [true, true, false], + [new Date(stamp), new Date(stamp), new Date(stamp - 100)], + [{ 'a': 1, 'b': 2 }, { 'a': 1, 'b': 2 }, { 'a': 1, 'b': 1 }], + [1, 1, 2], + [NaN, NaN, Infinity], + [/x/, /x/, /x/i], + ['a', 'a', 'A'] + ]; + + lodashStable.each(values, function(vals) { + if (!isNpm) { + var wrapped1 = _(vals[0]), + wrapped2 = _(vals[1]), + actual = wrapped1.isEqual(wrapped2); + + assert.strictEqual(actual, true); + assert.strictEqual(_.isEqual(_(actual), _(true)), true); + + wrapped1 = _(vals[0]); + wrapped2 = _(vals[2]); + + actual = wrapped1.isEqual(wrapped2); + assert.strictEqual(actual, false); + assert.strictEqual(_.isEqual(_(actual), _(false)), true); + } + else { + skipAssert(assert, 4); + } + }); + }); + + QUnit.test('should compare wrapped and non-wrapped values', function(assert) { + assert.expect(4); + + if (!isNpm) { + var object1 = _({ 'a': 1, 'b': 2 }), + object2 = { 'a': 1, 'b': 2 }; + + assert.strictEqual(object1.isEqual(object2), true); + assert.strictEqual(_.isEqual(object1, object2), true); + + object1 = _({ 'a': 1, 'b': 2 }); + object2 = { 'a': 1, 'b': 1 }; + + assert.strictEqual(object1.isEqual(object2), false); + assert.strictEqual(_.isEqual(object1, object2), false); + } + else { + skipAssert(assert, 4); + } + }); + + QUnit.test('should work as an iteratee for `_.every`', function(assert) { + assert.expect(1); + + var actual = lodashStable.every([1, 1, 1], lodashStable.partial(_.isEqual, 1)); + assert.ok(actual); + }); + + QUnit.test('should not error on DOM elements', function(assert) { + assert.expect(1); + + if (document) { + var element1 = document.createElement('div'), + element2 = element1.cloneNode(true); + + try { + assert.strictEqual(_.isEqual(element1, element2), false); + } catch (e) { + assert.ok(false, e.message); + } + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should return `true` for like-objects from different documents', function(assert) { + assert.expect(4); + + if (realm.object) { + assert.strictEqual(_.isEqual([1], realm.array), true); + assert.strictEqual(_.isEqual([2], realm.array), false); + assert.strictEqual(_.isEqual({ 'a': 1 }, realm.object), true); + assert.strictEqual(_.isEqual({ 'a': 2 }, realm.object), false); + } + else { + skipAssert(assert, 4); + } + }); + + QUnit.test('should return `false` for objects with custom `toString` methods', function(assert) { + assert.expect(1); + + var primitive, + object = { 'toString': function() { return primitive; } }, + values = [true, null, 1, 'a', undefined], + expected = lodashStable.map(values, stubFalse); + + var actual = lodashStable.map(values, function(value) { + primitive = value; + return _.isEqual(object, value); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should return an unwrapped value when implicitly chaining', function(assert) { + assert.expect(1); + + if (!isNpm) { + assert.strictEqual(_('a').isEqual('a'), true); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should return a wrapped value when explicitly chaining', function(assert) { + assert.expect(1); + + if (!isNpm) { + assert.ok(_('a').chain().isEqual('a') instanceof _); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isEqualWith'); + + (function() { + QUnit.test('should provide correct `customizer` arguments', function(assert) { + assert.expect(1); + + var argsList = [], + object1 = { 'a': [1, 2], 'b': null }, + object2 = { 'a': [1, 2], 'b': null }; + + object1.b = object2; + object2.b = object1; + + var expected = [ + [object1, object2], + [object1.a, object2.a, 'a', object1, object2], + [object1.a[0], object2.a[0], 0, object1.a, object2.a], + [object1.a[1], object2.a[1], 1, object1.a, object2.a], + [object1.b, object2.b, 'b', object1.b, object2.b] + ]; + + _.isEqualWith(object1, object2, function(assert) { + var length = arguments.length, + args = slice.call(arguments, 0, length - (length > 2 ? 1 : 0)); + + argsList.push(args); + }); + + assert.deepEqual(argsList, expected); + }); + + QUnit.test('should handle comparisons when `customizer` returns `undefined`', function(assert) { + assert.expect(3); + + assert.strictEqual(_.isEqualWith('a', 'a', noop), true); + assert.strictEqual(_.isEqualWith(['a'], ['a'], noop), true); + assert.strictEqual(_.isEqualWith({ '0': 'a' }, { '0': 'a' }, noop), true); + }); + + QUnit.test('should not handle comparisons when `customizer` returns `true`', function(assert) { + assert.expect(3); + + var customizer = function(value) { + return _.isString(value) || undefined; + }; + + assert.strictEqual(_.isEqualWith('a', 'b', customizer), true); + assert.strictEqual(_.isEqualWith(['a'], ['b'], customizer), true); + assert.strictEqual(_.isEqualWith({ '0': 'a' }, { '0': 'b' }, customizer), true); + }); + + QUnit.test('should not handle comparisons when `customizer` returns `false`', function(assert) { + assert.expect(3); + + var customizer = function(value) { + return _.isString(value) ? false : undefined; + }; + + assert.strictEqual(_.isEqualWith('a', 'a', customizer), false); + assert.strictEqual(_.isEqualWith(['a'], ['a'], customizer), false); + assert.strictEqual(_.isEqualWith({ '0': 'a' }, { '0': 'a' }, customizer), false); + }); + + QUnit.test('should return a boolean value even when `customizer` does not', function(assert) { + assert.expect(2); + + var actual = _.isEqualWith('a', 'b', stubC); + assert.strictEqual(actual, true); + + var values = _.without(falsey, undefined), + expected = lodashStable.map(values, stubFalse); + + actual = []; + lodashStable.each(values, function(value) { + actual.push(_.isEqualWith('a', 'a', lodashStable.constant(value))); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should ensure `customizer` is a function', function(assert) { + assert.expect(1); + + var array = [1, 2, 3], + eq = _.partial(_.isEqualWith, array), + actual = lodashStable.map([array, [1, 0, 3]], eq); + + assert.deepEqual(actual, [true, false]); + }); + + QUnit.test('should call `customizer` for values maps and sets', function(assert) { + assert.expect(2); + + var value = { 'a': { 'b': 2 } }; + + if (Map) { + var map1 = new Map; + map1.set('a', value); + + var map2 = new Map; + map2.set('a', value); + } + if (Set) { + var set1 = new Set; + set1.add(value); + + var set2 = new Set; + set2.add(value); + } + lodashStable.each([[map1, map2], [set1, set2]], function(pair, index) { + if (pair[0]) { + var argsList = [], + array = lodashStable.toArray(pair[0]); + + var expected = [ + [pair[0], pair[1]], + [array[0], array[0], 0, array, array], + [array[0][0], array[0][0], 0, array[0], array[0]], + [array[0][1], array[0][1], 1, array[0], array[0]] + ]; + + if (index) { + expected.length = 2; + } + _.isEqualWith(pair[0], pair[1], function() { + var length = arguments.length, + args = slice.call(arguments, 0, length - (length > 2 ? 1 : 0)); + + argsList.push(args); + }); + + assert.deepEqual(argsList, expected, index ? 'Set' : 'Map'); + } + else { + skipAssert(assert); + } + }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isError'); + + (function() { + QUnit.test('should return `true` for error objects', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(errors, stubTrue); + + var actual = lodashStable.map(errors, function(error) { + return _.isError(error) === true; + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should return `true` for subclassed values', function(assert) { + assert.expect(1); + + assert.strictEqual(_.isError(new CustomError('x')), true); + }); + + QUnit.test('should return `false` for non error objects', function(assert) { + assert.expect(12); + + var expected = lodashStable.map(falsey, stubFalse); + + var actual = lodashStable.map(falsey, function(value, index) { + return index ? _.isError(value) : _.isError(); + }); + + assert.deepEqual(actual, expected); + + assert.strictEqual(_.isError(args), false); + assert.strictEqual(_.isError([1, 2, 3]), false); + assert.strictEqual(_.isError(true), false); + assert.strictEqual(_.isError(new Date), false); + assert.strictEqual(_.isError(_), false); + assert.strictEqual(_.isError(slice), false); + assert.strictEqual(_.isError({ 'a': 1 }), false); + assert.strictEqual(_.isError(1), false); + assert.strictEqual(_.isError(/x/), false); + assert.strictEqual(_.isError('a'), false); + assert.strictEqual(_.isError(symbol), false); + }); + + QUnit.test('should return `false` for plain objects', function(assert) { + assert.expect(1); + + assert.strictEqual(_.isError({ 'name': 'Error', 'message': '' }), false); + }); + + QUnit.test('should work with an error object from another realm', function(assert) { + assert.expect(1); + + if (realm.errors) { + var expected = lodashStable.map(realm.errors, stubTrue); + + var actual = lodashStable.map(realm.errors, function(error) { + return _.isError(error) === true; + }); + + assert.deepEqual(actual, expected); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isFinite'); + + (function() { + QUnit.test('should return `true` for finite values', function(assert) { + assert.expect(1); + + var values = [0, 1, 3.14, -1], + expected = lodashStable.map(values, stubTrue), + actual = lodashStable.map(values, _.isFinite); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should return `false` for non-finite values', function(assert) { + assert.expect(1); + + var values = [NaN, Infinity, -Infinity, Object(1)], + expected = lodashStable.map(values, stubFalse), + actual = lodashStable.map(values, _.isFinite); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should return `false` for non-numeric values', function(assert) { + assert.expect(10); + + var values = [undefined, [], true, '', ' ', '2px'], + expected = lodashStable.map(values, stubFalse), + actual = lodashStable.map(values, _.isFinite); + + assert.deepEqual(actual, expected); + + assert.strictEqual(_.isFinite(args), false); + assert.strictEqual(_.isFinite([1, 2, 3]), false); + assert.strictEqual(_.isFinite(true), false); + assert.strictEqual(_.isFinite(new Date), false); + assert.strictEqual(_.isFinite(new Error), false); + assert.strictEqual(_.isFinite({ 'a': 1 }), false); + assert.strictEqual(_.isFinite(/x/), false); + assert.strictEqual(_.isFinite('a'), false); + assert.strictEqual(_.isFinite(symbol), false); + }); + + QUnit.test('should return `false` for numeric string values', function(assert) { + assert.expect(1); + + var values = ['2', '0', '08'], + expected = lodashStable.map(values, stubFalse), + actual = lodashStable.map(values, _.isFinite); + + assert.deepEqual(actual, expected); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isFunction'); + + (function() { + QUnit.test('should return `true` for functions', function(assert) { + assert.expect(2); + + assert.strictEqual(_.isFunction(_), true); + assert.strictEqual(_.isFunction(slice), true); + }); + + QUnit.test('should return `true` for async functions', function(assert) { + assert.expect(1); + + assert.strictEqual(_.isFunction(asyncFunc), typeof asyncFunc == 'function'); + }); + + QUnit.test('should return `true` for generator functions', function(assert) { + assert.expect(1); + + assert.strictEqual(_.isFunction(genFunc), typeof genFunc == 'function'); + }); + + QUnit.test('should return `true` for the `Proxy` constructor', function(assert) { + assert.expect(1); + + if (Proxy) { + assert.strictEqual(_.isFunction(Proxy), true); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should return `true` for array view constructors', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(arrayViews, function(type) { + return objToString.call(root[type]) == funcTag; + }); + + var actual = lodashStable.map(arrayViews, function(type) { + return _.isFunction(root[type]); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should return `false` for non-functions', function(assert) { + assert.expect(12); + + var expected = lodashStable.map(falsey, stubFalse); + + var actual = lodashStable.map(falsey, function(value, index) { + return index ? _.isFunction(value) : _.isFunction(); + }); + + assert.deepEqual(actual, expected); + + assert.strictEqual(_.isFunction(args), false); + assert.strictEqual(_.isFunction([1, 2, 3]), false); + assert.strictEqual(_.isFunction(true), false); + assert.strictEqual(_.isFunction(new Date), false); + assert.strictEqual(_.isFunction(new Error), false); + assert.strictEqual(_.isFunction({ 'a': 1 }), false); + assert.strictEqual(_.isFunction(1), false); + assert.strictEqual(_.isFunction(/x/), false); + assert.strictEqual(_.isFunction('a'), false); + assert.strictEqual(_.isFunction(symbol), false); + + if (document) { + assert.strictEqual(_.isFunction(document.getElementsByTagName('body')), false); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should work with a function from another realm', function(assert) { + assert.expect(1); + + if (realm.function) { + assert.strictEqual(_.isFunction(realm.function), true); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('isInteger methods'); + + lodashStable.each(['isInteger', 'isSafeInteger'], function(methodName) { + var func = _[methodName], + isSafe = methodName == 'isSafeInteger'; + + QUnit.test('`_.' + methodName + '` should return `true` for integer values', function(assert) { + assert.expect(2); + + var values = [-1, 0, 1], + expected = lodashStable.map(values, stubTrue); + + var actual = lodashStable.map(values, function(value) { + return func(value); + }); + + assert.deepEqual(actual, expected); + assert.strictEqual(func(MAX_INTEGER), !isSafe); + }); + + QUnit.test('should return `false` for non-integer number values', function(assert) { + assert.expect(1); + + var values = [NaN, Infinity, -Infinity, Object(1), 3.14], + expected = lodashStable.map(values, stubFalse); + + var actual = lodashStable.map(values, function(value) { + return func(value); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should return `false` for non-numeric values', function(assert) { + assert.expect(10); + + var expected = lodashStable.map(falsey, function(value) { + return value === 0; + }); + + var actual = lodashStable.map(falsey, function(value, index) { + return index ? func(value) : func(); + }); + + assert.deepEqual(actual, expected); + + assert.strictEqual(func(args), false); + assert.strictEqual(func([1, 2, 3]), false); + assert.strictEqual(func(true), false); + assert.strictEqual(func(new Date), false); + assert.strictEqual(func(new Error), false); + assert.strictEqual(func({ 'a': 1 }), false); + assert.strictEqual(func(/x/), false); + assert.strictEqual(func('a'), false); + assert.strictEqual(func(symbol), false); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isLength'); + + (function() { + QUnit.test('should return `true` for lengths', function(assert) { + assert.expect(1); + + var values = [0, 3, MAX_SAFE_INTEGER], + expected = lodashStable.map(values, stubTrue), + actual = lodashStable.map(values, _.isLength); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should return `false` for non-lengths', function(assert) { + assert.expect(1); + + var values = [-1, '1', 1.1, MAX_SAFE_INTEGER + 1], + expected = lodashStable.map(values, stubFalse), + actual = lodashStable.map(values, _.isLength); + + assert.deepEqual(actual, expected); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isMap'); + + (function() { + QUnit.test('should return `true` for maps', function(assert) { + assert.expect(1); + + if (Map) { + assert.strictEqual(_.isMap(map), true); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should return `false` for non-maps', function(assert) { + assert.expect(14); + + var expected = lodashStable.map(falsey, stubFalse); + + var actual = lodashStable.map(falsey, function(value, index) { + return index ? _.isMap(value) : _.isMap(); + }); + + assert.deepEqual(actual, expected); + + assert.strictEqual(_.isMap(args), false); + assert.strictEqual(_.isMap([1, 2, 3]), false); + assert.strictEqual(_.isMap(true), false); + assert.strictEqual(_.isMap(new Date), false); + assert.strictEqual(_.isMap(new Error), false); + assert.strictEqual(_.isMap(_), false); + assert.strictEqual(_.isMap(slice), false); + assert.strictEqual(_.isMap({ 'a': 1 }), false); + assert.strictEqual(_.isMap(1), false); + assert.strictEqual(_.isMap(/x/), false); + assert.strictEqual(_.isMap('a'), false); + assert.strictEqual(_.isMap(symbol), false); + assert.strictEqual(_.isMap(weakMap), false); + }); + + QUnit.test('should work for objects with a non-function `constructor` (test in IE 11)', function(assert) { + assert.expect(1); + + var values = [false, true], + expected = lodashStable.map(values, stubFalse); + + var actual = lodashStable.map(values, function(value) { + return _.isMap({ 'constructor': value }); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should work with maps from another realm', function(assert) { + assert.expect(1); + + if (realm.map) { + assert.strictEqual(_.isMap(realm.map), true); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isMatchWith'); + + (function() { + QUnit.test('should provide correct `customizer` arguments', function(assert) { + assert.expect(1); + + var argsList = [], + object1 = { 'a': [1, 2], 'b': null }, + object2 = { 'a': [1, 2], 'b': null }; + + object1.b = object2; + object2.b = object1; + + var expected = [ + [object1.a, object2.a, 'a', object1, object2], + [object1.a[0], object2.a[0], 0, object1.a, object2.a], + [object1.a[1], object2.a[1], 1, object1.a, object2.a], + [object1.b, object2.b, 'b', object1, object2], + [object1.b.a, object2.b.a, 'a', object1.b, object2.b], + [object1.b.a[0], object2.b.a[0], 0, object1.b.a, object2.b.a], + [object1.b.a[1], object2.b.a[1], 1, object1.b.a, object2.b.a], + [object1.b.b, object2.b.b, 'b', object1.b, object2.b] + ]; + + _.isMatchWith(object1, object2, function(assert) { + argsList.push(slice.call(arguments, 0, -1)); + }); + + assert.deepEqual(argsList, expected); + }); + + QUnit.test('should handle comparisons when `customizer` returns `undefined`', function(assert) { + assert.expect(1); + + assert.strictEqual(_.isMatchWith({ 'a': 1 }, { 'a': 1 }, noop), true); + }); + + QUnit.test('should not handle comparisons when `customizer` returns `true`', function(assert) { + assert.expect(2); + + var customizer = function(value) { + return _.isString(value) || undefined; + }; + + assert.strictEqual(_.isMatchWith(['a'], ['b'], customizer), true); + assert.strictEqual(_.isMatchWith({ '0': 'a' }, { '0': 'b' }, customizer), true); + }); + + QUnit.test('should not handle comparisons when `customizer` returns `false`', function(assert) { + assert.expect(2); + + var customizer = function(value) { + return _.isString(value) ? false : undefined; + }; + + assert.strictEqual(_.isMatchWith(['a'], ['a'], customizer), false); + assert.strictEqual(_.isMatchWith({ '0': 'a' }, { '0': 'a' }, customizer), false); + }); + + QUnit.test('should return a boolean value even when `customizer` does not', function(assert) { + assert.expect(2); + + var object = { 'a': 1 }, + actual = _.isMatchWith(object, { 'a': 1 }, stubA); + + assert.strictEqual(actual, true); + + var expected = lodashStable.map(falsey, stubFalse); + + actual = []; + lodashStable.each(falsey, function(value) { + actual.push(_.isMatchWith(object, { 'a': 2 }, lodashStable.constant(value))); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should provide `stack` to `customizer`', function(assert) { + assert.expect(1); + + var actual; + + _.isMatchWith({ 'a': 1 }, { 'a': 1 }, function() { + actual = _.last(arguments); + }); + + assert.ok(isNpm + ? actual.constructor.name == 'Stack' + : actual instanceof mapCaches.Stack + ); + }); + + QUnit.test('should ensure `customizer` is a function', function(assert) { + assert.expect(1); + + var object = { 'a': 1 }, + matches = _.partial(_.isMatchWith, object), + actual = lodashStable.map([object, { 'a': 2 }], matches); + + assert.deepEqual(actual, [true, false]); + }); + + QUnit.test('should call `customizer` for values maps and sets', function(assert) { + assert.expect(2); + + var value = { 'a': { 'b': 2 } }; + + if (Map) { + var map1 = new Map; + map1.set('a', value); + + var map2 = new Map; + map2.set('a', value); + } + if (Set) { + var set1 = new Set; + set1.add(value); + + var set2 = new Set; + set2.add(value); + } + lodashStable.each([[map1, map2], [set1, set2]], function(pair, index) { + if (pair[0]) { + var argsList = [], + array = lodashStable.toArray(pair[0]), + object1 = { 'a': pair[0] }, + object2 = { 'a': pair[1] }; + + var expected = [ + [pair[0], pair[1], 'a', object1, object2], + [array[0], array[0], 0, array, array], + [array[0][0], array[0][0], 0, array[0], array[0]], + [array[0][1], array[0][1], 1, array[0], array[0]] + ]; + + if (index) { + expected.length = 2; + } + _.isMatchWith({ 'a': pair[0] }, { 'a': pair[1] }, function() { + argsList.push(slice.call(arguments, 0, -1)); + }); + + assert.deepEqual(argsList, expected, index ? 'Set' : 'Map'); + } + else { + skipAssert(assert); + } + }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isNaN'); + + (function() { + QUnit.test('should return `true` for NaNs', function(assert) { + assert.expect(2); + + assert.strictEqual(_.isNaN(NaN), true); + assert.strictEqual(_.isNaN(Object(NaN)), true); + }); + + QUnit.test('should return `false` for non-NaNs', function(assert) { + assert.expect(14); + + var expected = lodashStable.map(falsey, function(value) { + return value !== value; + }); + + var actual = lodashStable.map(falsey, function(value, index) { + return index ? _.isNaN(value) : _.isNaN(); + }); + + assert.deepEqual(actual, expected); + + assert.strictEqual(_.isNaN(args), false); + assert.strictEqual(_.isNaN([1, 2, 3]), false); + assert.strictEqual(_.isNaN(true), false); + assert.strictEqual(_.isNaN(new Date), false); + assert.strictEqual(_.isNaN(new Error), false); + assert.strictEqual(_.isNaN(_), false); + assert.strictEqual(_.isNaN(slice), false); + assert.strictEqual(_.isNaN({ 'a': 1 }), false); + assert.strictEqual(_.isNaN(1), false); + assert.strictEqual(_.isNaN(Object(1)), false); + assert.strictEqual(_.isNaN(/x/), false); + assert.strictEqual(_.isNaN('a'), false); + assert.strictEqual(_.isNaN(symbol), false); + }); + + QUnit.test('should work with `NaN` from another realm', function(assert) { + assert.expect(1); + + if (realm.object) { + assert.strictEqual(_.isNaN(realm.nan), true); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isNative'); + + (function() { + QUnit.test('should return `true` for native methods', function(assert) { + assert.expect(1); + + var values = [Array, body && body.cloneNode, create, root.encodeURI, Promise, slice, Uint8Array], + expected = lodashStable.map(values, Boolean), + actual = lodashStable.map(values, _.isNative); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should return `false` for non-native methods', function(assert) { + assert.expect(12); + + var expected = lodashStable.map(falsey, stubFalse); + + var actual = lodashStable.map(falsey, function(value, index) { + return index ? _.isNative(value) : _.isNative(); + }); + + assert.deepEqual(actual, expected); + + assert.strictEqual(_.isNative(args), false); + assert.strictEqual(_.isNative([1, 2, 3]), false); + assert.strictEqual(_.isNative(true), false); + assert.strictEqual(_.isNative(new Date), false); + assert.strictEqual(_.isNative(new Error), false); + assert.strictEqual(_.isNative(_), false); + assert.strictEqual(_.isNative({ 'a': 1 }), false); + assert.strictEqual(_.isNative(1), false); + assert.strictEqual(_.isNative(/x/), false); + assert.strictEqual(_.isNative('a'), false); + assert.strictEqual(_.isNative(symbol), false); + }); + + QUnit.test('should work with native functions from another realm', function(assert) { + assert.expect(2); + + if (realm.element) { + assert.strictEqual(_.isNative(realm.element.cloneNode), true); + } + else { + skipAssert(assert); + } + if (realm.object) { + assert.strictEqual(_.isNative(realm.object.valueOf), true); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should throw an error if core-js is detected', function(assert) { + assert.expect(1); + + if (!isModularize) { + var lodash = _.runInContext({ + '__core-js_shared__': {} + }); + + assert.raises(function() { lodash.isNative(noop); }); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should detect methods masquerading as native (test in Node.js)', function(assert) { + assert.expect(2); + + if (!amd && _._baseEach) { + var path = require('path'), + basePath = path.dirname(filePath), + uid = 'e0gvgyrad1jor', + coreKey = '__core-js_shared__', + fakeSrcKey = 'Symbol(src)_1.' + uid; + + root[coreKey] = { 'keys': { 'IE_PROTO': 'Symbol(IE_PROTO)_3.' + uid } }; + emptyObject(require.cache); + + var baseIsNative = interopRequire(path.join(basePath, '_baseIsNative')); + assert.strictEqual(baseIsNative(slice), true); + + slice[fakeSrcKey] = slice + ''; + assert.strictEqual(baseIsNative(slice), false); + + delete slice[fakeSrcKey]; + delete root[coreKey]; + } + else { + skipAssert(assert, 2); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isNil'); + + (function() { + QUnit.test('should return `true` for nullish values', function(assert) { + assert.expect(3); + + assert.strictEqual(_.isNil(null), true); + assert.strictEqual(_.isNil(), true); + assert.strictEqual(_.isNil(undefined), true); + }); + + QUnit.test('should return `false` for non-nullish values', function(assert) { + assert.expect(13); + + var expected = lodashStable.map(falsey, function(value) { + return value == null; + }); + + var actual = lodashStable.map(falsey, function(value, index) { + return index ? _.isNil(value) : _.isNil(); + }); + + assert.deepEqual(actual, expected); + + assert.strictEqual(_.isNil(args), false); + assert.strictEqual(_.isNil([1, 2, 3]), false); + assert.strictEqual(_.isNil(true), false); + assert.strictEqual(_.isNil(new Date), false); + assert.strictEqual(_.isNil(new Error), false); + assert.strictEqual(_.isNil(_), false); + assert.strictEqual(_.isNil(slice), false); + assert.strictEqual(_.isNil({ 'a': 1 }), false); + assert.strictEqual(_.isNil(1), false); + assert.strictEqual(_.isNil(/x/), false); + assert.strictEqual(_.isNil('a'), false); + + if (Symbol) { + assert.strictEqual(_.isNil(symbol), false); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should work with nils from another realm', function(assert) { + assert.expect(2); + + if (realm.object) { + assert.strictEqual(_.isNil(realm.null), true); + assert.strictEqual(_.isNil(realm.undefined), true); + } + else { + skipAssert(assert, 2); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isNull'); + + (function() { + QUnit.test('should return `true` for `null` values', function(assert) { + assert.expect(1); + + assert.strictEqual(_.isNull(null), true); + }); + + QUnit.test('should return `false` for non `null` values', function(assert) { + assert.expect(13); + + var expected = lodashStable.map(falsey, function(value) { + return value === null; + }); + + var actual = lodashStable.map(falsey, function(value, index) { + return index ? _.isNull(value) : _.isNull(); + }); + + assert.deepEqual(actual, expected); + + assert.strictEqual(_.isNull(args), false); + assert.strictEqual(_.isNull([1, 2, 3]), false); + assert.strictEqual(_.isNull(true), false); + assert.strictEqual(_.isNull(new Date), false); + assert.strictEqual(_.isNull(new Error), false); + assert.strictEqual(_.isNull(_), false); + assert.strictEqual(_.isNull(slice), false); + assert.strictEqual(_.isNull({ 'a': 1 }), false); + assert.strictEqual(_.isNull(1), false); + assert.strictEqual(_.isNull(/x/), false); + assert.strictEqual(_.isNull('a'), false); + assert.strictEqual(_.isNull(symbol), false); + }); + + QUnit.test('should work with nulls from another realm', function(assert) { + assert.expect(1); + + if (realm.object) { + assert.strictEqual(_.isNull(realm.null), true); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isNumber'); + + (function() { + QUnit.test('should return `true` for numbers', function(assert) { + assert.expect(3); + + assert.strictEqual(_.isNumber(0), true); + assert.strictEqual(_.isNumber(Object(0)), true); + assert.strictEqual(_.isNumber(NaN), true); + }); + + QUnit.test('should return `false` for non-numbers', function(assert) { + assert.expect(12); + + var expected = lodashStable.map(falsey, function(value) { + return typeof value == 'number'; + }); + + var actual = lodashStable.map(falsey, function(value, index) { + return index ? _.isNumber(value) : _.isNumber(); + }); + + assert.deepEqual(actual, expected); + + assert.strictEqual(_.isNumber(args), false); + assert.strictEqual(_.isNumber([1, 2, 3]), false); + assert.strictEqual(_.isNumber(true), false); + assert.strictEqual(_.isNumber(new Date), false); + assert.strictEqual(_.isNumber(new Error), false); + assert.strictEqual(_.isNumber(_), false); + assert.strictEqual(_.isNumber(slice), false); + assert.strictEqual(_.isNumber({ 'a': 1 }), false); + assert.strictEqual(_.isNumber(/x/), false); + assert.strictEqual(_.isNumber('a'), false); + assert.strictEqual(_.isNumber(symbol), false); + }); + + QUnit.test('should work with numbers from another realm', function(assert) { + assert.expect(1); + + if (realm.number) { + assert.strictEqual(_.isNumber(realm.number), true); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isObject'); + + (function() { + QUnit.test('should return `true` for objects', function(assert) { + assert.expect(13); + + assert.strictEqual(_.isObject(args), true); + assert.strictEqual(_.isObject([1, 2, 3]), true); + assert.strictEqual(_.isObject(Object(false)), true); + assert.strictEqual(_.isObject(new Date), true); + assert.strictEqual(_.isObject(new Error), true); + assert.strictEqual(_.isObject(_), true); + assert.strictEqual(_.isObject(slice), true); + assert.strictEqual(_.isObject({ 'a': 1 }), true); + assert.strictEqual(_.isObject(Object(0)), true); + assert.strictEqual(_.isObject(/x/), true); + assert.strictEqual(_.isObject(Object('a')), true); + + if (document) { + assert.strictEqual(_.isObject(body), true); + } + else { + skipAssert(assert); + } + if (Symbol) { + assert.strictEqual(_.isObject(Object(symbol)), true); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should return `false` for non-objects', function(assert) { + assert.expect(1); + + var values = falsey.concat(true, 1, 'a', symbol), + expected = lodashStable.map(values, stubFalse); + + var actual = lodashStable.map(values, function(value, index) { + return index ? _.isObject(value) : _.isObject(); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should work with objects from another realm', function(assert) { + assert.expect(8); + + if (realm.element) { + assert.strictEqual(_.isObject(realm.element), true); + } + else { + skipAssert(assert); + } + if (realm.object) { + assert.strictEqual(_.isObject(realm.boolean), true); + assert.strictEqual(_.isObject(realm.date), true); + assert.strictEqual(_.isObject(realm.function), true); + assert.strictEqual(_.isObject(realm.number), true); + assert.strictEqual(_.isObject(realm.object), true); + assert.strictEqual(_.isObject(realm.regexp), true); + assert.strictEqual(_.isObject(realm.string), true); + } + else { + skipAssert(assert, 7); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isObjectLike'); + + (function() { + QUnit.test('should return `true` for objects', function(assert) { + assert.expect(9); + + assert.strictEqual(_.isObjectLike(args), true); + assert.strictEqual(_.isObjectLike([1, 2, 3]), true); + assert.strictEqual(_.isObjectLike(Object(false)), true); + assert.strictEqual(_.isObjectLike(new Date), true); + assert.strictEqual(_.isObjectLike(new Error), true); + assert.strictEqual(_.isObjectLike({ 'a': 1 }), true); + assert.strictEqual(_.isObjectLike(Object(0)), true); + assert.strictEqual(_.isObjectLike(/x/), true); + assert.strictEqual(_.isObjectLike(Object('a')), true); + }); + + QUnit.test('should return `false` for non-objects', function(assert) { + assert.expect(1); + + var values = falsey.concat(true, _, slice, 1, 'a', symbol), + expected = lodashStable.map(values, stubFalse); + + var actual = lodashStable.map(values, function(value, index) { + return index ? _.isObjectLike(value) : _.isObjectLike(); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should work with objects from another realm', function(assert) { + assert.expect(6); + + if (realm.object) { + assert.strictEqual(_.isObjectLike(realm.boolean), true); + assert.strictEqual(_.isObjectLike(realm.date), true); + assert.strictEqual(_.isObjectLike(realm.number), true); + assert.strictEqual(_.isObjectLike(realm.object), true); + assert.strictEqual(_.isObjectLike(realm.regexp), true); + assert.strictEqual(_.isObjectLike(realm.string), true); + } + else { + skipAssert(assert, 6); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isPlainObject'); + + (function() { + var element = document && document.createElement('div'); + + QUnit.test('should detect plain objects', function(assert) { + assert.expect(5); + + function Foo(a) { + this.a = 1; + } + + assert.strictEqual(_.isPlainObject({}), true); + assert.strictEqual(_.isPlainObject({ 'a': 1 }), true); + assert.strictEqual(_.isPlainObject({ 'constructor': Foo }), true); + assert.strictEqual(_.isPlainObject([1, 2, 3]), false); + assert.strictEqual(_.isPlainObject(new Foo(1)), false); + }); + + QUnit.test('should return `true` for objects with a `[[Prototype]]` of `null`', function(assert) { + assert.expect(2); + + var object = create(null); + assert.strictEqual(_.isPlainObject(object), true); + + object.constructor = objectProto.constructor; + assert.strictEqual(_.isPlainObject(object), true); + }); + + QUnit.test('should return `true` for objects with a `valueOf` property', function(assert) { + assert.expect(1); + + assert.strictEqual(_.isPlainObject({ 'valueOf': 0 }), true); + }); + + QUnit.test('should return `true` for objects with a writable `Symbol.toStringTag` property', function(assert) { + assert.expect(1); + + if (Symbol && Symbol.toStringTag) { + var object = {}; + object[Symbol.toStringTag] = 'X'; + + assert.deepEqual(_.isPlainObject(object), true); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should return `false` for objects with a custom `[[Prototype]]`', function(assert) { + assert.expect(1); + + var object = create({ 'a': 1 }); + assert.strictEqual(_.isPlainObject(object), false); + }); + + QUnit.test('should return `false` for DOM elements', function(assert) { + assert.expect(1); + + if (element) { + assert.strictEqual(_.isPlainObject(element), false); + } else { + skipAssert(assert); + } + }); + + QUnit.test('should return `false` for non-Object objects', function(assert) { + assert.expect(3); + + assert.strictEqual(_.isPlainObject(arguments), false); + assert.strictEqual(_.isPlainObject(Error), false); + assert.strictEqual(_.isPlainObject(Math), false); + }); + + QUnit.test('should return `false` for non-objects', function(assert) { + assert.expect(4); + + var expected = lodashStable.map(falsey, stubFalse); + + var actual = lodashStable.map(falsey, function(value, index) { + return index ? _.isPlainObject(value) : _.isPlainObject(); + }); + + assert.deepEqual(actual, expected); + + assert.strictEqual(_.isPlainObject(true), false); + assert.strictEqual(_.isPlainObject('a'), false); + assert.strictEqual(_.isPlainObject(symbol), false); + }); + + QUnit.test('should return `false` for objects with a read-only `Symbol.toStringTag` property', function(assert) { + assert.expect(1); + + if (Symbol && Symbol.toStringTag) { + var object = {}; + defineProperty(object, Symbol.toStringTag, { + 'configurable': true, + 'enumerable': false, + 'writable': false, + 'value': 'X' + }); + + assert.deepEqual(_.isPlainObject(object), false); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should not mutate `value`', function(assert) { + assert.expect(2); + + if (Symbol && Symbol.toStringTag) { + var proto = {}; + proto[Symbol.toStringTag] = undefined; + var object = create(proto); + + assert.strictEqual(_.isPlainObject(object), false); + assert.notOk(lodashStable.has(object, Symbol.toStringTag)); + } + else { + skipAssert(assert, 2); + } + }); + + QUnit.test('should work with objects from another realm', function(assert) { + assert.expect(1); + + if (realm.object) { + assert.strictEqual(_.isPlainObject(realm.object), true); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isRegExp'); + + (function() { + QUnit.test('should return `true` for regexes', function(assert) { + assert.expect(2); + + assert.strictEqual(_.isRegExp(/x/), true); + assert.strictEqual(_.isRegExp(RegExp('x')), true); + }); + + QUnit.test('should return `false` for non-regexes', function(assert) { + assert.expect(12); + + var expected = lodashStable.map(falsey, stubFalse); + + var actual = lodashStable.map(falsey, function(value, index) { + return index ? _.isRegExp(value) : _.isRegExp(); + }); + + assert.deepEqual(actual, expected); + + assert.strictEqual(_.isRegExp(args), false); + assert.strictEqual(_.isRegExp([1, 2, 3]), false); + assert.strictEqual(_.isRegExp(true), false); + assert.strictEqual(_.isRegExp(new Date), false); + assert.strictEqual(_.isRegExp(new Error), false); + assert.strictEqual(_.isRegExp(_), false); + assert.strictEqual(_.isRegExp(slice), false); + assert.strictEqual(_.isRegExp({ 'a': 1 }), false); + assert.strictEqual(_.isRegExp(1), false); + assert.strictEqual(_.isRegExp('a'), false); + assert.strictEqual(_.isRegExp(symbol), false); + }); + + QUnit.test('should work with regexes from another realm', function(assert) { + assert.expect(1); + + if (realm.regexp) { + assert.strictEqual(_.isRegExp(realm.regexp), true); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isSet'); + + (function() { + QUnit.test('should return `true` for sets', function(assert) { + assert.expect(1); + + if (Set) { + assert.strictEqual(_.isSet(set), true); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should return `false` for non-sets', function(assert) { + assert.expect(14); + + var expected = lodashStable.map(falsey, stubFalse); + + var actual = lodashStable.map(falsey, function(value, index) { + return index ? _.isSet(value) : _.isSet(); + }); + + assert.deepEqual(actual, expected); + + assert.strictEqual(_.isSet(args), false); + assert.strictEqual(_.isSet([1, 2, 3]), false); + assert.strictEqual(_.isSet(true), false); + assert.strictEqual(_.isSet(new Date), false); + assert.strictEqual(_.isSet(new Error), false); + assert.strictEqual(_.isSet(_), false); + assert.strictEqual(_.isSet(slice), false); + assert.strictEqual(_.isSet({ 'a': 1 }), false); + assert.strictEqual(_.isSet(1), false); + assert.strictEqual(_.isSet(/x/), false); + assert.strictEqual(_.isSet('a'), false); + assert.strictEqual(_.isSet(symbol), false); + assert.strictEqual(_.isSet(weakSet), false); + }); + + QUnit.test('should work for objects with a non-function `constructor` (test in IE 11)', function(assert) { + assert.expect(1); + + var values = [false, true], + expected = lodashStable.map(values, stubFalse); + + var actual = lodashStable.map(values, function(value) { + return _.isSet({ 'constructor': value }); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should work with weak sets from another realm', function(assert) { + assert.expect(1); + + if (realm.set) { + assert.strictEqual(_.isSet(realm.set), true); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isString'); + + (function() { + QUnit.test('should return `true` for strings', function(assert) { + assert.expect(2); + + assert.strictEqual(_.isString('a'), true); + assert.strictEqual(_.isString(Object('a')), true); + }); + + QUnit.test('should return `false` for non-strings', function(assert) { + assert.expect(12); + + var expected = lodashStable.map(falsey, function(value) { + return value === ''; + }); + + var actual = lodashStable.map(falsey, function(value, index) { + return index ? _.isString(value) : _.isString(); + }); + + assert.deepEqual(actual, expected); + + assert.strictEqual(_.isString(args), false); + assert.strictEqual(_.isString([1, 2, 3]), false); + assert.strictEqual(_.isString(true), false); + assert.strictEqual(_.isString(new Date), false); + assert.strictEqual(_.isString(new Error), false); + assert.strictEqual(_.isString(_), false); + assert.strictEqual(_.isString(slice), false); + assert.strictEqual(_.isString({ '0': 1, 'length': 1 }), false); + assert.strictEqual(_.isString(1), false); + assert.strictEqual(_.isString(/x/), false); + assert.strictEqual(_.isString(symbol), false); + }); + + QUnit.test('should work with strings from another realm', function(assert) { + assert.expect(1); + + if (realm.string) { + assert.strictEqual(_.isString(realm.string), true); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isSymbol'); + + (function() { + QUnit.test('should return `true` for symbols', function(assert) { + assert.expect(2); + + if (Symbol) { + assert.strictEqual(_.isSymbol(symbol), true); + assert.strictEqual(_.isSymbol(Object(symbol)), true); + } + else { + skipAssert(assert, 2); + } + }); + + QUnit.test('should return `false` for non-symbols', function(assert) { + assert.expect(12); + + var expected = lodashStable.map(falsey, stubFalse); + + var actual = lodashStable.map(falsey, function(value, index) { + return index ? _.isSymbol(value) : _.isSymbol(); + }); + + assert.deepEqual(actual, expected); + + assert.strictEqual(_.isSymbol(args), false); + assert.strictEqual(_.isSymbol([1, 2, 3]), false); + assert.strictEqual(_.isSymbol(true), false); + assert.strictEqual(_.isSymbol(new Date), false); + assert.strictEqual(_.isSymbol(new Error), false); + assert.strictEqual(_.isSymbol(_), false); + assert.strictEqual(_.isSymbol(slice), false); + assert.strictEqual(_.isSymbol({ '0': 1, 'length': 1 }), false); + assert.strictEqual(_.isSymbol(1), false); + assert.strictEqual(_.isSymbol(/x/), false); + assert.strictEqual(_.isSymbol('a'), false); + }); + + QUnit.test('should work with symbols from another realm', function(assert) { + assert.expect(1); + + if (Symbol && realm.symbol) { + assert.strictEqual(_.isSymbol(realm.symbol), true); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isTypedArray'); + + (function() { + QUnit.test('should return `true` for typed arrays', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(typedArrays, function(type) { + return type in root; + }); + + var actual = lodashStable.map(typedArrays, function(type) { + var Ctor = root[type]; + return Ctor ? _.isTypedArray(new Ctor(new ArrayBuffer(8))) : false; + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should return `false` for non typed arrays', function(assert) { + assert.expect(13); + + var expected = lodashStable.map(falsey, stubFalse); + + var actual = lodashStable.map(falsey, function(value, index) { + return index ? _.isTypedArray(value) : _.isTypedArray(); + }); + + assert.deepEqual(actual, expected); + + assert.strictEqual(_.isTypedArray(args), false); + assert.strictEqual(_.isTypedArray([1, 2, 3]), false); + assert.strictEqual(_.isTypedArray(true), false); + assert.strictEqual(_.isTypedArray(new Date), false); + assert.strictEqual(_.isTypedArray(new Error), false); + assert.strictEqual(_.isTypedArray(_), false); + assert.strictEqual(_.isTypedArray(slice), false); + assert.strictEqual(_.isTypedArray({ 'a': 1 }), false); + assert.strictEqual(_.isTypedArray(1), false); + assert.strictEqual(_.isTypedArray(/x/), false); + assert.strictEqual(_.isTypedArray('a'), false); + assert.strictEqual(_.isTypedArray(symbol), false); + }); + + QUnit.test('should work with typed arrays from another realm', function(assert) { + assert.expect(1); + + if (realm.object) { + var props = lodashStable.invokeMap(typedArrays, 'toLowerCase'); + + var expected = lodashStable.map(props, function(key) { + return realm[key] !== undefined; + }); + + var actual = lodashStable.map(props, function(key) { + var value = realm[key]; + return value ? _.isTypedArray(value) : false; + }); + + assert.deepEqual(actual, expected); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isUndefined'); + + (function() { + QUnit.test('should return `true` for `undefined` values', function(assert) { + assert.expect(2); + + assert.strictEqual(_.isUndefined(), true); + assert.strictEqual(_.isUndefined(undefined), true); + }); + + QUnit.test('should return `false` for non `undefined` values', function(assert) { + assert.expect(13); + + var expected = lodashStable.map(falsey, function(value) { + return value === undefined; + }); + + var actual = lodashStable.map(falsey, function(value, index) { + return index ? _.isUndefined(value) : _.isUndefined(); + }); + + assert.deepEqual(actual, expected); + + assert.strictEqual(_.isUndefined(args), false); + assert.strictEqual(_.isUndefined([1, 2, 3]), false); + assert.strictEqual(_.isUndefined(true), false); + assert.strictEqual(_.isUndefined(new Date), false); + assert.strictEqual(_.isUndefined(new Error), false); + assert.strictEqual(_.isUndefined(_), false); + assert.strictEqual(_.isUndefined(slice), false); + assert.strictEqual(_.isUndefined({ 'a': 1 }), false); + assert.strictEqual(_.isUndefined(1), false); + assert.strictEqual(_.isUndefined(/x/), false); + assert.strictEqual(_.isUndefined('a'), false); + + if (Symbol) { + assert.strictEqual(_.isUndefined(symbol), false); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should work with `undefined` from another realm', function(assert) { + assert.expect(1); + + if (realm.object) { + assert.strictEqual(_.isUndefined(realm.undefined), true); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isWeakMap'); + + (function() { + QUnit.test('should return `true` for weak maps', function(assert) { + assert.expect(1); + + if (WeakMap) { + assert.strictEqual(_.isWeakMap(weakMap), true); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should return `false` for non weak maps', function(assert) { + assert.expect(14); + + var expected = lodashStable.map(falsey, stubFalse); + + var actual = lodashStable.map(falsey, function(value, index) { + return index ? _.isWeakMap(value) : _.isWeakMap(); + }); + + assert.deepEqual(actual, expected); + + assert.strictEqual(_.isWeakMap(args), false); + assert.strictEqual(_.isWeakMap([1, 2, 3]), false); + assert.strictEqual(_.isWeakMap(true), false); + assert.strictEqual(_.isWeakMap(new Date), false); + assert.strictEqual(_.isWeakMap(new Error), false); + assert.strictEqual(_.isWeakMap(_), false); + assert.strictEqual(_.isWeakMap(slice), false); + assert.strictEqual(_.isWeakMap({ 'a': 1 }), false); + assert.strictEqual(_.isWeakMap(map), false); + assert.strictEqual(_.isWeakMap(1), false); + assert.strictEqual(_.isWeakMap(/x/), false); + assert.strictEqual(_.isWeakMap('a'), false); + assert.strictEqual(_.isWeakMap(symbol), false); + }); + + QUnit.test('should work for objects with a non-function `constructor` (test in IE 11)', function(assert) { + assert.expect(1); + + var values = [false, true], + expected = lodashStable.map(values, stubFalse); + + var actual = lodashStable.map(values, function(value) { + return _.isWeakMap({ 'constructor': value }); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should work with weak maps from another realm', function(assert) { + assert.expect(1); + + if (realm.weakMap) { + assert.strictEqual(_.isWeakMap(realm.weakMap), true); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.isWeakSet'); + + (function() { + QUnit.test('should return `true` for weak sets', function(assert) { + assert.expect(1); + + if (WeakSet) { + assert.strictEqual(_.isWeakSet(weakSet), true); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should return `false` for non weak sets', function(assert) { + assert.expect(14); + + var expected = lodashStable.map(falsey, stubFalse); + + var actual = lodashStable.map(falsey, function(value, index) { + return index ? _.isWeakSet(value) : _.isWeakSet(); + }); + + assert.deepEqual(actual, expected); + + assert.strictEqual(_.isWeakSet(args), false); + assert.strictEqual(_.isWeakSet([1, 2, 3]), false); + assert.strictEqual(_.isWeakSet(true), false); + assert.strictEqual(_.isWeakSet(new Date), false); + assert.strictEqual(_.isWeakSet(new Error), false); + assert.strictEqual(_.isWeakSet(_), false); + assert.strictEqual(_.isWeakSet(slice), false); + assert.strictEqual(_.isWeakSet({ 'a': 1 }), false); + assert.strictEqual(_.isWeakSet(1), false); + assert.strictEqual(_.isWeakSet(/x/), false); + assert.strictEqual(_.isWeakSet('a'), false); + assert.strictEqual(_.isWeakSet(set), false); + assert.strictEqual(_.isWeakSet(symbol), false); + }); + + QUnit.test('should work with weak sets from another realm', function(assert) { + assert.expect(1); + + if (realm.weakSet) { + assert.strictEqual(_.isWeakSet(realm.weakSet), true); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('isType checks'); + + (function() { + QUnit.test('should return `false` for subclassed values', function(assert) { + assert.expect(7); + + var funcs = [ + 'isArray', 'isBoolean', 'isDate', 'isFunction', + 'isNumber', 'isRegExp', 'isString' + ]; + + lodashStable.each(funcs, function(methodName) { + function Foo() {} + Foo.prototype = root[methodName.slice(2)].prototype; + + var object = new Foo; + if (objToString.call(object) == objectTag) { + assert.strictEqual(_[methodName](object), false, '`_.' + methodName + '` returns `false`'); + } + else { + skipAssert(assert); + } + }); + }); + + QUnit.test('should not error on host objects (test in IE)', function(assert) { + assert.expect(26); + + var funcs = [ + 'isArguments', 'isArray', 'isArrayBuffer', 'isArrayLike', 'isBoolean', + 'isBuffer', 'isDate', 'isElement', 'isError', 'isFinite', 'isFunction', + 'isInteger', 'isMap', 'isNaN', 'isNil', 'isNull', 'isNumber', 'isObject', + 'isObjectLike', 'isRegExp', 'isSet', 'isSafeInteger', 'isString', + 'isUndefined', 'isWeakMap', 'isWeakSet' + ]; + + lodashStable.each(funcs, function(methodName) { + if (xml) { + _[methodName](xml); + assert.ok(true, '`_.' + methodName + '` should not error'); + } + else { + skipAssert(assert); + } + }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.iteratee'); + + (function() { + QUnit.test('should provide arguments to `func`', function(assert) { + assert.expect(1); + + var fn = function() { return slice.call(arguments); }, + iteratee = _.iteratee(fn), + actual = iteratee('a', 'b', 'c', 'd', 'e', 'f'); + + assert.deepEqual(actual, ['a', 'b', 'c', 'd', 'e', 'f']); + }); + + QUnit.test('should return `_.identity` when `func` is nullish', function(assert) { + assert.expect(1); + + var object = {}, + values = [, null, undefined], + expected = lodashStable.map(values, lodashStable.constant([!isNpm && _.identity, object])); + + var actual = lodashStable.map(values, function(value, index) { + var identity = index ? _.iteratee(value) : _.iteratee(); + return [!isNpm && identity, identity(object)]; + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should return an iteratee created by `_.matches` when `func` is an object', function(assert) { + assert.expect(2); + + var matches = _.iteratee({ 'a': 1, 'b': 2 }); + assert.strictEqual(matches({ 'a': 1, 'b': 2, 'c': 3 }), true); + assert.strictEqual(matches({ 'b': 2 }), false); + }); + + QUnit.test('should not change `_.matches` behavior if `source` is modified', function(assert) { + assert.expect(9); + + var sources = [ + { 'a': { 'b': 2, 'c': 3 } }, + { 'a': 1, 'b': 2 }, + { 'a': 1 } + ]; + + lodashStable.each(sources, function(source, index) { + var object = lodashStable.cloneDeep(source), + matches = _.iteratee(source); + + assert.strictEqual(matches(object), true); + + if (index) { + source.a = 2; + source.b = 1; + source.c = 3; + } else { + source.a.b = 1; + source.a.c = 2; + source.a.d = 3; + } + assert.strictEqual(matches(object), true); + assert.strictEqual(matches(source), false); + }); + }); + + QUnit.test('should return an iteratee created by `_.matchesProperty` when `func` is an array', function(assert) { + assert.expect(3); + + var array = ['a', undefined], + matches = _.iteratee([0, 'a']); + + assert.strictEqual(matches(array), true); + + matches = _.iteratee(['0', 'a']); + assert.strictEqual(matches(array), true); + + matches = _.iteratee([1, undefined]); + assert.strictEqual(matches(array), true); + }); + + QUnit.test('should support deep paths for `_.matchesProperty` shorthands', function(assert) { + assert.expect(1); + + var object = { 'a': { 'b': { 'c': 1, 'd': 2 } } }, + matches = _.iteratee(['a.b', { 'c': 1 }]); + + assert.strictEqual(matches(object), true); + }); + + QUnit.test('should not change `_.matchesProperty` behavior if `source` is modified', function(assert) { + assert.expect(9); + + var sources = [ + { 'a': { 'b': 2, 'c': 3 } }, + { 'a': 1, 'b': 2 }, + { 'a': 1 } + ]; + + lodashStable.each(sources, function(source, index) { + var object = { 'a': lodashStable.cloneDeep(source) }, + matches = _.iteratee(['a', source]); + + assert.strictEqual(matches(object), true); + + if (index) { + source.a = 2; + source.b = 1; + source.c = 3; + } else { + source.a.b = 1; + source.a.c = 2; + source.a.d = 3; + } + assert.strictEqual(matches(object), true); + assert.strictEqual(matches({ 'a': source }), false); + }); + }); + + QUnit.test('should return an iteratee created by `_.property` when `func` is a number or string', function(assert) { + assert.expect(2); + + var array = ['a'], + prop = _.iteratee(0); + + assert.strictEqual(prop(array), 'a'); + + prop = _.iteratee('0'); + assert.strictEqual(prop(array), 'a'); + }); + + QUnit.test('should support deep paths for `_.property` shorthands', function(assert) { + assert.expect(1); + + var object = { 'a': { 'b': 2 } }, + prop = _.iteratee('a.b'); + + assert.strictEqual(prop(object), 2); + }); + + QUnit.test('should work with functions created by `_.partial` and `_.partialRight`', function(assert) { + assert.expect(2); + + var fn = function() { + var result = [this.a]; + push.apply(result, arguments); + return result; + }; + + var expected = [1, 2, 3], + object = { 'a': 1 , 'iteratee': _.iteratee(_.partial(fn, 2)) }; + + assert.deepEqual(object.iteratee(3), expected); + + object.iteratee = _.iteratee(_.partialRight(fn, 3)); + assert.deepEqual(object.iteratee(2), expected); + }); + + QUnit.test('should use internal `iteratee` if external is unavailable', function(assert) { + assert.expect(1); + + var iteratee = _.iteratee; + delete _.iteratee; + + assert.deepEqual(_.map([{ 'a': 1 }], 'a'), [1]); + + _.iteratee = iteratee; + }); + + QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) { + assert.expect(1); + + var fn = function() { return this instanceof Number; }, + array = [fn, fn, fn], + iteratees = lodashStable.map(array, _.iteratee), + expected = lodashStable.map(array, stubFalse); + + var actual = lodashStable.map(iteratees, function(iteratee) { + return iteratee(); + }); + + assert.deepEqual(actual, expected); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('custom `_.iteratee` methods'); + + (function() { + var array = ['one', 'two', 'three'], + getPropA = _.partial(_.property, 'a'), + getPropB = _.partial(_.property, 'b'), + getLength = _.partial(_.property, 'length'), + iteratee = _.iteratee; + + var getSum = function() { + return function(result, object) { + return result + object.a; + }; + }; + + var objects = [ + { 'a': 0, 'b': 0 }, + { 'a': 1, 'b': 0 }, + { 'a': 1, 'b': 1 } + ]; + + QUnit.test('`_.countBy` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getLength; + assert.deepEqual(_.countBy(array), { '3': 2, '5': 1 }); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.differenceBy` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getPropA; + assert.deepEqual(_.differenceBy(objects, [objects[1]]), [objects[0]]); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.dropRightWhile` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getPropB; + assert.deepEqual(_.dropRightWhile(objects), objects.slice(0, 2)); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.dropWhile` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getPropB; + assert.deepEqual(_.dropWhile(objects.reverse()).reverse(), objects.reverse().slice(0, 2)); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.every` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getPropA; + assert.strictEqual(_.every(objects.slice(1)), true); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.filter` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + var objects = [{ 'a': 0 }, { 'a': 1 }]; + + _.iteratee = getPropA; + assert.deepEqual(_.filter(objects), [objects[1]]); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.find` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getPropA; + assert.strictEqual(_.find(objects), objects[1]); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.findIndex` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getPropA; + assert.strictEqual(_.findIndex(objects), 1); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.findLast` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getPropA; + assert.strictEqual(_.findLast(objects), objects[2]); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.findLastIndex` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getPropA; + assert.strictEqual(_.findLastIndex(objects), 2); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.findKey` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getPropB; + assert.strictEqual(_.findKey(objects), '2'); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.findLastKey` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getPropB; + assert.strictEqual(_.findLastKey(objects), '2'); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.groupBy` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getLength; + assert.deepEqual(_.groupBy(array), { '3': ['one', 'two'], '5': ['three'] }); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.intersectionBy` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getPropA; + assert.deepEqual(_.intersectionBy(objects, [objects[2]]), [objects[1]]); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.keyBy` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getLength; + assert.deepEqual(_.keyBy(array), { '3': 'two', '5': 'three' }); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.map` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getPropA; + assert.deepEqual(_.map(objects), [0, 1, 1]); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.mapKeys` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getPropB; + assert.deepEqual(_.mapKeys({ 'a': { 'b': 2 } }), { '2': { 'b': 2 } }); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.mapValues` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getPropB; + assert.deepEqual(_.mapValues({ 'a': { 'b': 2 } }), { 'a': 2 }); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.maxBy` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getPropB; + assert.deepEqual(_.maxBy(objects), objects[2]); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.meanBy` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getPropA; + assert.strictEqual(_.meanBy(objects), 2 / 3); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.minBy` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getPropB; + assert.deepEqual(_.minBy(objects), objects[0]); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.partition` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + var objects = [{ 'a': 1 }, { 'a': 1 }, { 'b': 2 }]; + + _.iteratee = getPropA; + assert.deepEqual(_.partition(objects), [objects.slice(0, 2), objects.slice(2)]); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.pullAllBy` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getPropA; + assert.deepEqual(_.pullAllBy(objects.slice(), [{ 'a': 1, 'b': 0 }]), [objects[0]]); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.reduce` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getSum; + assert.strictEqual(_.reduce(objects, undefined, 0), 2); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.reduceRight` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getSum; + assert.strictEqual(_.reduceRight(objects, undefined, 0), 2); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.reject` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + var objects = [{ 'a': 0 }, { 'a': 1 }]; + + _.iteratee = getPropA; + assert.deepEqual(_.reject(objects), [objects[0]]); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.remove` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + var objects = [{ 'a': 0 }, { 'a': 1 }]; + + _.iteratee = getPropA; + _.remove(objects); + assert.deepEqual(objects, [{ 'a': 0 }]); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.some` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getPropB; + assert.strictEqual(_.some(objects), true); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.sortBy` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getPropA; + assert.deepEqual(_.sortBy(objects.slice().reverse()), [objects[0], objects[2], objects[1]]); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.sortedIndexBy` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + var objects = [{ 'a': 30 }, { 'a': 50 }]; + + _.iteratee = getPropA; + assert.strictEqual(_.sortedIndexBy(objects, { 'a': 40 }), 1); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.sortedLastIndexBy` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + var objects = [{ 'a': 30 }, { 'a': 50 }]; + + _.iteratee = getPropA; + assert.strictEqual(_.sortedLastIndexBy(objects, { 'a': 40 }), 1); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.sumBy` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getPropB; + assert.strictEqual(_.sumBy(objects), 1); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.takeRightWhile` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getPropB; + assert.deepEqual(_.takeRightWhile(objects), objects.slice(2)); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.takeWhile` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getPropB; + assert.deepEqual(_.takeWhile(objects.reverse()), objects.reverse().slice(2)); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.transform` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = function() { + return function(result, object) { + result.sum += object.a; + }; + }; + + assert.deepEqual(_.transform(objects, undefined, { 'sum': 0 }), { 'sum': 2 }); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.uniqBy` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getPropB; + assert.deepEqual(_.uniqBy(objects), [objects[0], objects[2]]); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.unionBy` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getPropB; + assert.deepEqual(_.unionBy(objects.slice(0, 1), [objects[2]]), [objects[0], objects[2]]); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.xorBy` should use `_.iteratee` internally', function(assert) { + assert.expect(1); + + if (!isModularize) { + _.iteratee = getPropA; + assert.deepEqual(_.xorBy(objects, objects.slice(1)), [objects[0]]); + _.iteratee = iteratee; + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.join'); + + (function() { + var array = ['a', 'b', 'c']; + + QUnit.test('should return join all array elements into a string', function(assert) { + assert.expect(1); + + assert.strictEqual(_.join(array, '~'), 'a~b~c'); + }); + + QUnit.test('should return an unwrapped value when implicitly chaining', function(assert) { + assert.expect(2); + + if (!isNpm) { + var wrapped = _(array); + assert.strictEqual(wrapped.join('~'), 'a~b~c'); + assert.strictEqual(wrapped.value(), array); + } + else { + skipAssert(assert, 2); + } + }); + + QUnit.test('should return a wrapped value when explicitly chaining', function(assert) { + assert.expect(1); + + if (!isNpm) { + assert.ok(_(array).chain().join('~') instanceof _); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.keyBy'); + + (function() { + var array = [ + { 'dir': 'left', 'code': 97 }, + { 'dir': 'right', 'code': 100 } + ]; + + QUnit.test('should transform keys by `iteratee`', function(assert) { + assert.expect(1); + + var expected = { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }; + + var actual = _.keyBy(array, function(object) { + return String.fromCharCode(object.code); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should use `_.identity` when `iteratee` is nullish', function(assert) { + assert.expect(1); + + var array = [4, 6, 6], + values = [, null, undefined], + expected = lodashStable.map(values, lodashStable.constant({ '4': 4, '6': 6 })); + + var actual = lodashStable.map(values, function(value, index) { + return index ? _.keyBy(array, value) : _.keyBy(array); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should work with `_.property` shorthands', function(assert) { + assert.expect(1); + + var expected = { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }, + actual = _.keyBy(array, 'dir'); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should only add values to own, not inherited, properties', function(assert) { + assert.expect(2); + + var actual = _.keyBy([6.1, 4.2, 6.3], function(n) { + return Math.floor(n) > 4 ? 'hasOwnProperty' : 'constructor'; + }); + + assert.deepEqual(actual.constructor, 4.2); + assert.deepEqual(actual.hasOwnProperty, 6.3); + }); + + QUnit.test('should work with a number for `iteratee`', function(assert) { + assert.expect(2); + + var array = [ + [1, 'a'], + [2, 'a'], + [2, 'b'] + ]; + + assert.deepEqual(_.keyBy(array, 0), { '1': [1, 'a'], '2': [2, 'b'] }); + assert.deepEqual(_.keyBy(array, 1), { 'a': [2, 'a'], 'b': [2, 'b'] }); + }); + + QUnit.test('should work with an object for `collection`', function(assert) { + assert.expect(1); + + var actual = _.keyBy({ 'a': 6.1, 'b': 4.2, 'c': 6.3 }, Math.floor); + assert.deepEqual(actual, { '4': 4.2, '6': 6.3 }); + }); + + QUnit.test('should work in a lazy sequence', function(assert) { + assert.expect(1); + + if (!isNpm) { + var array = lodashStable.range(LARGE_ARRAY_SIZE).concat( + lodashStable.range(Math.floor(LARGE_ARRAY_SIZE / 2), LARGE_ARRAY_SIZE), + lodashStable.range(Math.floor(LARGE_ARRAY_SIZE / 1.5), LARGE_ARRAY_SIZE) + ); + + var actual = _(array).keyBy().map(square).filter(isEven).take().value(); + + assert.deepEqual(actual, _.take(_.filter(_.map(_.keyBy(array), square), isEven))); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('keys methods'); + + lodashStable.each(['keys', 'keysIn'], function(methodName) { + var func = _[methodName], + isKeys = methodName == 'keys'; + + QUnit.test('`_.' + methodName + '` should return the string keyed property names of `object`', function(assert) { + assert.expect(1); + + var actual = func({ 'a': 1, 'b': 1 }).sort(); + + assert.deepEqual(actual, ['a', 'b']); + }); + + QUnit.test('`_.' + methodName + '` should ' + (isKeys ? 'not ' : '') + 'include inherited string keyed properties', function(assert) { + assert.expect(1); + + function Foo() { + this.a = 1; + } + Foo.prototype.b = 2; + + var expected = isKeys ? ['a'] : ['a', 'b'], + actual = func(new Foo).sort(); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should treat sparse arrays as dense', function(assert) { + assert.expect(1); + + var array = [1]; + array[2] = 3; + + var actual = func(array).sort(); + + assert.deepEqual(actual, ['0', '1', '2']); + }); + + QUnit.test('`_.' + methodName + '` should return keys for custom properties on arrays', function(assert) { + assert.expect(1); + + var array = [1]; + array.a = 1; + + var actual = func(array).sort(); + + assert.deepEqual(actual, ['0', 'a']); + }); + + QUnit.test('`_.' + methodName + '` should ' + (isKeys ? 'not ' : '') + 'include inherited string keyed properties of arrays', function(assert) { + assert.expect(1); + + arrayProto.a = 1; + + var expected = isKeys ? ['0'] : ['0', 'a'], + actual = func([1]).sort(); + + assert.deepEqual(actual, expected); + + delete arrayProto.a; + }); + + QUnit.test('`_.' + methodName + '` should work with `arguments` objects', function(assert) { + assert.expect(1); + + var values = [args, strictArgs], + expected = lodashStable.map(values, lodashStable.constant(['0', '1', '2'])); + + var actual = lodashStable.map(values, function(value) { + return func(value).sort(); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should return keys for custom properties on `arguments` objects', function(assert) { + assert.expect(1); + + var values = [args, strictArgs], + expected = lodashStable.map(values, lodashStable.constant(['0', '1', '2', 'a'])); + + var actual = lodashStable.map(values, function(value) { + value.a = 1; + var result = func(value).sort(); + delete value.a; + return result; + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should ' + (isKeys ? 'not ' : '') + 'include inherited string keyed properties of `arguments` objects', function(assert) { + assert.expect(1); + + var values = [args, strictArgs], + expected = lodashStable.map(values, lodashStable.constant(isKeys ? ['0', '1', '2'] : ['0', '1', '2', 'a'])); + + var actual = lodashStable.map(values, function(value) { + objectProto.a = 1; + var result = func(value).sort(); + delete objectProto.a; + return result; + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should work with string objects', function(assert) { + assert.expect(1); + + var actual = func(Object('abc')).sort(); + + assert.deepEqual(actual, ['0', '1', '2']); + }); + + QUnit.test('`_.' + methodName + '` should return keys for custom properties on string objects', function(assert) { + assert.expect(1); + + var object = Object('a'); + object.a = 1; + + var actual = func(object).sort(); + + assert.deepEqual(actual, ['0', 'a']); + }); + + QUnit.test('`_.' + methodName + '` should ' + (isKeys ? 'not ' : '') + 'include inherited string keyed properties of string objects', function(assert) { + assert.expect(1); + + stringProto.a = 1; + + var expected = isKeys ? ['0'] : ['0', 'a'], + actual = func(Object('a')).sort(); + + assert.deepEqual(actual, expected); + + delete stringProto.a; + }); + + QUnit.test('`_.' + methodName + '` should work with array-like objects', function(assert) { + assert.expect(1); + + var object = { '0': 'a', 'length': 1 }, + actual = func(object).sort(); + + assert.deepEqual(actual, ['0', 'length']); + }); + + QUnit.test('`_.' + methodName + '` should coerce primitives to objects (test in IE 9)', function(assert) { + assert.expect(2); + + var expected = lodashStable.map(primitives, function(value) { + return typeof value == 'string' ? ['0'] : []; + }); + + var actual = lodashStable.map(primitives, func); + assert.deepEqual(actual, expected); + + // IE 9 doesn't box numbers in for-in loops. + numberProto.a = 1; + assert.deepEqual(func(0), isKeys ? [] : ['a']); + delete numberProto.a; + }); + + QUnit.test('`_.' + methodName + '` skips the `constructor` property on prototype objects', function(assert) { + assert.expect(3); + + function Foo() {} + Foo.prototype.a = 1; + + var expected = ['a']; + assert.deepEqual(func(Foo.prototype), expected); + + Foo.prototype = { 'constructor': Foo, 'a': 1 }; + assert.deepEqual(func(Foo.prototype), expected); + + var Fake = { 'prototype': {} }; + Fake.prototype.constructor = Fake; + assert.deepEqual(func(Fake.prototype), ['constructor']); + }); + + QUnit.test('`_.' + methodName + '` should return an empty array when `object` is nullish', function(assert) { + var values = [, null, undefined], + expected = lodashStable.map(values, stubArray); + + var actual = lodashStable.map(values, function(value, index) { + objectProto.a = 1; + var result = index ? func(value) : func(); + delete objectProto.a; + return result; + }); + + assert.deepEqual(actual, expected); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.last'); + + (function() { + var array = [1, 2, 3, 4]; + + QUnit.test('should return the last element', function(assert) { + assert.expect(1); + + assert.strictEqual(_.last(array), 4); + }); + + QUnit.test('should return `undefined` when querying empty arrays', function(assert) { + assert.expect(1); + + var array = []; + array['-1'] = 1; + + assert.strictEqual(_.last([]), undefined); + }); + + QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) { + assert.expect(1); + + var array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]], + actual = lodashStable.map(array, _.last); + + assert.deepEqual(actual, [3, 6, 9]); + }); + + QUnit.test('should return an unwrapped value when implicitly chaining', function(assert) { + assert.expect(1); + + if (!isNpm) { + assert.strictEqual(_(array).last(), 4); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should return a wrapped value when explicitly chaining', function(assert) { + assert.expect(1); + + if (!isNpm) { + assert.ok(_(array).chain().last() instanceof _); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should not execute immediately when explicitly chaining', function(assert) { + assert.expect(1); + + if (!isNpm) { + var wrapped = _(array).chain().last(); + assert.strictEqual(wrapped.__wrapped__, array); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should work in a lazy sequence', function(assert) { + assert.expect(2); + + if (!isNpm) { + var largeArray = lodashStable.range(LARGE_ARRAY_SIZE), + smallArray = array; + + lodashStable.times(2, function(index) { + var array = index ? largeArray : smallArray, + wrapped = _(array).filter(isEven); + + assert.strictEqual(wrapped.last(), _.last(_.filter(array, isEven))); + }); + } + else { + skipAssert(assert, 2); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.lowerCase'); + + (function() { + QUnit.test('should lowercase as space-separated words', function(assert) { + assert.expect(3); + + assert.strictEqual(_.lowerCase('--Foo-Bar--'), 'foo bar'); + assert.strictEqual(_.lowerCase('fooBar'), 'foo bar'); + assert.strictEqual(_.lowerCase('__FOO_BAR__'), 'foo bar'); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.lowerFirst'); + + (function() { + QUnit.test('should lowercase only the first character', function(assert) { + assert.expect(3); + + assert.strictEqual(_.lowerFirst('fred'), 'fred'); + assert.strictEqual(_.lowerFirst('Fred'), 'fred'); + assert.strictEqual(_.lowerFirst('FRED'), 'fRED'); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.lt'); + + (function() { + QUnit.test('should return `true` if `value` is less than `other`', function(assert) { + assert.expect(2); + + assert.strictEqual(_.lt(1, 3), true); + assert.strictEqual(_.lt('abc', 'def'), true); + }); + + QUnit.test('should return `false` if `value` >= `other`', function(assert) { + assert.expect(4); + + assert.strictEqual(_.lt(3, 1), false); + assert.strictEqual(_.lt(3, 3), false); + assert.strictEqual(_.lt('def', 'abc'), false); + assert.strictEqual(_.lt('def', 'def'), false); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.lte'); + + (function() { + QUnit.test('should return `true` if `value` is <= `other`', function(assert) { + assert.expect(4); + + assert.strictEqual(_.lte(1, 3), true); + assert.strictEqual(_.lte(3, 3), true); + assert.strictEqual(_.lte('abc', 'def'), true); + assert.strictEqual(_.lte('def', 'def'), true); + }); + + QUnit.test('should return `false` if `value` > `other`', function(assert) { + assert.expect(2); + + assert.strictEqual(_.lt(3, 1), false); + assert.strictEqual(_.lt('def', 'abc'), false); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.findLastIndex and lodash.lastIndexOf'); + + lodashStable.each(['findLastIndex', 'lastIndexOf'], function(methodName) { + var array = [1, 2, 3, 1, 2, 3], + func = _[methodName], + resolve = methodName == 'findLastIndex' ? lodashStable.curry(lodashStable.eq) : identity; + + QUnit.test('`_.' + methodName + '` should return the index of the last matched value', function(assert) { + assert.expect(1); + + assert.strictEqual(func(array, resolve(3)), 5); + }); + + QUnit.test('`_.' + methodName + '` should work with a positive `fromIndex`', function(assert) { + assert.expect(1); + + assert.strictEqual(func(array, resolve(1), 2), 0); + }); + + QUnit.test('`_.' + methodName + '` should work with a `fromIndex` >= `length`', function(assert) { + assert.expect(1); + + var values = [6, 8, Math.pow(2, 32), Infinity], + expected = lodashStable.map(values, lodashStable.constant([-1, 3, -1])); + + var actual = lodashStable.map(values, function(fromIndex) { + return [ + func(array, resolve(undefined), fromIndex), + func(array, resolve(1), fromIndex), + func(array, resolve(''), fromIndex) + ]; + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should work with a negative `fromIndex`', function(assert) { + assert.expect(1); + + assert.strictEqual(func(array, resolve(2), -3), 1); + }); + + QUnit.test('`_.' + methodName + '` should work with a negative `fromIndex` <= `-length`', function(assert) { + assert.expect(1); + + var values = [-6, -8, -Infinity], + expected = lodashStable.map(values, stubZero); + + var actual = lodashStable.map(values, function(fromIndex) { + return func(array, resolve(1), fromIndex); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should treat falsey `fromIndex` values correctly', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(falsey, function(value) { + return value === undefined ? 5 : -1; + }); + + var actual = lodashStable.map(falsey, function(fromIndex) { + return func(array, resolve(3), fromIndex); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should coerce `fromIndex` to an integer', function(assert) { + assert.expect(1); + + assert.strictEqual(func(array, resolve(2), 4.2), 4); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('indexOf methods'); + + lodashStable.each(['indexOf', 'lastIndexOf', 'sortedIndexOf', 'sortedLastIndexOf'], function(methodName) { + var func = _[methodName], + isIndexOf = !/last/i.test(methodName), + isSorted = /^sorted/.test(methodName); + + QUnit.test('`_.' + methodName + '` should accept a falsey `array`', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(falsey, lodashStable.constant(-1)); + + var actual = lodashStable.map(falsey, function(array, index) { + try { + return index ? func(array) : func(); + } catch (e) {} + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should return `-1` for an unmatched value', function(assert) { + assert.expect(5); + + var array = [1, 2, 3], + empty = []; + + assert.strictEqual(func(array, 4), -1); + assert.strictEqual(func(array, 4, true), -1); + assert.strictEqual(func(array, undefined, true), -1); + + assert.strictEqual(func(empty, undefined), -1); + assert.strictEqual(func(empty, undefined, true), -1); + }); + + QUnit.test('`_.' + methodName + '` should not match values on empty arrays', function(assert) { + assert.expect(2); + + var array = []; + array[-1] = 0; + + assert.strictEqual(func(array, undefined), -1); + assert.strictEqual(func(array, 0, true), -1); + }); + + QUnit.test('`_.' + methodName + '` should match `NaN`', function(assert) { + assert.expect(3); + + var array = isSorted + ? [1, 2, NaN, NaN] + : [1, NaN, 3, NaN, 5, NaN]; + + if (isSorted) { + assert.strictEqual(func(array, NaN, true), isIndexOf ? 2 : 3); + skipAssert(assert, 2); + } + else { + assert.strictEqual(func(array, NaN), isIndexOf ? 1 : 5); + assert.strictEqual(func(array, NaN, 2), isIndexOf ? 3 : 1); + assert.strictEqual(func(array, NaN, -2), isIndexOf ? 5 : 3); + } + }); + + QUnit.test('`_.' + methodName + '` should match `-0` as `0`', function(assert) { + assert.expect(2); + + assert.strictEqual(func([-0], 0), 0); + assert.strictEqual(func([0], -0), 0); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.map'); + + (function() { + var array = [1, 2]; + + QUnit.test('should map values in `collection` to a new array', function(assert) { + assert.expect(2); + + var object = { 'a': 1, 'b': 2 }, + expected = ['1', '2']; + + assert.deepEqual(_.map(array, String), expected); + assert.deepEqual(_.map(object, String), expected); + }); + + QUnit.test('should work with `_.property` shorthands', function(assert) { + assert.expect(1); + + var objects = [{ 'a': 'x' }, { 'a': 'y' }]; + assert.deepEqual(_.map(objects, 'a'), ['x', 'y']); + }); + + QUnit.test('should iterate over own string keyed properties of objects', function(assert) { + assert.expect(1); + + function Foo() { + this.a = 1; + } + Foo.prototype.b = 2; + + var actual = _.map(new Foo, identity); + assert.deepEqual(actual, [1]); + }); + + QUnit.test('should use `_.identity` when `iteratee` is nullish', function(assert) { + assert.expect(2); + + var object = { 'a': 1, 'b': 2 }, + values = [, null, undefined], + expected = lodashStable.map(values, lodashStable.constant([1, 2])); + + lodashStable.each([array, object], function(collection) { + var actual = lodashStable.map(values, function(value, index) { + return index ? _.map(collection, value) : _.map(collection); + }); + + assert.deepEqual(actual, expected); + }); + }); + + QUnit.test('should accept a falsey `collection`', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(falsey, stubArray); + + var actual = lodashStable.map(falsey, function(collection, index) { + try { + return index ? _.map(collection) : _.map(); + } catch (e) {} + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should treat number values for `collection` as empty', function(assert) { + assert.expect(1); + + assert.deepEqual(_.map(1), []); + }); + + QUnit.test('should treat a nodelist as an array-like object', function(assert) { + assert.expect(1); + + if (document) { + var actual = _.map(document.getElementsByTagName('body'), function(element) { + return element.nodeName.toLowerCase(); + }); + + assert.deepEqual(actual, ['body']); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should work with objects with non-number length properties', function(assert) { + assert.expect(1); + + var value = { 'value': 'x' }, + object = { 'length': { 'value': 'x' } }; + + assert.deepEqual(_.map(object, identity), [value]); + }); + + QUnit.test('should return a wrapped value when chaining', function(assert) { + assert.expect(1); + + if (!isNpm) { + assert.ok(_(array).map(noop) instanceof _); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should provide correct `predicate` arguments in a lazy sequence', function(assert) { + assert.expect(5); + + if (!isNpm) { + var args, + array = lodashStable.range(LARGE_ARRAY_SIZE + 1), + expected = [1, 0, _.map(array.slice(1), square)]; + + _(array).slice(1).map(function(value, index, array) { + args || (args = slice.call(arguments)); + }).value(); + + assert.deepEqual(args, [1, 0, array.slice(1)]); + + args = undefined; + _(array).slice(1).map(square).map(function(value, index, array) { + args || (args = slice.call(arguments)); + }).value(); + + assert.deepEqual(args, expected); + + args = undefined; + _(array).slice(1).map(square).map(function(value, index) { + args || (args = slice.call(arguments)); + }).value(); + + assert.deepEqual(args, expected); + + args = undefined; + _(array).slice(1).map(square).map(function(value) { + args || (args = slice.call(arguments)); + }).value(); + + assert.deepEqual(args, [1]); + + args = undefined; + _(array).slice(1).map(square).map(function() { + args || (args = slice.call(arguments)); + }).value(); + + assert.deepEqual(args, expected); + } + else { + skipAssert(assert, 5); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.mapKeys'); + + (function() { + var array = [1, 2], + object = { 'a': 1, 'b': 2 }; + + QUnit.test('should map keys in `object` to a new object', function(assert) { + assert.expect(1); + + var actual = _.mapKeys(object, String); + assert.deepEqual(actual, { '1': 1, '2': 2 }); + }); + + QUnit.test('should treat arrays like objects', function(assert) { + assert.expect(1); + + var actual = _.mapKeys(array, String); + assert.deepEqual(actual, { '1': 1, '2': 2 }); + }); + + QUnit.test('should work with `_.property` shorthands', function(assert) { + assert.expect(1); + + var actual = _.mapKeys({ 'a': { 'b': 'c' } }, 'b'); + assert.deepEqual(actual, { 'c': { 'b': 'c' } }); + }); + + QUnit.test('should use `_.identity` when `iteratee` is nullish', function(assert) { + assert.expect(1); + + var object = { 'a': 1, 'b': 2 }, + values = [, null, undefined], + expected = lodashStable.map(values, lodashStable.constant({ '1': 1, '2': 2 })); + + var actual = lodashStable.map(values, function(value, index) { + return index ? _.mapKeys(object, value) : _.mapKeys(object); + }); + + assert.deepEqual(actual, expected); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.mapValues'); + + (function() { + var array = [1, 2], + object = { 'a': 1, 'b': 2 }; + + QUnit.test('should map values in `object` to a new object', function(assert) { + assert.expect(1); + + var actual = _.mapValues(object, String); + assert.deepEqual(actual, { 'a': '1', 'b': '2' }); + }); + + QUnit.test('should treat arrays like objects', function(assert) { + assert.expect(1); + + var actual = _.mapValues(array, String); + assert.deepEqual(actual, { '0': '1', '1': '2' }); + }); + + QUnit.test('should work with `_.property` shorthands', function(assert) { + assert.expect(1); + + var actual = _.mapValues({ 'a': { 'b': 2 } }, 'b'); + assert.deepEqual(actual, { 'a': 2 }); + }); + + QUnit.test('should use `_.identity` when `iteratee` is nullish', function(assert) { + assert.expect(1); + + var object = { 'a': 1, 'b': 2 }, + values = [, null, undefined], + expected = lodashStable.map(values, lodashStable.constant([true, false])); + + var actual = lodashStable.map(values, function(value, index) { + var result = index ? _.mapValues(object, value) : _.mapValues(object); + return [lodashStable.isEqual(result, object), result === object]; + }); + + assert.deepEqual(actual, expected); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.mapKeys and lodash.mapValues'); + + lodashStable.each(['mapKeys', 'mapValues'], function(methodName) { + var func = _[methodName], + object = { 'a': 1, 'b': 2 }; + + QUnit.test('`_.' + methodName + '` should iterate over own string keyed properties of objects', function(assert) { + assert.expect(1); + + function Foo() { + this.a = 'a'; + } + Foo.prototype.b = 'b'; + + var actual = func(new Foo, function(value, key) { return key; }); + assert.deepEqual(actual, { 'a': 'a' }); + }); + + QUnit.test('`_.' + methodName + '` should accept a falsey `object`', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(falsey, stubObject); + + var actual = lodashStable.map(falsey, function(object, index) { + try { + return index ? func(object) : func(); + } catch (e) {} + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should return a wrapped value when chaining', function(assert) { + assert.expect(1); + + if (!isNpm) { + assert.ok(_(object)[methodName](noop) instanceof _); + } + else { + skipAssert(assert); + } + }); + }); + + QUnit.module('lodash.matches'); + + (function() { + QUnit.test('should not change behavior if `source` is modified', function(assert) { + assert.expect(9); + + var sources = [ + { 'a': { 'b': 2, 'c': 3 } }, + { 'a': 1, 'b': 2 }, + { 'a': 1 } + ]; + + lodashStable.each(sources, function(source, index) { + var object = lodashStable.cloneDeep(source), + par = _.matches(source); + + assert.strictEqual(par(object), true); + + if (index) { + source.a = 2; + source.b = 1; + source.c = 3; + } else { + source.a.b = 1; + source.a.c = 2; + source.a.d = 3; + } + assert.strictEqual(par(object), true); + assert.strictEqual(par(source), false); + }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('matches methods'); + + lodashStable.each(['matches', 'isMatch'], function(methodName) { + var isMatches = methodName == 'matches'; + + function matches(source) { + return isMatches ? _.matches(source) : function(object) { + return _.isMatch(object, source); + }; + } + + QUnit.test('`_.' + methodName + '` should perform a deep comparison between `source` and `object`', function(assert) { + assert.expect(5); + + var object = { 'a': 1, 'b': 2, 'c': 3 }, + par = matches({ 'a': 1 }); + + assert.strictEqual(par(object), true); + + par = matches({ 'b': 1 }); + assert.strictEqual(par(object), false); + + par = matches({ 'a': 1, 'c': 3 }); + assert.strictEqual(par(object), true); + + par = matches({ 'c': 3, 'd': 4 }); + assert.strictEqual(par(object), false); + + object = { 'a': { 'b': { 'c': 1, 'd': 2 }, 'e': 3 }, 'f': 4 }; + par = matches({ 'a': { 'b': { 'c': 1 } } }); + + assert.strictEqual(par(object), true); + }); + + QUnit.test('`_.' + methodName + '` should match inherited string keyed `object` properties', function(assert) { + assert.expect(1); + + function Foo() { + this.a = 1; + } + Foo.prototype.b = 2; + + var object = { 'a': new Foo }, + par = matches({ 'a': { 'b': 2 } }); + + assert.strictEqual(par(object), true); + }); + + QUnit.test('`_.' + methodName + '` should not match by inherited `source` properties', function(assert) { + assert.expect(1); + + function Foo() { + this.a = 1; + } + Foo.prototype.b = 2; + + var objects = [{ 'a': 1 }, { 'a': 1, 'b': 2 }], + source = new Foo, + actual = lodashStable.map(objects, matches(source)), + expected = lodashStable.map(objects, stubTrue); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should compare a variety of `source` property values', function(assert) { + assert.expect(2); + + var object1 = { 'a': false, 'b': true, 'c': '3', 'd': 4, 'e': [5], 'f': { 'g': 6 } }, + object2 = { 'a': 0, 'b': 1, 'c': 3, 'd': '4', 'e': ['5'], 'f': { 'g': '6' } }, + par = matches(object1); + + assert.strictEqual(par(object1), true); + assert.strictEqual(par(object2), false); + }); + + QUnit.test('`_.' + methodName + '` should match `-0` as `0`', function(assert) { + assert.expect(2); + + var object1 = { 'a': -0 }, + object2 = { 'a': 0 }, + par = matches(object1); + + assert.strictEqual(par(object2), true); + + par = matches(object2); + assert.strictEqual(par(object1), true); + }); + + QUnit.test('`_.' + methodName + '` should compare functions by reference', function(assert) { + assert.expect(3); + + var object1 = { 'a': lodashStable.noop }, + object2 = { 'a': noop }, + object3 = { 'a': {} }, + par = matches(object1); + + assert.strictEqual(par(object1), true); + assert.strictEqual(par(object2), false); + assert.strictEqual(par(object3), false); + }); + + QUnit.test('`_.' + methodName + '` should work with a function for `object`', function(assert) { + assert.expect(1); + + function Foo() {} + Foo.a = { 'b': 2, 'c': 3 }; + + var par = matches({ 'a': { 'b': 2 } }); + assert.strictEqual(par(Foo), true); + }); + + QUnit.test('`_.' + methodName + '` should work with a function for `source`', function(assert) { + assert.expect(1); + + function Foo() {} + Foo.a = 1; + Foo.b = function() {}; + Foo.c = 3; + + var objects = [{ 'a': 1 }, { 'a': 1, 'b': Foo.b, 'c': 3 }], + actual = lodashStable.map(objects, matches(Foo)); + + assert.deepEqual(actual, [false, true]); + }); + + QUnit.test('`_.' + methodName + '` should work with a non-plain `object`', function(assert) { + assert.expect(1); + + function Foo(object) { lodashStable.assign(this, object); } + + var object = new Foo({ 'a': new Foo({ 'b': 2, 'c': 3 }) }), + par = matches({ 'a': { 'b': 2 } }); + + assert.strictEqual(par(object), true); + }); + + QUnit.test('`_.' + methodName + '` should partial match arrays', function(assert) { + assert.expect(3); + + var objects = [{ 'a': ['b'] }, { 'a': ['c', 'd'] }], + actual = lodashStable.filter(objects, matches({ 'a': ['d'] })); + + assert.deepEqual(actual, [objects[1]]); + + actual = lodashStable.filter(objects, matches({ 'a': ['b', 'd'] })); + assert.deepEqual(actual, []); + + actual = lodashStable.filter(objects, matches({ 'a': ['d', 'b'] })); + assert.deepEqual(actual, []); + }); + + QUnit.test('`_.' + methodName + '` should partial match arrays with duplicate values', function(assert) { + assert.expect(1); + + var objects = [{ 'a': [1, 2] }, { 'a': [2, 2] }], + actual = lodashStable.filter(objects, matches({ 'a': [2, 2] })); + + assert.deepEqual(actual, [objects[1]]); + }); + + QUnit.test('should partial match arrays of objects', function(assert) { + assert.expect(1); + + var objects = [ + { 'a': [{ 'b': 1, 'c': 2 }, { 'b': 4, 'c': 5, 'd': 6 }] }, + { 'a': [{ 'b': 1, 'c': 2 }, { 'b': 4, 'c': 6, 'd': 7 }] } + ]; + + var actual = lodashStable.filter(objects, matches({ 'a': [{ 'b': 1 }, { 'b': 4, 'c': 5 }] })); + assert.deepEqual(actual, [objects[0]]); + }); + + QUnit.test('`_.' + methodName + '` should partial match maps', function(assert) { + assert.expect(3); + + if (Map) { + var objects = [{ 'a': new Map }, { 'a': new Map }]; + objects[0].a.set('a', 1); + objects[1].a.set('a', 1); + objects[1].a.set('b', 2); + + var map = new Map; + map.set('b', 2); + var actual = lodashStable.filter(objects, matches({ 'a': map })); + + assert.deepEqual(actual, [objects[1]]); + + map.delete('b'); + actual = lodashStable.filter(objects, matches({ 'a': map })); + + assert.deepEqual(actual, objects); + + map.set('c', 3); + actual = lodashStable.filter(objects, matches({ 'a': map })); + + assert.deepEqual(actual, []); + } + else { + skipAssert(assert, 3); + } + }); + + QUnit.test('`_.' + methodName + '` should partial match sets', function(assert) { + assert.expect(3); + + if (Set) { + var objects = [{ 'a': new Set }, { 'a': new Set }]; + objects[0].a.add(1); + objects[1].a.add(1); + objects[1].a.add(2); + + var set = new Set; + set.add(2); + var actual = lodashStable.filter(objects, matches({ 'a': set })); + + assert.deepEqual(actual, [objects[1]]); + + set.delete(2); + actual = lodashStable.filter(objects, matches({ 'a': set })); + + assert.deepEqual(actual, objects); + + set.add(3); + actual = lodashStable.filter(objects, matches({ 'a': set })); + + assert.deepEqual(actual, []); + } + else { + skipAssert(assert, 3); + } + }); + + QUnit.test('`_.' + methodName + '` should match `undefined` values', function(assert) { + assert.expect(3); + + var objects = [{ 'a': 1 }, { 'a': 1, 'b': 1 }, { 'a': 1, 'b': undefined }], + actual = lodashStable.map(objects, matches({ 'b': undefined })), + expected = [false, false, true]; + + assert.deepEqual(actual, expected); + + actual = lodashStable.map(objects, matches({ 'a': 1, 'b': undefined })); + + assert.deepEqual(actual, expected); + + objects = [{ 'a': { 'b': 2 } }, { 'a': { 'b': 2, 'c': 3 } }, { 'a': { 'b': 2, 'c': undefined } }]; + actual = lodashStable.map(objects, matches({ 'a': { 'c': undefined } })); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should match `undefined` values on primitives', function(assert) { + assert.expect(3); + + numberProto.a = 1; + numberProto.b = undefined; + + try { + var par = matches({ 'b': undefined }); + assert.strictEqual(par(1), true); + } catch (e) { + assert.ok(false, e.message); + } + try { + par = matches({ 'a': 1, 'b': undefined }); + assert.strictEqual(par(1), true); + } catch (e) { + assert.ok(false, e.message); + } + numberProto.a = { 'b': 1, 'c': undefined }; + try { + par = matches({ 'a': { 'c': undefined } }); + assert.strictEqual(par(1), true); + } catch (e) { + assert.ok(false, e.message); + } + delete numberProto.a; + delete numberProto.b; + }); + + QUnit.test('`_.' + methodName + '` should return `false` when `object` is nullish', function(assert) { + assert.expect(1); + + var values = [, null, undefined], + expected = lodashStable.map(values, stubFalse), + par = matches({ 'a': 1 }); + + var actual = lodashStable.map(values, function(value, index) { + try { + return index ? par(value) : par(); + } catch (e) {} + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should return `true` when comparing an empty `source`', function(assert) { + assert.expect(1); + + var object = { 'a': 1 }, + expected = lodashStable.map(empties, stubTrue); + + var actual = lodashStable.map(empties, function(value) { + var par = matches(value); + return par(object); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should return `true` when comparing an empty `source` to a nullish `object`', function(assert) { + assert.expect(1); + + var values = [, null, undefined], + expected = lodashStable.map(values, stubTrue), + par = matches({}); + + var actual = lodashStable.map(values, function(value, index) { + try { + return index ? par(value) : par(); + } catch (e) {} + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should return `true` when comparing a `source` of empty arrays and objects', function(assert) { + assert.expect(1); + + var objects = [{ 'a': [1], 'b': { 'c': 1 } }, { 'a': [2, 3], 'b': { 'd': 2 } }], + actual = lodashStable.filter(objects, matches({ 'a': [], 'b': {} })); + + assert.deepEqual(actual, objects); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.matchesProperty'); + + (function() { + QUnit.test('should create a function that performs a deep comparison between a property value and `srcValue`', function(assert) { + assert.expect(6); + + var object = { 'a': 1, 'b': 2, 'c': 3 }, + matches = _.matchesProperty('a', 1); + + assert.strictEqual(matches.length, 1); + assert.strictEqual(matches(object), true); + + matches = _.matchesProperty('b', 3); + assert.strictEqual(matches(object), false); + + matches = _.matchesProperty('a', { 'a': 1, 'c': 3 }); + assert.strictEqual(matches({ 'a': object }), true); + + matches = _.matchesProperty('a', { 'c': 3, 'd': 4 }); + assert.strictEqual(matches(object), false); + + object = { 'a': { 'b': { 'c': 1, 'd': 2 }, 'e': 3 }, 'f': 4 }; + matches = _.matchesProperty('a', { 'b': { 'c': 1 } }); + + assert.strictEqual(matches(object), true); + }); + + QUnit.test('should support deep paths', function(assert) { + assert.expect(2); + + var object = { 'a': { 'b': 2 } }; + + lodashStable.each(['a.b', ['a', 'b']], function(path) { + var matches = _.matchesProperty(path, 2); + assert.strictEqual(matches(object), true); + }); + }); + + QUnit.test('should work with a non-string `path`', function(assert) { + assert.expect(2); + + var array = [1, 2, 3]; + + lodashStable.each([1, [1]], function(path) { + var matches = _.matchesProperty(path, 2); + assert.strictEqual(matches(array), true); + }); + }); + + QUnit.test('should preserve the sign of `0`', function(assert) { + assert.expect(1); + + var object1 = { '-0': 'a' }, + object2 = { '0': 'b' }, + pairs = [[object1, object2], [object1, object2], [object2, object1], [object2, object1]], + props = [-0, Object(-0), 0, Object(0)], + values = ['a', 'a', 'b', 'b'], + expected = lodashStable.map(props, lodashStable.constant([true, false])); + + var actual = lodashStable.map(props, function(key, index) { + var matches = _.matchesProperty(key, values[index]), + pair = pairs[index]; + + return [matches(pair[0]), matches(pair[1])]; + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should coerce `path` to a string', function(assert) { + assert.expect(2); + + function fn() {} + fn.toString = lodashStable.constant('fn'); + + var object = { 'null': 1, 'undefined': 2, 'fn': 3, '[object Object]': 4 }, + paths = [null, undefined, fn, {}], + expected = lodashStable.map(paths, stubTrue); + + lodashStable.times(2, function(index) { + var actual = lodashStable.map(paths, function(path) { + var matches = _.matchesProperty(index ? [path] : path, object[path]); + return matches(object); + }); + + assert.deepEqual(actual, expected); + }); + }); + + QUnit.test('should match a key over a path', function(assert) { + assert.expect(2); + + var object = { 'a.b': 1, 'a': { 'b': 2 } }; + + lodashStable.each(['a.b', ['a.b']], function(path) { + var matches = _.matchesProperty(path, 1); + assert.strictEqual(matches(object), true); + }); + }); + + QUnit.test('should return `false` when `object` is nullish', function(assert) { + assert.expect(2); + + var values = [, null, undefined], + expected = lodashStable.map(values, stubFalse); + + lodashStable.each(['constructor', ['constructor']], function(path) { + var matches = _.matchesProperty(path, 1); + + var actual = lodashStable.map(values, function(value, index) { + try { + return index ? matches(value) : matches(); + } catch (e) {} + }); + + assert.deepEqual(actual, expected); + }); + }); + + QUnit.test('should return `false` for deep paths when `object` is nullish', function(assert) { + assert.expect(2); + + var values = [, null, undefined], + expected = lodashStable.map(values, stubFalse); + + lodashStable.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], function(path) { + var matches = _.matchesProperty(path, 1); + + var actual = lodashStable.map(values, function(value, index) { + try { + return index ? matches(value) : matches(); + } catch (e) {} + }); + + assert.deepEqual(actual, expected); + }); + }); + + QUnit.test('should return `false` if parts of `path` are missing', function(assert) { + assert.expect(4); + + var object = {}; + + lodashStable.each(['a', 'a[1].b.c', ['a'], ['a', '1', 'b', 'c']], function(path) { + var matches = _.matchesProperty(path, 1); + assert.strictEqual(matches(object), false); + }); + }); + + QUnit.test('should match inherited string keyed `srcValue` properties', function(assert) { + assert.expect(2); + + function Foo() {} + Foo.prototype.b = 2; + + var object = { 'a': new Foo }; + + lodashStable.each(['a', ['a']], function(path) { + var matches = _.matchesProperty(path, { 'b': 2 }); + assert.strictEqual(matches(object), true); + }); + }); + + QUnit.test('should not match by inherited `srcValue` properties', function(assert) { + assert.expect(2); + + function Foo() { + this.a = 1; + } + Foo.prototype.b = 2; + + var objects = [{ 'a': { 'a': 1 } }, { 'a': { 'a': 1, 'b': 2 } }], + expected = lodashStable.map(objects, stubTrue); + + lodashStable.each(['a', ['a']], function(path) { + assert.deepEqual(lodashStable.map(objects, _.matchesProperty(path, new Foo)), expected); + }); + }); + + QUnit.test('should compare a variety of values', function(assert) { + assert.expect(2); + + var object1 = { 'a': false, 'b': true, 'c': '3', 'd': 4, 'e': [5], 'f': { 'g': 6 } }, + object2 = { 'a': 0, 'b': 1, 'c': 3, 'd': '4', 'e': ['5'], 'f': { 'g': '6' } }, + matches = _.matchesProperty('a', object1); + + assert.strictEqual(matches({ 'a': object1 }), true); + assert.strictEqual(matches({ 'a': object2 }), false); + }); + + QUnit.test('should match `-0` as `0`', function(assert) { + assert.expect(2); + + var matches = _.matchesProperty('a', -0); + assert.strictEqual(matches({ 'a': 0 }), true); + + matches = _.matchesProperty('a', 0); + assert.strictEqual(matches({ 'a': -0 }), true); + }); + + QUnit.test('should compare functions by reference', function(assert) { + assert.expect(3); + + var object1 = { 'a': lodashStable.noop }, + object2 = { 'a': noop }, + object3 = { 'a': {} }, + matches = _.matchesProperty('a', object1); + + assert.strictEqual(matches({ 'a': object1 }), true); + assert.strictEqual(matches({ 'a': object2 }), false); + assert.strictEqual(matches({ 'a': object3 }), false); + }); + + QUnit.test('should work with a function for `srcValue`', function(assert) { + assert.expect(1); + + function Foo() {} + Foo.a = 1; + Foo.b = function() {}; + Foo.c = 3; + + var objects = [{ 'a': { 'a': 1 } }, { 'a': { 'a': 1, 'b': Foo.b, 'c': 3 } }], + actual = lodashStable.map(objects, _.matchesProperty('a', Foo)); + + assert.deepEqual(actual, [false, true]); + }); + + QUnit.test('should work with a non-plain `srcValue`', function(assert) { + assert.expect(1); + + function Foo(object) { lodashStable.assign(this, object); } + + var object = new Foo({ 'a': new Foo({ 'b': 1, 'c': 2 }) }), + matches = _.matchesProperty('a', { 'b': 1 }); + + assert.strictEqual(matches(object), true); + }); + + QUnit.test('should partial match arrays', function(assert) { + assert.expect(3); + + var objects = [{ 'a': ['b'] }, { 'a': ['c', 'd'] }], + actual = lodashStable.filter(objects, _.matchesProperty('a', ['d'])); + + assert.deepEqual(actual, [objects[1]]); + + actual = lodashStable.filter(objects, _.matchesProperty('a', ['b', 'd'])); + assert.deepEqual(actual, []); + + actual = lodashStable.filter(objects, _.matchesProperty('a', ['d', 'b'])); + assert.deepEqual(actual, []); + }); + + QUnit.test('should partial match arrays with duplicate values', function(assert) { + assert.expect(1); + + var objects = [{ 'a': [1, 2] }, { 'a': [2, 2] }], + actual = lodashStable.filter(objects, _.matchesProperty('a', [2, 2])); + + assert.deepEqual(actual, [objects[1]]); + }); + + QUnit.test('should partial match arrays of objects', function(assert) { + assert.expect(1); + + var objects = [ + { 'a': [{ 'a': 1, 'b': 2 }, { 'a': 4, 'b': 5, 'c': 6 }] }, + { 'a': [{ 'a': 1, 'b': 2 }, { 'a': 4, 'b': 6, 'c': 7 }] } + ]; + + var actual = lodashStable.filter(objects, _.matchesProperty('a', [{ 'a': 1 }, { 'a': 4, 'b': 5 }])); + assert.deepEqual(actual, [objects[0]]); + }); + QUnit.test('should partial match maps', function(assert) { + assert.expect(3); + + if (Map) { + var objects = [{ 'a': new Map }, { 'a': new Map }]; + objects[0].a.set('a', 1); + objects[1].a.set('a', 1); + objects[1].a.set('b', 2); + + var map = new Map; + map.set('b', 2); + var actual = lodashStable.filter(objects, _.matchesProperty('a', map)); + + assert.deepEqual(actual, [objects[1]]); + + map.delete('b'); + actual = lodashStable.filter(objects, _.matchesProperty('a', map)); + + assert.deepEqual(actual, objects); + + map.set('c', 3); + actual = lodashStable.filter(objects, _.matchesProperty('a', map)); + + assert.deepEqual(actual, []); + } + else { + skipAssert(assert, 3); + } + }); + + QUnit.test('should partial match sets', function(assert) { + assert.expect(3); + + if (Set) { + var objects = [{ 'a': new Set }, { 'a': new Set }]; + objects[0].a.add(1); + objects[1].a.add(1); + objects[1].a.add(2); + + var set = new Set; + set.add(2); + var actual = lodashStable.filter(objects, _.matchesProperty('a', set)); + + assert.deepEqual(actual, [objects[1]]); + + set.delete(2); + actual = lodashStable.filter(objects, _.matchesProperty('a', set)); + + assert.deepEqual(actual, objects); + + set.add(3); + actual = lodashStable.filter(objects, _.matchesProperty('a', set)); + + assert.deepEqual(actual, []); + } + else { + skipAssert(assert, 3); + } + }); + + QUnit.test('should match `undefined` values', function(assert) { + assert.expect(2); + + var objects = [{ 'a': 1 }, { 'a': 1, 'b': 1 }, { 'a': 1, 'b': undefined }], + actual = lodashStable.map(objects, _.matchesProperty('b', undefined)), + expected = [false, false, true]; + + assert.deepEqual(actual, expected); + + objects = [{ 'a': { 'a': 1 } }, { 'a': { 'a': 1, 'b': 1 } }, { 'a': { 'a': 1, 'b': undefined } }]; + actual = lodashStable.map(objects, _.matchesProperty('a', { 'b': undefined })); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should match `undefined` values of nested objects', function(assert) { + assert.expect(4); + + var object = { 'a': { 'b': undefined } }; + + lodashStable.each(['a.b', ['a', 'b']], function(path) { + var matches = _.matchesProperty(path, undefined); + assert.strictEqual(matches(object), true); + }); + + lodashStable.each(['a.a', ['a', 'a']], function(path) { + var matches = _.matchesProperty(path, undefined); + assert.strictEqual(matches(object), false); + }); + }); + + QUnit.test('should match `undefined` values on primitives', function(assert) { + assert.expect(2); + + numberProto.a = 1; + numberProto.b = undefined; + + try { + var matches = _.matchesProperty('b', undefined); + assert.strictEqual(matches(1), true); + } catch (e) { + assert.ok(false, e.message); + } + numberProto.a = { 'b': 1, 'c': undefined }; + try { + matches = _.matchesProperty('a', { 'c': undefined }); + assert.strictEqual(matches(1), true); + } catch (e) { + assert.ok(false, e.message); + } + delete numberProto.a; + delete numberProto.b; + }); + + QUnit.test('should return `true` when comparing a `srcValue` of empty arrays and objects', function(assert) { + assert.expect(1); + + var objects = [{ 'a': [1], 'b': { 'c': 1 } }, { 'a': [2, 3], 'b': { 'd': 2 } }], + matches = _.matchesProperty('a', { 'a': [], 'b': {} }); + + var actual = lodashStable.filter(objects, function(object) { + return matches({ 'a': object }); + }); + + assert.deepEqual(actual, objects); + }); + + QUnit.test('should not change behavior if `srcValue` is modified', function(assert) { + assert.expect(9); + + lodashStable.each([{ 'a': { 'b': 2, 'c': 3 } }, { 'a': 1, 'b': 2 }, { 'a': 1 }], function(source, index) { + var object = lodashStable.cloneDeep(source), + matches = _.matchesProperty('a', source); + + assert.strictEqual(matches({ 'a': object }), true); + + if (index) { + source.a = 2; + source.b = 1; + source.c = 3; + } else { + source.a.b = 1; + source.a.c = 2; + source.a.d = 3; + } + assert.strictEqual(matches({ 'a': object }), true); + assert.strictEqual(matches({ 'a': source }), false); + }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.max'); + + (function() { + QUnit.test('should return the largest value from a collection', function(assert) { + assert.expect(1); + + assert.strictEqual(_.max([1, 2, 3]), 3); + }); + + QUnit.test('should return `undefined` for empty collections', function(assert) { + assert.expect(1); + + var values = falsey.concat([[]]), + expected = lodashStable.map(values, noop); + + var actual = lodashStable.map(values, function(value, index) { + try { + return index ? _.max(value) : _.max(); + } catch (e) {} + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should work with non-numeric collection values', function(assert) { + assert.expect(1); + + assert.strictEqual(_.max(['a', 'b']), 'b'); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.mean'); + + (function() { + QUnit.test('should return the mean of an array of numbers', function(assert) { + assert.expect(1); + + var array = [4, 2, 8, 6]; + assert.strictEqual(_.mean(array), 5); + }); + + QUnit.test('should return `NaN` when passing empty `array` values', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(empties, stubNaN), + actual = lodashStable.map(empties, _.mean); + + assert.deepEqual(actual, expected); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.meanBy'); + + (function() { + var objects = [{ 'a': 2 }, { 'a': 3 }, { 'a': 1 }]; + + QUnit.test('should work with an `iteratee`', function(assert) { + assert.expect(1); + + var actual = _.meanBy(objects, function(object) { + return object.a; + }); + + assert.deepEqual(actual, 2); + }); + + QUnit.test('should provide correct `iteratee` arguments', function(assert) { + assert.expect(1); + + var args; + + _.meanBy(objects, function() { + args || (args = slice.call(arguments)); + }); + + assert.deepEqual(args, [{ 'a': 2 }]); + }); + + QUnit.test('should work with `_.property` shorthands', function(assert) { + assert.expect(2); + + var arrays = [[2], [3], [1]]; + assert.strictEqual(_.meanBy(arrays, 0), 2); + assert.strictEqual(_.meanBy(objects, 'a'), 2); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.memoize'); + + (function() { + function CustomCache() { + this.clear(); + } + + CustomCache.prototype = { + 'clear': function() { + this.__data__ = []; + return this; + }, + 'get': function(key) { + var entry = lodashStable.find(this.__data__, ['key', key]); + return entry && entry.value; + }, + 'has': function(key) { + return lodashStable.some(this.__data__, ['key', key]); + }, + 'set': function(key, value) { + this.__data__.push({ 'key': key, 'value': value }); + return this; + } + }; + + function ImmutableCache() { + this.__data__ = []; + } + + ImmutableCache.prototype = lodashStable.create(CustomCache.prototype, { + 'constructor': ImmutableCache, + 'clear': function() { + return new ImmutableCache; + }, + 'set': function(key, value) { + var result = new ImmutableCache; + result.__data__ = this.__data__.concat({ 'key': key, 'value': value }); + return result; + } + }); + + QUnit.test('should memoize results based on the first argument given', function(assert) { + assert.expect(2); + + var memoized = _.memoize(function(a, b, c) { + return a + b + c; + }); + + assert.strictEqual(memoized(1, 2, 3), 6); + assert.strictEqual(memoized(1, 3, 5), 6); + }); + + QUnit.test('should support a `resolver`', function(assert) { + assert.expect(2); + + var fn = function(a, b, c) { return a + b + c; }, + memoized = _.memoize(fn, fn); + + assert.strictEqual(memoized(1, 2, 3), 6); + assert.strictEqual(memoized(1, 3, 5), 9); + }); + + QUnit.test('should use `this` binding of function for `resolver`', function(assert) { + assert.expect(2); + + var fn = function(a, b, c) { return a + this.b + this.c; }, + memoized = _.memoize(fn, fn); + + var object = { 'memoized': memoized, 'b': 2, 'c': 3 }; + assert.strictEqual(object.memoized(1), 6); + + object.b = 3; + object.c = 5; + assert.strictEqual(object.memoized(1), 9); + }); + + QUnit.test('should throw a TypeError if `resolve` is truthy and not a function', function(assert) { + assert.expect(1); + + assert.raises(function() { _.memoize(noop, true); }, TypeError); + }); + + QUnit.test('should not error if `resolver` is nullish', function(assert) { + assert.expect(1); + + var values = [, null, undefined], + expected = lodashStable.map(values, stubTrue); + + var actual = lodashStable.map(values, function(resolver, index) { + try { + return _.isFunction(index ? _.memoize(noop, resolver) : _.memoize(noop)); + } catch (e) {} + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should check cache for own properties', function(assert) { + assert.expect(1); + + var props = [ + 'constructor', + 'hasOwnProperty', + 'isPrototypeOf', + 'propertyIsEnumerable', + 'toLocaleString', + 'toString', + 'valueOf' + ]; + + var memoized = _.memoize(identity); + + var actual = lodashStable.map(props, function(value) { + return memoized(value); + }); + + assert.deepEqual(actual, props); + }); + + QUnit.test('should cache the `__proto__` key', function(assert) { + assert.expect(8); + + var array = [], + key = '__proto__'; + + lodashStable.times(2, function(index) { + var count = 0, + resolver = index ? identity : undefined; + + var memoized = _.memoize(function() { + count++; + return array; + }, resolver); + + var cache = memoized.cache; + + memoized(key); + memoized(key); + + assert.strictEqual(count, 1); + assert.strictEqual(cache.get(key), array); + assert.notOk(cache.__data__ instanceof Array); + assert.strictEqual(cache.delete(key), true); + }); + }); + + QUnit.test('should allow `_.memoize.Cache` to be customized', function(assert) { + assert.expect(4); + + var oldCache = _.memoize.Cache; + _.memoize.Cache = CustomCache; + + var memoized = _.memoize(function(object) { + return object.id; + }); + + var cache = memoized.cache, + key1 = { 'id': 'a' }, + key2 = { 'id': 'b' }; + + assert.strictEqual(memoized(key1), 'a'); + assert.strictEqual(cache.has(key1), true); + + assert.strictEqual(memoized(key2), 'b'); + assert.strictEqual(cache.has(key2), true); + + _.memoize.Cache = oldCache; + }); + + QUnit.test('should works with an immutable `_.memoize.Cache` ', function(assert) { + assert.expect(2); + + var oldCache = _.memoize.Cache; + _.memoize.Cache = ImmutableCache; + + var memoized = _.memoize(function(object) { + return object.id; + }); + + var key1 = { 'id': 'a' }, + key2 = { 'id': 'b' }; + + memoized(key1); + memoized(key2); + + var cache = memoized.cache; + assert.strictEqual(cache.has(key1), true); + assert.strictEqual(cache.has(key2), true); + + _.memoize.Cache = oldCache; + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('memoizeCapped'); + + (function() { + var func = _._memoizeCapped; + + QUnit.test('should enforce a max cache size of `MAX_MEMOIZE_SIZE`', function(assert) { + assert.expect(2); + + if (func) { + var memoized = func(identity), + cache = memoized.cache; + + lodashStable.times(MAX_MEMOIZE_SIZE, memoized); + assert.strictEqual(cache.size, MAX_MEMOIZE_SIZE); + + memoized(MAX_MEMOIZE_SIZE); + assert.strictEqual(cache.size, 1); + } + else { + skipAssert(assert, 2); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.merge'); + + (function() { + QUnit.test('should merge `source` into `object`', function(assert) { + assert.expect(1); + + var names = { + 'characters': [ + { 'name': 'barney' }, + { 'name': 'fred' } + ] + }; + + var ages = { + 'characters': [ + { 'age': 36 }, + { 'age': 40 } + ] + }; + + var heights = { + 'characters': [ + { 'height': '5\'4"' }, + { 'height': '5\'5"' } + ] + }; + + var expected = { + 'characters': [ + { 'name': 'barney', 'age': 36, 'height': '5\'4"' }, + { 'name': 'fred', 'age': 40, 'height': '5\'5"' } + ] + }; + + assert.deepEqual(_.merge(names, ages, heights), expected); + }); + + QUnit.test('should merge sources containing circular references', function(assert) { + assert.expect(2); + + var object = { + 'foo': { 'a': 1 }, + 'bar': { 'a': 2 } + }; + + var source = { + 'foo': { 'b': { 'c': { 'd': {} } } }, + 'bar': {} + }; + + source.foo.b.c.d = source; + source.bar.b = source.foo.b; + + var actual = _.merge(object, source); + + assert.notStrictEqual(actual.bar.b, actual.foo.b); + assert.strictEqual(actual.foo.b.c.d, actual.foo.b.c.d.foo.b.c.d); + }); + + QUnit.test('should work with four arguments', function(assert) { + assert.expect(1); + + var expected = { 'a': 4 }, + actual = _.merge({ 'a': 1 }, { 'a': 2 }, { 'a': 3 }, expected); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should merge onto function `object` values', function(assert) { + assert.expect(2); + + function Foo() {} + + var source = { 'a': 1 }, + actual = _.merge(Foo, source); + + assert.strictEqual(actual, Foo); + assert.strictEqual(Foo.a, 1); + }); + + QUnit.test('should merge first source object properties to function', function(assert) { + assert.expect(1); + + var fn = function() {}, + object = { 'prop': {} }, + actual = _.merge({ 'prop': fn }, object); + + assert.deepEqual(actual, object); + }); + + QUnit.test('should merge first and second source object properties to function', function(assert) { + assert.expect(1); + + var fn = function() {}, + object = { 'prop': {} }, + actual = _.merge({ 'prop': fn }, { 'prop': fn }, object); + + assert.deepEqual(actual, object); + }); + + QUnit.test('should not merge onto function values of sources', function(assert) { + assert.expect(3); + + var source1 = { 'a': function() {} }, + source2 = { 'a': { 'b': 2 } }, + expected = { 'a': { 'b': 2 } }, + actual = _.merge({}, source1, source2); + + assert.deepEqual(actual, expected); + assert.notOk('b' in source1.a); + + actual = _.merge(source1, source2); + assert.deepEqual(actual, expected); + }); + + QUnit.test('should merge onto non-plain `object` values', function(assert) { + assert.expect(2); + + function Foo() {} + + var object = new Foo, + actual = _.merge(object, { 'a': 1 }); + + assert.strictEqual(actual, object); + assert.strictEqual(object.a, 1); + }); + + QUnit.test('should treat sparse array sources as dense', function(assert) { + assert.expect(2); + + var array = [1]; + array[2] = 3; + + var actual = _.merge([], array), + expected = array.slice(); + + expected[1] = undefined; + + assert.ok('1' in actual); + assert.deepEqual(actual, expected); + }); + + QUnit.test('should merge `arguments` objects', function(assert) { + assert.expect(7); + + var object1 = { 'value': args }, + object2 = { 'value': { '3': 4 } }, + expected = { '0': 1, '1': 2, '2': 3, '3': 4 }, + actual = _.merge(object1, object2); + + assert.notOk('3' in args); + assert.notOk(_.isArguments(actual.value)); + assert.deepEqual(actual.value, expected); + object1.value = args; + + actual = _.merge(object2, object1); + assert.notOk(_.isArguments(actual.value)); + assert.deepEqual(actual.value, expected); + + expected = { '0': 1, '1': 2, '2': 3 }; + + actual = _.merge({}, object1); + assert.notOk(_.isArguments(actual.value)); + assert.deepEqual(actual.value, expected); + }); + + QUnit.test('should merge typed arrays', function(assert) { + assert.expect(4); + + var array1 = [0], + array2 = [0, 0], + array3 = [0, 0, 0, 0], + array4 = [0, 0, 0, 0, 0, 0, 0, 0]; + + var arrays = [array2, array1, array4, array3, array2, array4, array4, array3, array2], + buffer = ArrayBuffer && new ArrayBuffer(8); + + var expected = lodashStable.map(typedArrays, function(type, index) { + var array = arrays[index].slice(); + array[0] = 1; + return root[type] ? { 'value': array } : false; + }); + + var actual = lodashStable.map(typedArrays, function(type) { + var Ctor = root[type]; + return Ctor ? _.merge({ 'value': new Ctor(buffer) }, { 'value': [1] }) : false; + }); + + assert.ok(lodashStable.isArray(actual)); + assert.deepEqual(actual, expected); + + expected = lodashStable.map(typedArrays, function(type, index) { + var array = arrays[index].slice(); + array.push(1); + return root[type] ? { 'value': array } : false; + }); + + actual = lodashStable.map(typedArrays, function(type, index) { + var Ctor = root[type], + array = lodashStable.range(arrays[index].length); + + array.push(1); + return Ctor ? _.merge({ 'value': array }, { 'value': new Ctor(buffer) }) : false; + }); + + assert.ok(lodashStable.isArray(actual)); + assert.deepEqual(actual, expected); + }); + + QUnit.test('should assign `null` values', function(assert) { + assert.expect(1); + + var actual = _.merge({ 'a': 1 }, { 'a': null }); + assert.strictEqual(actual.a, null); + }); + + QUnit.test('should assign non array/buffer/typed-array/plain-object source values directly', function(assert) { + assert.expect(1); + + function Foo() {} + + var values = [new Foo, new Boolean, new Date, Foo, new Number, new String, new RegExp], + expected = lodashStable.map(values, stubTrue); + + var actual = lodashStable.map(values, function(value) { + var object = _.merge({}, { 'a': value, 'b': { 'c': value } }); + return object.a === value && object.b.c === value; + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should clone buffer source values', function(assert) { + assert.expect(3); + + if (Buffer) { + var buffer = new Buffer([1]), + actual = _.merge({}, { 'value': buffer }).value; + + assert.ok(lodashStable.isBuffer(actual)); + assert.strictEqual(actual[0], buffer[0]); + assert.notStrictEqual(actual, buffer); + } + else { + skipAssert(assert, 3); + } + }); + + QUnit.test('should deep clone array/typed-array/plain-object source values', function(assert) { + assert.expect(1); + + var typedArray = Uint8Array + ? new Uint8Array([1]) + : { 'buffer': [1] }; + + var props = ['0', 'buffer', 'a'], + values = [[{ 'a': 1 }], typedArray, { 'a': [1] }], + expected = lodashStable.map(values, stubTrue); + + var actual = lodashStable.map(values, function(value, index) { + var key = props[index], + object = _.merge({}, { 'value': value }), + subValue = value[key], + newValue = object.value, + newSubValue = newValue[key]; + + return ( + newValue !== value && + newSubValue !== subValue && + lodashStable.isEqual(newValue, value) + ); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should not augment source objects', function(assert) { + assert.expect(6); + + var source1 = { 'a': [{ 'a': 1 }] }, + source2 = { 'a': [{ 'b': 2 }] }, + actual = _.merge({}, source1, source2); + + assert.deepEqual(source1.a, [{ 'a': 1 }]); + assert.deepEqual(source2.a, [{ 'b': 2 }]); + assert.deepEqual(actual.a, [{ 'a': 1, 'b': 2 }]); + + var source1 = { 'a': [[1, 2, 3]] }, + source2 = { 'a': [[3, 4]] }, + actual = _.merge({}, source1, source2); + + assert.deepEqual(source1.a, [[1, 2, 3]]); + assert.deepEqual(source2.a, [[3, 4]]); + assert.deepEqual(actual.a, [[3, 4, 3]]); + }); + + QUnit.test('should merge plain objects onto non-plain objects', function(assert) { + assert.expect(4); + + function Foo(object) { + lodashStable.assign(this, object); + } + + var object = { 'a': 1 }, + actual = _.merge(new Foo, object); + + assert.ok(actual instanceof Foo); + assert.deepEqual(actual, new Foo(object)); + + actual = _.merge([new Foo], [object]); + assert.ok(actual[0] instanceof Foo); + assert.deepEqual(actual, [new Foo(object)]); + }); + + QUnit.test('should not overwrite existing values with `undefined` values of object sources', function(assert) { + assert.expect(1); + + var actual = _.merge({ 'a': 1 }, { 'a': undefined, 'b': undefined }); + assert.deepEqual(actual, { 'a': 1, 'b': undefined }); + }); + + QUnit.test('should not overwrite existing values with `undefined` values of array sources', function(assert) { + assert.expect(2); + + var array = [1]; + array[2] = 3; + + var actual = _.merge([4, 5, 6], array), + expected = [1, 5, 3]; + + assert.deepEqual(actual, expected); + + array = [1, , 3]; + array[1] = undefined; + + actual = _.merge([4, 5, 6], array); + assert.deepEqual(actual, expected); + }); + + QUnit.test('should skip merging when `object` and `source` are the same value', function(assert) { + assert.expect(1); + + var object = {}, + pass = true; + + defineProperty(object, 'a', { + 'configurable': true, + 'enumerable': true, + 'get': function() { pass = false; }, + 'set': function() { pass = false; } + }); + + _.merge(object, object); + assert.ok(pass); + }); + + QUnit.test('should convert values to arrays when merging arrays of `source`', function(assert) { + assert.expect(2); + + var object = { 'a': { '1': 'y', 'b': 'z', 'length': 2 } }, + actual = _.merge(object, { 'a': ['x'] }); + + assert.deepEqual(actual, { 'a': ['x', 'y'] }); + + actual = _.merge({ 'a': {} }, { 'a': [] }); + assert.deepEqual(actual, { 'a': [] }); + }); + + QUnit.test('should not convert strings to arrays when merging arrays of `source`', function(assert) { + assert.expect(1); + + var object = { 'a': 'abcde' }, + actual = _.merge(object, { 'a': ['x', 'y', 'z'] }); + + assert.deepEqual(actual, { 'a': ['x', 'y', 'z'] }); + }); + + QUnit.test('should not error on DOM elements', function(assert) { + assert.expect(1); + + var object1 = { 'el': document && document.createElement('div') }, + object2 = { 'el': document && document.createElement('div') }, + pairs = [[{}, object1], [object1, object2]], + expected = lodashStable.map(pairs, stubTrue); + + var actual = lodashStable.map(pairs, function(pair) { + try { + return _.merge(pair[0], pair[1]).el === pair[1].el; + } catch (e) {} + }); + + assert.deepEqual(actual, expected); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.mergeWith'); + + (function() { + QUnit.test('should handle merging when `customizer` returns `undefined`', function(assert) { + assert.expect(2); + + var actual = _.mergeWith({ 'a': { 'b': [1, 1] } }, { 'a': { 'b': [0] } }, noop); + assert.deepEqual(actual, { 'a': { 'b': [0, 1] } }); + + actual = _.mergeWith([], [undefined], identity); + assert.deepEqual(actual, [undefined]); + }); + + QUnit.test('should clone sources when `customizer` returns `undefined`', function(assert) { + assert.expect(1); + + var source1 = { 'a': { 'b': { 'c': 1 } } }, + source2 = { 'a': { 'b': { 'd': 2 } } }; + + _.mergeWith({}, source1, source2, noop); + assert.deepEqual(source1.a.b, { 'c': 1 }); + }); + + QUnit.test('should defer to `customizer` for non `undefined` results', function(assert) { + assert.expect(1); + + var actual = _.mergeWith({ 'a': { 'b': [0, 1] } }, { 'a': { 'b': [2] } }, function(a, b) { + return lodashStable.isArray(a) ? a.concat(b) : undefined; + }); + + assert.deepEqual(actual, { 'a': { 'b': [0, 1, 2] } }); + }); + + QUnit.test('should provide `stack` to `customizer`', function(assert) { + assert.expect(4); + + var actual = []; + + _.mergeWith({}, { 'z': 1, 'a': { 'b': 2 } }, function() { + actual.push(_.last(arguments)); + }); + + assert.strictEqual(actual.length, 3); + _.each(actual, function(a) { + assert.ok(isNpm + ? a.constructor.name == 'Stack' + : a instanceof mapCaches.Stack + ); + }); + }); + + QUnit.test('should overwrite primitives with source object clones', function(assert) { + assert.expect(1); + + var actual = _.mergeWith({ 'a': 0 }, { 'a': { 'b': ['c'] } }, function(a, b) { + return lodashStable.isArray(a) ? a.concat(b) : undefined; + }); + + assert.deepEqual(actual, { 'a': { 'b': ['c'] } }); + }); + + QUnit.test('should pop the stack of sources for each sibling property', function(assert) { + assert.expect(1); + + var array = ['b', 'c'], + object = { 'a': ['a'] }, + source = { 'a': array, 'b': array }; + + var actual = _.mergeWith(object, source, function(a, b) { + return lodashStable.isArray(a) ? a.concat(b) : undefined; + }); + + assert.deepEqual(actual, { 'a': ['a', 'b', 'c'], 'b': ['b', 'c'] }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.method'); + + (function() { + QUnit.test('should create a function that calls a method of a given object', function(assert) { + assert.expect(4); + + var object = { 'a': stubOne }; + + lodashStable.each(['a', ['a']], function(path) { + var method = _.method(path); + assert.strictEqual(method.length, 1); + assert.strictEqual(method(object), 1); + }); + }); + + QUnit.test('should work with deep property values', function(assert) { + assert.expect(2); + + var object = { 'a': { 'b': stubTwo } }; + + lodashStable.each(['a.b', ['a', 'b']], function(path) { + var method = _.method(path); + assert.strictEqual(method(object), 2); + }); + }); + + QUnit.test('should work with a non-string `path`', function(assert) { + assert.expect(2); + + var array = lodashStable.times(3, _.constant); + + lodashStable.each([1, [1]], function(path) { + var method = _.method(path); + assert.strictEqual(method(array), 1); + }); + }); + + QUnit.test('should coerce `path` to a string', function(assert) { + assert.expect(2); + + function fn() {} + fn.toString = lodashStable.constant('fn'); + + var expected = [1, 2, 3, 4], + object = { 'null': stubOne, 'undefined': stubTwo, 'fn': stubThree, '[object Object]': stubFour }, + paths = [null, undefined, fn, {}]; + + lodashStable.times(2, function(index) { + var actual = lodashStable.map(paths, function(path) { + var method = _.method(index ? [path] : path); + return method(object); + }); + + assert.deepEqual(actual, expected); + }); + }); + + QUnit.test('should work with inherited property values', function(assert) { + assert.expect(2); + + function Foo() {} + Foo.prototype.a = stubOne; + + lodashStable.each(['a', ['a']], function(path) { + var method = _.method(path); + assert.strictEqual(method(new Foo), 1); + }); + }); + + QUnit.test('should use a key over a path', function(assert) { + assert.expect(2); + + var object = { 'a.b': stubOne, 'a': { 'b': stubTwo } }; + + lodashStable.each(['a.b', ['a.b']], function(path) { + var method = _.method(path); + assert.strictEqual(method(object), 1); + }); + }); + + QUnit.test('should return `undefined` when `object` is nullish', function(assert) { + assert.expect(2); + + var values = [, null, undefined], + expected = lodashStable.map(values, noop); + + lodashStable.each(['constructor', ['constructor']], function(path) { + var method = _.method(path); + + var actual = lodashStable.map(values, function(value, index) { + return index ? method(value) : method(); + }); + + assert.deepEqual(actual, expected); + }); + }); + + QUnit.test('should return `undefined` for deep paths when `object` is nullish', function(assert) { + assert.expect(2); + + var values = [, null, undefined], + expected = lodashStable.map(values, noop); + + lodashStable.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], function(path) { + var method = _.method(path); + + var actual = lodashStable.map(values, function(value, index) { + return index ? method(value) : method(); + }); + + assert.deepEqual(actual, expected); + }); + }); + + QUnit.test('should return `undefined` if parts of `path` are missing', function(assert) { + assert.expect(4); + + var object = {}; + + lodashStable.each(['a', 'a[1].b.c', ['a'], ['a', '1', 'b', 'c']], function(path) { + var method = _.method(path); + assert.strictEqual(method(object), undefined); + }); + }); + + QUnit.test('should apply partial arguments to function', function(assert) { + assert.expect(2); + + var object = { + 'fn': function() { + return slice.call(arguments); + } + }; + + lodashStable.each(['fn', ['fn']], function(path) { + var method = _.method(path, 1, 2, 3); + assert.deepEqual(method(object), [1, 2, 3]); + }); + }); + + QUnit.test('should invoke deep property methods with the correct `this` binding', function(assert) { + assert.expect(2); + + var object = { 'a': { 'b': function() { return this.c; }, 'c': 1 } }; + + lodashStable.each(['a.b', ['a', 'b']], function(path) { + var method = _.method(path); + assert.strictEqual(method(object), 1); + }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.methodOf'); + + (function() { + QUnit.test('should create a function that calls a method of a given key', function(assert) { + assert.expect(4); + + var object = { 'a': stubOne }; + + lodashStable.each(['a', ['a']], function(path) { + var methodOf = _.methodOf(object); + assert.strictEqual(methodOf.length, 1); + assert.strictEqual(methodOf(path), 1); + }); + }); + + QUnit.test('should work with deep property values', function(assert) { + assert.expect(2); + + var object = { 'a': { 'b': stubTwo } }; + + lodashStable.each(['a.b', ['a', 'b']], function(path) { + var methodOf = _.methodOf(object); + assert.strictEqual(methodOf(path), 2); + }); + }); + + QUnit.test('should work with a non-string `path`', function(assert) { + assert.expect(2); + + var array = lodashStable.times(3, _.constant); + + lodashStable.each([1, [1]], function(path) { + var methodOf = _.methodOf(array); + assert.strictEqual(methodOf(path), 1); + }); + }); + + QUnit.test('should coerce `path` to a string', function(assert) { + assert.expect(2); + + function fn() {} + fn.toString = lodashStable.constant('fn'); + + var expected = [1, 2, 3, 4], + object = { 'null': stubOne, 'undefined': stubTwo, 'fn': stubThree, '[object Object]': stubFour }, + paths = [null, undefined, fn, {}]; + + lodashStable.times(2, function(index) { + var actual = lodashStable.map(paths, function(path) { + var methodOf = _.methodOf(object); + return methodOf(index ? [path] : path); + }); + + assert.deepEqual(actual, expected); + }); + }); + + QUnit.test('should work with inherited property values', function(assert) { + assert.expect(2); + + function Foo() {} + Foo.prototype.a = stubOne; + + lodashStable.each(['a', ['a']], function(path) { + var methodOf = _.methodOf(new Foo); + assert.strictEqual(methodOf(path), 1); + }); + }); + + QUnit.test('should use a key over a path', function(assert) { + assert.expect(2); + + var object = { 'a.b': stubOne, 'a': { 'b': stubTwo } }; + + lodashStable.each(['a.b', ['a.b']], function(path) { + var methodOf = _.methodOf(object); + assert.strictEqual(methodOf(path), 1); + }); + }); + + QUnit.test('should return `undefined` when `object` is nullish', function(assert) { + assert.expect(2); + + var values = [, null, undefined], + expected = lodashStable.map(values, noop); + + lodashStable.each(['constructor', ['constructor']], function(path) { + var actual = lodashStable.map(values, function(value, index) { + var methodOf = index ? _.methodOf() : _.methodOf(value); + return methodOf(path); + }); + + assert.deepEqual(actual, expected); + }); + }); + + QUnit.test('should return `undefined` for deep paths when `object` is nullish', function(assert) { + assert.expect(2); + + var values = [, null, undefined], + expected = lodashStable.map(values, noop); + + lodashStable.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], function(path) { + var actual = lodashStable.map(values, function(value, index) { + var methodOf = index ? _.methodOf() : _.methodOf(value); + return methodOf(path); + }); + + assert.deepEqual(actual, expected); + }); + }); + + QUnit.test('should return `undefined` if parts of `path` are missing', function(assert) { + assert.expect(4); + + var object = {}, + methodOf = _.methodOf(object); + + lodashStable.each(['a', 'a[1].b.c', ['a'], ['a', '1', 'b', 'c']], function(path) { + assert.strictEqual(methodOf(path), undefined); + }); + }); + + QUnit.test('should apply partial arguments to function', function(assert) { + assert.expect(2); + + var object = { + 'fn': function() { + return slice.call(arguments); + } + }; + + var methodOf = _.methodOf(object, 1, 2, 3); + + lodashStable.each(['fn', ['fn']], function(path) { + assert.deepEqual(methodOf(path), [1, 2, 3]); + }); + }); + + QUnit.test('should invoke deep property methods with the correct `this` binding', function(assert) { + assert.expect(2); + + var object = { 'a': { 'b': function() { return this.c; }, 'c': 1 } }, + methodOf = _.methodOf(object); + + lodashStable.each(['a.b', ['a', 'b']], function(path) { + assert.strictEqual(methodOf(path), 1); + }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.min'); + + (function() { + QUnit.test('should return the smallest value from a collection', function(assert) { + assert.expect(1); + + assert.strictEqual(_.min([1, 2, 3]), 1); + }); + + QUnit.test('should return `undefined` for empty collections', function(assert) { + assert.expect(1); + + var values = falsey.concat([[]]), + expected = lodashStable.map(values, noop); + + var actual = lodashStable.map(values, function(value, index) { + try { + return index ? _.min(value) : _.min(); + } catch (e) {} + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should work with non-numeric collection values', function(assert) { + assert.expect(1); + + assert.strictEqual(_.min(['a', 'b']), 'a'); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('extremum methods'); + + lodashStable.each(['max', 'maxBy', 'min', 'minBy'], function(methodName) { + var func = _[methodName], + isMax = /^max/.test(methodName); + + QUnit.test('`_.' + methodName + '` should work with Date objects', function(assert) { + assert.expect(1); + + var curr = new Date, + past = new Date(0); + + assert.strictEqual(func([curr, past]), isMax ? curr : past); + }); + + QUnit.test('`_.' + methodName + '` should work with extremely large arrays', function(assert) { + assert.expect(1); + + var array = lodashStable.range(0, 5e5); + assert.strictEqual(func(array), isMax ? 499999 : 0); + }); + + QUnit.test('`_.' + methodName + '` should work when chaining on an array with only one value', function(assert) { + assert.expect(1); + + if (!isNpm) { + var actual = _([40])[methodName](); + assert.strictEqual(actual, 40); + } + else { + skipAssert(assert); + } + }); + }); + + lodashStable.each(['maxBy', 'minBy'], function(methodName) { + var array = [1, 2, 3], + func = _[methodName], + isMax = methodName == 'maxBy'; + + QUnit.test('`_.' + methodName + '` should work with an `iteratee`', function(assert) { + assert.expect(1); + + var actual = func(array, function(n) { + return -n; + }); + + assert.strictEqual(actual, isMax ? 1 : 3); + }); + + QUnit.test('should work with `_.property` shorthands', function(assert) { + assert.expect(2); + + var objects = [{ 'a': 2 }, { 'a': 3 }, { 'a': 1 }], + actual = func(objects, 'a'); + + assert.deepEqual(actual, objects[isMax ? 1 : 2]); + + var arrays = [[2], [3], [1]]; + actual = func(arrays, 0); + + assert.deepEqual(actual, arrays[isMax ? 1 : 2]); + }); + + QUnit.test('`_.' + methodName + '` should work when `iteratee` returns +/-Infinity', function(assert) { + assert.expect(1); + + var value = isMax ? -Infinity : Infinity, + object = { 'a': value }; + + var actual = func([object, { 'a': value }], function(object) { + return object.a; + }); + + assert.strictEqual(actual, object); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.mixin'); + + (function() { + function reset(wrapper) { + delete wrapper.a; + delete wrapper.prototype.a; + delete wrapper.b; + delete wrapper.prototype.b; + } + + function Wrapper(value) { + if (!(this instanceof Wrapper)) { + return new Wrapper(value); + } + if (_.has(value, '__wrapped__')) { + var actions = slice.call(value.__actions__), + chain = value.__chain__; + + value = value.__wrapped__; + } + this.__wrapped__ = value; + this.__actions__ = actions || []; + this.__chain__ = chain || false; + } + + Wrapper.prototype.value = function() { + return getUnwrappedValue(this); + }; + + var array = ['a'], + source = { 'a': function(array) { return array[0]; }, 'b': 'B' }; + + QUnit.test('should mixin `source` methods into lodash', function(assert) { + assert.expect(4); + + if (!isNpm) { + _.mixin(source); + + assert.strictEqual(_.a(array), 'a'); + assert.strictEqual(_(array).a().value(), 'a'); + assert.notOk('b' in _); + assert.notOk('b' in _.prototype); + + reset(_); + } + else { + skipAssert(assert, 4); + } + }); + + QUnit.test('should mixin chaining methods by reference', function(assert) { + assert.expect(2); + + if (!isNpm) { + _.mixin(source); + _.a = stubB; + + assert.strictEqual(_.a(array), 'b'); + assert.strictEqual(_(array).a().value(), 'a'); + + reset(_); + } + else { + skipAssert(assert, 2); + } + }); + + QUnit.test('should use a default `object` of `this`', function(assert) { + assert.expect(3); + + var object = lodashStable.create(_); + object.mixin(source); + + assert.strictEqual(object.a(array), 'a'); + assert.notOk('a' in _); + assert.notOk('a' in _.prototype); + + reset(_); + }); + + QUnit.test('should accept an `object`', function(assert) { + assert.expect(1); + + var object = {}; + _.mixin(object, source); + assert.strictEqual(object.a(array), 'a'); + }); + + QUnit.test('should accept a function `object`', function(assert) { + assert.expect(2); + + _.mixin(Wrapper, source); + + var wrapped = Wrapper(array), + actual = wrapped.a(); + + assert.strictEqual(actual.value(), 'a'); + assert.ok(actual instanceof Wrapper); + + reset(Wrapper); + }); + + QUnit.test('should return `object`', function(assert) { + assert.expect(3); + + var object = {}; + assert.strictEqual(_.mixin(object, source), object); + assert.strictEqual(_.mixin(Wrapper, source), Wrapper); + assert.strictEqual(_.mixin(), _); + + reset(Wrapper); + }); + + QUnit.test('should not assign inherited `source` methods', function(assert) { + assert.expect(1); + + function Foo() {} + Foo.prototype.a = noop; + + var object = {}; + assert.strictEqual(_.mixin(object, new Foo), object); + }); + + QUnit.test('should accept an `options`', function(assert) { + assert.expect(8); + + function message(func, chain) { + return (func === _ ? 'lodash' : 'given') + ' function should ' + (chain ? '' : 'not ') + 'chain'; + } + + lodashStable.each([_, Wrapper], function(func) { + lodashStable.each([{ 'chain': false }, { 'chain': true }], function(options) { + if (!isNpm) { + if (func === _) { + _.mixin(source, options); + } else { + _.mixin(func, source, options); + } + var wrapped = func(array), + actual = wrapped.a(); + + if (options.chain) { + assert.strictEqual(actual.value(), 'a', message(func, true)); + assert.ok(actual instanceof func, message(func, true)); + } else { + assert.strictEqual(actual, 'a', message(func, false)); + assert.notOk(actual instanceof func, message(func, false)); + } + reset(func); + } + else { + skipAssert(assert, 2); + } + }); + }); + }); + + QUnit.test('should not extend lodash when an `object` is given with an empty `options` object', function(assert) { + assert.expect(1); + + _.mixin({ 'a': noop }, {}); + assert.notOk('a' in _); + reset(_); + }); + + QUnit.test('should not error for non-object `options` values', function(assert) { + assert.expect(2); + + var pass = true; + + try { + _.mixin({}, source, 1); + } catch (e) { + pass = false; + } + assert.ok(pass); + + pass = true; + + try { + _.mixin(source, 1); + } catch (e) { + pass = false; + } + assert.ok(pass); + + reset(_); + }); + + QUnit.test('should not return the existing wrapped value when chaining', function(assert) { + assert.expect(2); + + lodashStable.each([_, Wrapper], function(func) { + if (!isNpm) { + if (func === _) { + var wrapped = _(source), + actual = wrapped.mixin(); + + assert.strictEqual(actual.value(), _); + } + else { + wrapped = _(func); + actual = wrapped.mixin(source); + assert.notStrictEqual(actual, wrapped); + } + reset(func); + } + else { + skipAssert(assert); + } + }); + }); + + QUnit.test('should produce methods that work in a lazy sequence', function(assert) { + assert.expect(1); + + if (!isNpm) { + _.mixin({ 'a': _.countBy, 'b': _.filter }); + + var array = lodashStable.range(LARGE_ARRAY_SIZE), + actual = _(array).a().map(square).b(isEven).take().value(); + + assert.deepEqual(actual, _.take(_.b(_.map(_.a(array), square), isEven))); + + reset(_); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.multiply'); + + (function() { + QUnit.test('should multiply two numbers', function(assert) { + assert.expect(3); + + assert.strictEqual(_.multiply(6, 4), 24); + assert.strictEqual(_.multiply(-6, 4), -24); + assert.strictEqual(_.multiply(-6, -4), 24); + }); + + QUnit.test('should coerce arguments to numbers', function(assert) { + assert.expect(2); + + assert.strictEqual(_.multiply('6', '4'), 24); + assert.deepEqual(_.multiply('x', 'y'), NaN); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.orderBy'); + + (function() { + var objects = [ + { 'a': 'x', 'b': 3 }, + { 'a': 'y', 'b': 4 }, + { 'a': 'x', 'b': 1 }, + { 'a': 'y', 'b': 2 } + ]; + + var nestedObj = [ + { id: '4', address: { zipCode: 4, streetName: 'Beta' } }, + { id: '3', address: { zipCode: 3, streetName: 'Alpha' } }, + { id: '1', address: { zipCode: 1, streetName: 'Alpha' } }, + { id: '2', address: { zipCode: 2, streetName: 'Alpha' } }, + { id: '5', address: { zipCode: 4, streetName: 'Alpha' } }, + ]; + + QUnit.test('should sort by a single property by a specified order', function(assert) { + assert.expect(1); + + var actual = _.orderBy(objects, 'a', 'desc'); + assert.deepEqual(actual, [objects[1], objects[3], objects[0], objects[2]]); + }); + + QUnit.test('should sort by nested key in array format', function(assert) { + assert.expect(1); + + var actual = _.orderBy( + nestedObj, + [['address', 'zipCode'], ['address.streetName']], + ['asc', 'desc'] + ); + assert.deepEqual(actual, [nestedObj[2], nestedObj[3], nestedObj[1], nestedObj[0], nestedObj[4]]); + }); + + QUnit.test('should sort by multiple properties by specified orders', function(assert) { + assert.expect(1); + + var actual = _.orderBy(objects, ['a', 'b'], ['desc', 'asc']); + assert.deepEqual(actual, [objects[3], objects[1], objects[2], objects[0]]); + }); + + QUnit.test('should sort by a property in ascending order when its order is not specified', function(assert) { + assert.expect(2); + + var expected = [objects[2], objects[0], objects[3], objects[1]], + actual = _.orderBy(objects, ['a', 'b']); + + assert.deepEqual(actual, expected); + + expected = lodashStable.map(falsey, lodashStable.constant([objects[3], objects[1], objects[2], objects[0]])); + + actual = lodashStable.map(falsey, function(order, index) { + return _.orderBy(objects, ['a', 'b'], index ? ['desc', order] : ['desc']); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should work with `orders` specified as string objects', function(assert) { + assert.expect(1); + + var actual = _.orderBy(objects, ['a'], [Object('desc')]); + assert.deepEqual(actual, [objects[1], objects[3], objects[0], objects[2]]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.overArgs'); + + (function() { + function fn() { + return slice.call(arguments); + } + + QUnit.test('should transform each argument', function(assert) { + assert.expect(1); + + var over = _.overArgs(fn, doubled, square); + assert.deepEqual(over(5, 10), [10, 100]); + }); + + QUnit.test('should use `_.identity` when a predicate is nullish', function(assert) { + assert.expect(1); + + var over = _.overArgs(fn, undefined, null); + assert.deepEqual(over('a', 'b'), ['a', 'b']); + }); + + QUnit.test('should work with `_.property` shorthands', function(assert) { + assert.expect(1); + + var over = _.overArgs(fn, 'b', 'a'); + assert.deepEqual(over({ 'b': 2 }, { 'a': 1 }), [2, 1]); + }); + + QUnit.test('should work with `_.matches` shorthands', function(assert) { + assert.expect(1); + + var over = _.overArgs(fn, { 'b': 1 }, { 'a': 1 }); + assert.deepEqual(over({ 'b': 2 }, { 'a': 1 }), [false, true]); + }); + + QUnit.test('should work with `_.matchesProperty` shorthands', function(assert) { + assert.expect(1); + + var over = _.overArgs(fn, [['b', 1], ['a', 1]]); + assert.deepEqual(over({ 'b': 2 }, { 'a': 1 }), [false, true]); + }); + + QUnit.test('should differentiate between `_.property` and `_.matchesProperty` shorthands', function(assert) { + assert.expect(2); + + var over = _.overArgs(fn, ['a', 1]); + assert.deepEqual(over({ 'a': 1 }, { '1': 2 }), [1, 2]); + + over = _.overArgs(fn, [['a', 1]]); + assert.deepEqual(over({ 'a': 1 }), [true]); + }); + + QUnit.test('should flatten `transforms`', function(assert) { + assert.expect(1); + + var over = _.overArgs(fn, [doubled, square], String); + assert.deepEqual(over(5, 10, 15), [10, 100, '15']); + }); + + QUnit.test('should not transform any argument greater than the number of transforms', function(assert) { + assert.expect(1); + + var over = _.overArgs(fn, doubled, square); + assert.deepEqual(over(5, 10, 18), [10, 100, 18]); + }); + + QUnit.test('should not transform any arguments if no transforms are given', function(assert) { + assert.expect(1); + + var over = _.overArgs(fn); + assert.deepEqual(over(5, 10, 18), [5, 10, 18]); + }); + + QUnit.test('should not pass `undefined` if there are more transforms than arguments', function(assert) { + assert.expect(1); + + var over = _.overArgs(fn, doubled, identity); + assert.deepEqual(over(5), [10]); + }); + + QUnit.test('should provide the correct argument to each transform', function(assert) { + assert.expect(1); + + var argsList = [], + transform = function() { argsList.push(slice.call(arguments)); }, + over = _.overArgs(noop, transform, transform, transform); + + over('a', 'b'); + assert.deepEqual(argsList, [['a'], ['b']]); + }); + + QUnit.test('should use `this` binding of function for `transforms`', function(assert) { + assert.expect(1); + + var over = _.overArgs(function(x) { + return this[x]; + }, function(x) { + return this === x; + }); + + var object = { 'over': over, 'true': 1 }; + assert.strictEqual(object.over(object), 1); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.negate'); + + (function() { + QUnit.test('should create a function that negates the result of `func`', function(assert) { + assert.expect(2); + + var negate = _.negate(isEven); + + assert.strictEqual(negate(1), true); + assert.strictEqual(negate(2), false); + }); + + QUnit.test('should create a function that negates the result of `func`', function(assert) { + assert.expect(2); + + var negate = _.negate(isEven); + + assert.strictEqual(negate(1), true); + assert.strictEqual(negate(2), false); + }); + + QUnit.test('should create a function that accepts multiple arguments', function(assert) { + assert.expect(1); + + var argCount, + count = 5, + negate = _.negate(function() { argCount = arguments.length; }), + expected = lodashStable.times(count, stubTrue); + + var actual = lodashStable.times(count, function(index) { + switch (index) { + case 0: negate(); break; + case 1: negate(1); break; + case 2: negate(1, 2); break; + case 3: negate(1, 2, 3); break; + case 4: negate(1, 2, 3, 4); + } + return argCount == index; + }); + + assert.deepEqual(actual, expected); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.noConflict'); + + (function() { + QUnit.test('should return the `lodash` function', function(assert) { + assert.expect(2); + + if (!isModularize) { + assert.strictEqual(_.noConflict(), oldDash); + assert.notStrictEqual(root._, oldDash); + root._ = oldDash; + } + else { + skipAssert(assert, 2); + } + }); + + QUnit.test('should restore `_` only if `lodash` is the current `_` value', function(assert) { + assert.expect(2); + + if (!isModularize) { + var object = root._ = {}; + assert.strictEqual(_.noConflict(), oldDash); + assert.strictEqual(root._, object); + root._ = oldDash; + } + else { + skipAssert(assert, 2); + } + }); + + QUnit.test('should work with a `root` of `this`', function(assert) { + assert.expect(2); + + if (!coverage && !document && !isModularize && realm.object) { + var fs = require('fs'), + vm = require('vm'), + expected = {}, + context = vm.createContext({ '_': expected, 'console': console }), + source = fs.readFileSync(filePath, 'utf8'); + + vm.runInContext(source + '\nthis.lodash = this._.noConflict()', context); + + assert.strictEqual(context._, expected); + assert.ok(context.lodash); + } + else { + skipAssert(assert, 2); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.now'); + + (function() { + QUnit.test('should return the number of milliseconds that have elapsed since the Unix epoch', function(assert) { + assert.expect(2); + + var done = assert.async(); + + var stamp = +new Date, + actual = _.now(); + + assert.ok(actual >= stamp); + + setTimeout(function() { + assert.ok(_.now() > actual); + done(); + }, 32); + }); + + QUnit.test('should work with mocked `Date.now`', function(assert) { + assert.expect(1); + + var now = Date.now; + Date.now = stubA; + + var actual = _.now(); + Date.now = now; + + assert.strictEqual(actual, 'a'); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.nth'); + + (function() { + var array = ['a', 'b', 'c', 'd']; + + QUnit.test('should get the nth element of `array`', function(assert) { + assert.expect(1); + + var actual = lodashStable.map(array, function(value, index) { + return _.nth(array, index); + }); + + assert.deepEqual(actual, array); + }); + + QUnit.test('should work with a negative `n`', function(assert) { + assert.expect(1); + + var actual = lodashStable.map(lodashStable.range(1, array.length + 1), function(n) { + return _.nth(array, -n); + }); + + assert.deepEqual(actual, ['d', 'c', 'b', 'a']); + }); + + QUnit.test('should coerce `n` to an integer', function(assert) { + assert.expect(2); + + var values = falsey, + expected = lodashStable.map(values, stubA); + + var actual = lodashStable.map(values, function(n) { + return n ? _.nth(array, n) : _.nth(array); + }); + + assert.deepEqual(actual, expected); + + values = ['1', 1.6]; + expected = lodashStable.map(values, stubB); + + actual = lodashStable.map(values, function(n) { + return _.nth(array, n); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should return `undefined` for empty arrays', function(assert) { + assert.expect(1); + + var values = [null, undefined, []], + expected = lodashStable.map(values, noop); + + var actual = lodashStable.map(values, function(array) { + return _.nth(array, 1); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should return `undefined` for non-indexes', function(assert) { + assert.expect(1); + + var array = [1, 2], + values = [Infinity, array.length], + expected = lodashStable.map(values, noop); + + array[-1] = 3; + + var actual = lodashStable.map(values, function(n) { + return _.nth(array, n); + }); + + assert.deepEqual(actual, expected); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.nthArg'); + + (function() { + var args = ['a', 'b', 'c', 'd']; + + QUnit.test('should create a function that returns its nth argument', function(assert) { + assert.expect(1); + + var actual = lodashStable.map(args, function(value, index) { + var func = _.nthArg(index); + return func.apply(undefined, args); + }); + + assert.deepEqual(actual, args); + }); + + QUnit.test('should work with a negative `n`', function(assert) { + assert.expect(1); + + var actual = lodashStable.map(lodashStable.range(1, args.length + 1), function(n) { + var func = _.nthArg(-n); + return func.apply(undefined, args); + }); + + assert.deepEqual(actual, ['d', 'c', 'b', 'a']); + }); + + QUnit.test('should coerce `n` to an integer', function(assert) { + assert.expect(2); + + var values = falsey, + expected = lodashStable.map(values, stubA); + + var actual = lodashStable.map(values, function(n) { + var func = n ? _.nthArg(n) : _.nthArg(); + return func.apply(undefined, args); + }); + + assert.deepEqual(actual, expected); + + values = ['1', 1.6]; + expected = lodashStable.map(values, stubB); + + actual = lodashStable.map(values, function(n) { + var func = _.nthArg(n); + return func.apply(undefined, args); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should return `undefined` for empty arrays', function(assert) { + assert.expect(1); + + var func = _.nthArg(1); + assert.strictEqual(func(), undefined); + }); + + QUnit.test('should return `undefined` for non-indexes', function(assert) { + assert.expect(1); + + var values = [Infinity, args.length], + expected = lodashStable.map(values, noop); + + var actual = lodashStable.map(values, function(n) { + var func = _.nthArg(n); + return func.apply(undefined, args); + }); + + assert.deepEqual(actual, expected); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.omit'); + + (function() { + var args = toArgs(['a', 'c']), + object = { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }, + nested = { 'a': 1, 'b': { 'c': 2, 'd': 3 } }; + + QUnit.test('should flatten `paths`', function(assert) { + assert.expect(2); + + assert.deepEqual(_.omit(object, 'a', 'c'), { 'b': 2, 'd': 4 }); + assert.deepEqual(_.omit(object, ['a', 'd'], 'c'), { 'b': 2 }); + }); + + QUnit.test('should support deep paths', function(assert) { + assert.expect(1); + + assert.deepEqual(_.omit(nested, 'b.c'), { 'a': 1, 'b': { 'd': 3} }); + }); + + QUnit.test('should support path arrays', function(assert) { + assert.expect(1); + + var object = { 'a.b': 1, 'a': { 'b': 2 } }, + actual = _.omit(object, [['a.b']]); + + assert.deepEqual(actual, { 'a': { 'b': 2 } }); + }); + + QUnit.test('should omit a key over a path', function(assert) { + assert.expect(2); + + var object = { 'a.b': 1, 'a': { 'b': 2 } }; + + lodashStable.each(['a.b', ['a.b']], function(path) { + assert.deepEqual(_.omit(object, path), { 'a': { 'b': 2 } }); + }); + }); + + QUnit.test('should coerce `paths` to strings', function(assert) { + assert.expect(1); + + assert.deepEqual(_.omit({ '0': 'a' }, 0), {}); + }); + + QUnit.test('should return an empty object when `object` is nullish', function(assert) { + assert.expect(2); + + lodashStable.each([null, undefined], function(value) { + objectProto.a = 1; + var actual = _.omit(value, 'valueOf'); + delete objectProto.a; + assert.deepEqual(actual, {}); + }); + }); + + QUnit.test('should work with a primitive `object`', function(assert) { + assert.expect(1); + + stringProto.a = 1; + stringProto.b = 2; + + assert.deepEqual(_.omit('', 'b'), { 'a': 1 }); + + delete stringProto.a; + delete stringProto.b; + }); + + QUnit.test('should work with `arguments` object `paths`', function(assert) { + assert.expect(1); + + assert.deepEqual(_.omit(object, args), { 'b': 2, 'd': 4 }); + }); + + QUnit.test('should not mutate `object`', function(assert) { + assert.expect(4); + + lodashStable.each(['a', ['a'], 'a.b', ['a.b']], function(path) { + var object = { 'a': { 'b': 2 } }; + _.omit(object, path); + assert.deepEqual(object, { 'a': { 'b': 2 } }); + }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.omitBy'); + + (function() { + QUnit.test('should work with a predicate argument', function(assert) { + assert.expect(1); + + var object = { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }; + + var actual = _.omitBy(object, function(n) { + return n != 2 && n != 4; + }); + + assert.deepEqual(actual, { 'b': 2, 'd': 4 }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('omit methods'); + + lodashStable.each(['omit', 'omitBy'], function(methodName) { + var expected = { 'b': 2, 'd': 4 }, + func = _[methodName], + object = { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }, + resolve = lodashStable.nthArg(1); + + if (methodName == 'omitBy') { + resolve = function(object, props) { + props = lodashStable.castArray(props); + return function(value) { + return lodashStable.some(props, function(key) { + key = lodashStable.isSymbol(key) ? key : lodashStable.toString(key); + return object[key] === value; + }); + }; + }; + } + QUnit.test('`_.' + methodName + '` should create an object with omitted string keyed properties', function(assert) { + assert.expect(2); + + assert.deepEqual(func(object, resolve(object, 'a')), { 'b': 2, 'c': 3, 'd': 4 }); + assert.deepEqual(func(object, resolve(object, ['a', 'c'])), expected); + }); + + QUnit.test('`_.' + methodName + '` should include inherited string keyed properties', function(assert) { + assert.expect(1); + + function Foo() {} + Foo.prototype = object; + + assert.deepEqual(func(new Foo, resolve(object, ['a', 'c'])), expected); + }); + + QUnit.test('`_.' + methodName + '` should preserve the sign of `0`', function(assert) { + assert.expect(1); + + var object = { '-0': 'a', '0': 'b' }, + props = [-0, Object(-0), 0, Object(0)], + expected = [{ '0': 'b' }, { '0': 'b' }, { '-0': 'a' }, { '-0': 'a' }]; + + var actual = lodashStable.map(props, function(key) { + return func(object, resolve(object, key)); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should include symbols', function(assert) { + assert.expect(3); + + function Foo() { + this.a = 0; + this[symbol] = 1; + } + + if (Symbol) { + var symbol2 = Symbol('b'); + Foo.prototype[symbol2] = 2; + + var symbol3 = Symbol('c'); + defineProperty(Foo.prototype, symbol3, { + 'configurable': true, + 'enumerable': false, + 'writable': true, + 'value': 3 + }); + + var foo = new Foo, + actual = func(foo, resolve(foo, 'a')); + + assert.strictEqual(actual[symbol], 1); + assert.strictEqual(actual[symbol2], 2); + assert.notOk(symbol3 in actual); + } + else { + skipAssert(assert, 3); + } + }); + + QUnit.test('`_.' + methodName + '` should create an object with omitted symbols', function(assert) { + assert.expect(8); + + function Foo() { + this.a = 0; + this[symbol] = 1; + } + + if (Symbol) { + var symbol2 = Symbol('b'); + Foo.prototype[symbol2] = 2; + + var symbol3 = Symbol('c'); + defineProperty(Foo.prototype, symbol3, { + 'configurable': true, + 'enumerable': false, + 'writable': true, + 'value': 3 + }); + + var foo = new Foo, + actual = func(foo, resolve(foo, symbol)); + + assert.strictEqual(actual.a, 0); + assert.notOk(symbol in actual); + assert.strictEqual(actual[symbol2], 2); + assert.notOk(symbol3 in actual); + + actual = func(foo, resolve(foo, symbol2)); + + assert.strictEqual(actual.a, 0); + assert.strictEqual(actual[symbol], 1); + assert.notOk(symbol2 in actual); + assert.notOk(symbol3 in actual); + } + else { + skipAssert(assert, 8); + } + }); + + QUnit.test('`_.' + methodName + '` should work with an array `object`', function(assert) { + assert.expect(1); + + var array = [1, 2, 3]; + assert.deepEqual(func(array, resolve(array, ['0', '2'])), { '1': 2 }); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.once'); + + (function() { + QUnit.test('should invoke `func` once', function(assert) { + assert.expect(2); + + var count = 0, + once = _.once(function() { return ++count; }); + + once(); + assert.strictEqual(once(), 1); + assert.strictEqual(count, 1); + }); + + QUnit.test('should ignore recursive calls', function(assert) { + assert.expect(2); + + var count = 0; + + var once = _.once(function() { + once(); + return ++count; + }); + + assert.strictEqual(once(), 1); + assert.strictEqual(count, 1); + }); + + QUnit.test('should not throw more than once', function(assert) { + assert.expect(2); + + var once = _.once(function() { + throw new Error; + }); + + assert.raises(once); + + once(); + assert.ok(true); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.over'); + + (function() { + QUnit.test('should create a function that invokes `iteratees`', function(assert) { + assert.expect(1); + + var over = _.over(Math.max, Math.min); + assert.deepEqual(over(1, 2, 3, 4), [4, 1]); + }); + + QUnit.test('should use `_.identity` when a predicate is nullish', function(assert) { + assert.expect(1); + + var over = _.over(undefined, null); + assert.deepEqual(over('a', 'b', 'c'), ['a', 'a']); + }); + + QUnit.test('should work with `_.property` shorthands', function(assert) { + assert.expect(1); + + var over = _.over('b', 'a'); + assert.deepEqual(over({ 'a': 1, 'b': 2 }), [2, 1]); + }); + + QUnit.test('should work with `_.matches` shorthands', function(assert) { + assert.expect(1); + + var over = _.over({ 'b': 1 }, { 'a': 1 }); + assert.deepEqual(over({ 'a': 1, 'b': 2 }), [false, true]); + }); + + QUnit.test('should work with `_.matchesProperty` shorthands', function(assert) { + assert.expect(2); + + var over = _.over([['b', 2], ['a', 2]]); + + assert.deepEqual(over({ 'a': 1, 'b': 2 }), [true, false]); + assert.deepEqual(over({ 'a': 2, 'b': 1 }), [false, true]); + }); + + QUnit.test('should differentiate between `_.property` and `_.matchesProperty` shorthands', function(assert) { + assert.expect(4); + + var over = _.over(['a', 1]); + + assert.deepEqual(over({ 'a': 1, '1': 2 }), [1, 2]); + assert.deepEqual(over({ 'a': 2, '1': 1 }), [2, 1]); + + over = _.over([['a', 1]]); + + assert.deepEqual(over({ 'a': 1 }), [true]); + assert.deepEqual(over({ 'a': 2 }), [false]); + }); + + QUnit.test('should provide arguments to predicates', function(assert) { + assert.expect(1); + + var over = _.over(function() { + return slice.call(arguments); + }); + + assert.deepEqual(over('a', 'b', 'c'), [['a', 'b', 'c']]); + }); + + QUnit.test('should use `this` binding of function for `iteratees`', function(assert) { + assert.expect(1); + + var over = _.over(function() { return this.b; }, function() { return this.a; }), + object = { 'over': over, 'a': 1, 'b': 2 }; + + assert.deepEqual(object.over(), [2, 1]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.overEvery'); + + (function() { + QUnit.test('should create a function that returns `true` if all predicates return truthy', function(assert) { + assert.expect(1); + + var over = _.overEvery(stubTrue, stubOne, stubA); + assert.strictEqual(over(), true); + }); + + QUnit.test('should return `false` as soon as a predicate returns falsey', function(assert) { + assert.expect(2); + + var count = 0, + countFalse = function() { count++; return false; }, + countTrue = function() { count++; return true; }, + over = _.overEvery(countTrue, countFalse, countTrue); + + assert.strictEqual(over(), false); + assert.strictEqual(count, 2); + }); + + QUnit.test('should use `_.identity` when a predicate is nullish', function(assert) { + assert.expect(2); + + var over = _.overEvery(undefined, null); + + assert.strictEqual(over(true), true); + assert.strictEqual(over(false), false); + }); + + QUnit.test('should work with `_.property` shorthands', function(assert) { + assert.expect(2); + + var over = _.overEvery('b', 'a'); + + assert.strictEqual(over({ 'a': 1, 'b': 1 }), true); + assert.strictEqual(over({ 'a': 0, 'b': 1 }), false); + }); + + QUnit.test('should work with `_.matches` shorthands', function(assert) { + assert.expect(2); + + var over = _.overEvery({ 'b': 2 }, { 'a': 1 }); + + assert.strictEqual(over({ 'a': 1, 'b': 2 }), true); + assert.strictEqual(over({ 'a': 0, 'b': 2 }), false); + }); + + QUnit.test('should work with `_.matchesProperty` shorthands', function(assert) { + assert.expect(2); + + var over = _.overEvery([['b', 2], ['a', 1]]); + + assert.strictEqual(over({ 'a': 1, 'b': 2 }), true); + assert.strictEqual(over({ 'a': 0, 'b': 2 }), false); + }); + + QUnit.test('should differentiate between `_.property` and `_.matchesProperty` shorthands', function(assert) { + assert.expect(5); + + var over = _.overEvery(['a', 1]); + + assert.strictEqual(over({ 'a': 1, '1': 1 }), true); + assert.strictEqual(over({ 'a': 1, '1': 0 }), false); + assert.strictEqual(over({ 'a': 0, '1': 1 }), false); + + over = _.overEvery([['a', 1]]); + + assert.strictEqual(over({ 'a': 1 }), true); + assert.strictEqual(over({ 'a': 2 }), false); + }); + + QUnit.test('should flatten `predicates`', function(assert) { + assert.expect(1); + + var over = _.overEvery(stubTrue, [stubFalse]); + assert.strictEqual(over(), false); + }); + + QUnit.test('should provide arguments to predicates', function(assert) { + assert.expect(1); + + var args; + + var over = _.overEvery(function() { + args = slice.call(arguments); + }); + + over('a', 'b', 'c'); + assert.deepEqual(args, ['a', 'b', 'c']); + }); + + QUnit.test('should use `this` binding of function for `predicates`', function(assert) { + assert.expect(2); + + var over = _.overEvery(function() { return this.b; }, function() { return this.a; }), + object = { 'over': over, 'a': 1, 'b': 2 }; + + assert.strictEqual(object.over(), true); + + object.a = 0; + assert.strictEqual(object.over(), false); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.overSome'); + + (function() { + QUnit.test('should create a function that returns `true` if any predicates return truthy', function(assert) { + assert.expect(2); + + var over = _.overSome(stubFalse, stubOne, stubString); + assert.strictEqual(over(), true); + + over = _.overSome(stubNull, stubA, stubZero); + assert.strictEqual(over(), true); + }); + + QUnit.test('should return `true` as soon as `predicate` returns truthy', function(assert) { + assert.expect(2); + + var count = 0, + countFalse = function() { count++; return false; }, + countTrue = function() { count++; return true; }, + over = _.overSome(countFalse, countTrue, countFalse); + + assert.strictEqual(over(), true); + assert.strictEqual(count, 2); + }); + + QUnit.test('should return `false` if all predicates return falsey', function(assert) { + assert.expect(2); + + var over = _.overSome(stubFalse, stubFalse, stubFalse); + assert.strictEqual(over(), false); + + over = _.overSome(stubNull, stubZero, stubString); + assert.strictEqual(over(), false); + }); + + QUnit.test('should use `_.identity` when a predicate is nullish', function(assert) { + assert.expect(2); + + var over = _.overSome(undefined, null); + + assert.strictEqual(over(true), true); + assert.strictEqual(over(false), false); + }); + + QUnit.test('should work with `_.property` shorthands', function(assert) { + assert.expect(2); + + var over = _.overSome('b', 'a'); + + assert.strictEqual(over({ 'a': 1, 'b': 0 }), true); + assert.strictEqual(over({ 'a': 0, 'b': 0 }), false); + }); + + QUnit.test('should work with `_.matches` shorthands', function(assert) { + assert.expect(2); + + var over = _.overSome({ 'b': 2 }, { 'a': 1 }); + + assert.strictEqual(over({ 'a': 0, 'b': 2 }), true); + assert.strictEqual(over({ 'a': 0, 'b': 0 }), false); + }); + + QUnit.test('should work with `_.matchesProperty` shorthands', function(assert) { + assert.expect(2); + + var over = _.overSome([['b', 2], ['a', 1]]); + + assert.strictEqual(over({ 'a': 0, 'b': 2 }), true); + assert.strictEqual(over({ 'a': 0, 'b': 0 }), false); + }); + + QUnit.test('should differentiate between `_.property` and `_.matchesProperty` shorthands', function(assert) { + assert.expect(5); + + var over = _.overSome(['a', 1]); + + assert.strictEqual(over({ 'a': 0, '1': 0 }), false); + assert.strictEqual(over({ 'a': 1, '1': 0 }), true); + assert.strictEqual(over({ 'a': 0, '1': 1 }), true); + + over = _.overSome([['a', 1]]); + + assert.strictEqual(over({ 'a': 1 }), true); + assert.strictEqual(over({ 'a': 2 }), false); + }); + + QUnit.test('should flatten `predicates`', function(assert) { + assert.expect(1); + + var over = _.overSome(stubFalse, [stubTrue]); + assert.strictEqual(over(), true); + }); + + QUnit.test('should provide arguments to predicates', function(assert) { + assert.expect(1); + + var args; + + var over = _.overSome(function() { + args = slice.call(arguments); + }); + + over('a', 'b', 'c'); + assert.deepEqual(args, ['a', 'b', 'c']); + }); + + QUnit.test('should use `this` binding of function for `predicates`', function(assert) { + assert.expect(2); + + var over = _.overSome(function() { return this.b; }, function() { return this.a; }), + object = { 'over': over, 'a': 1, 'b': 2 }; + + assert.strictEqual(object.over(), true); + + object.a = object.b = 0; + assert.strictEqual(object.over(), false); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.pad'); + + (function() { + var string = 'abc'; + + QUnit.test('should pad a string to a given length', function(assert) { + assert.expect(1); + + var values = [, undefined], + expected = lodashStable.map(values, lodashStable.constant(' abc ')); + + var actual = lodashStable.map(values, function(value, index) { + return index ? _.pad(string, 6, value) : _.pad(string, 6); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should truncate pad characters to fit the pad length', function(assert) { + assert.expect(2); + + assert.strictEqual(_.pad(string, 8), ' abc '); + assert.strictEqual(_.pad(string, 8, '_-'), '_-abc_-_'); + }); + + QUnit.test('should coerce `string` to a string', function(assert) { + assert.expect(1); + + var values = [Object(string), { 'toString': lodashStable.constant(string) }], + expected = lodashStable.map(values, stubTrue); + + var actual = lodashStable.map(values, function(value) { + return _.pad(value, 6) === ' abc '; + }); + + assert.deepEqual(actual, expected); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.padEnd'); + + (function() { + var string = 'abc'; + + QUnit.test('should pad a string to a given length', function(assert) { + assert.expect(1); + + var values = [, undefined], + expected = lodashStable.map(values, lodashStable.constant('abc ')); + + var actual = lodashStable.map(values, function(value, index) { + return index ? _.padEnd(string, 6, value) : _.padEnd(string, 6); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should truncate pad characters to fit the pad length', function(assert) { + assert.expect(1); + + assert.strictEqual(_.padEnd(string, 6, '_-'), 'abc_-_'); + }); + + QUnit.test('should coerce `string` to a string', function(assert) { + assert.expect(1); + + var values = [Object(string), { 'toString': lodashStable.constant(string) }], + expected = lodashStable.map(values, stubTrue); + + var actual = lodashStable.map(values, function(value) { + return _.padEnd(value, 6) === 'abc '; + }); + + assert.deepEqual(actual, expected); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.padStart'); + + (function() { + var string = 'abc'; + + QUnit.test('should pad a string to a given length', function(assert) { + assert.expect(1); + + var values = [, undefined], + expected = lodashStable.map(values, lodashStable.constant(' abc')); + + var actual = lodashStable.map(values, function(value, index) { + return index ? _.padStart(string, 6, value) : _.padStart(string, 6); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should truncate pad characters to fit the pad length', function(assert) { + assert.expect(1); + + assert.strictEqual(_.padStart(string, 6, '_-'), '_-_abc'); + }); + + QUnit.test('should coerce `string` to a string', function(assert) { + assert.expect(1); + + var values = [Object(string), { 'toString': lodashStable.constant(string) }], + expected = lodashStable.map(values, stubTrue); + + var actual = lodashStable.map(values, function(value) { + return _.padStart(value, 6) === ' abc'; + }); + + assert.deepEqual(actual, expected); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('pad methods'); + + lodashStable.each(['pad', 'padStart', 'padEnd'], function(methodName) { + var func = _[methodName], + isPad = methodName == 'pad', + isStart = methodName == 'padStart', + string = 'abc'; + + QUnit.test('`_.' + methodName + '` should not pad if string is >= `length`', function(assert) { + assert.expect(2); + + assert.strictEqual(func(string, 2), string); + assert.strictEqual(func(string, 3), string); + }); + + QUnit.test('`_.' + methodName + '` should treat negative `length` as `0`', function(assert) { + assert.expect(2); + + lodashStable.each([0, -2], function(length) { + assert.strictEqual(func(string, length), string); + }); + }); + + QUnit.test('`_.' + methodName + '` should coerce `length` to a number', function(assert) { + assert.expect(2); + + lodashStable.each(['', '4'], function(length) { + var actual = length ? (isStart ? ' abc' : 'abc ') : string; + assert.strictEqual(func(string, length), actual); + }); + }); + + QUnit.test('`_.' + methodName + '` should treat nullish values as empty strings', function(assert) { + assert.expect(6); + + lodashStable.each([undefined, '_-'], function(chars) { + var expected = chars ? (isPad ? '__' : chars) : ' '; + assert.strictEqual(func(null, 2, chars), expected); + assert.strictEqual(func(undefined, 2, chars), expected); + assert.strictEqual(func('', 2, chars), expected); + }); + }); + + QUnit.test('`_.' + methodName + '` should return `string` when `chars` coerces to an empty string', function(assert) { + assert.expect(1); + + var values = ['', Object('')], + expected = lodashStable.map(values, lodashStable.constant(string)); + + var actual = lodashStable.map(values, function(value) { + return _.pad(string, 6, value); + }); + + assert.deepEqual(actual, expected); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.parseInt'); + + (function() { + QUnit.test('should accept a `radix`', function(assert) { + assert.expect(1); + + var expected = lodashStable.range(2, 37); + + var actual = lodashStable.map(expected, function(radix) { + return _.parseInt('10', radix); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should use a radix of `10`, for non-hexadecimals, if `radix` is `undefined` or `0`', function(assert) { + assert.expect(4); + + assert.strictEqual(_.parseInt('10'), 10); + assert.strictEqual(_.parseInt('10', 0), 10); + assert.strictEqual(_.parseInt('10', 10), 10); + assert.strictEqual(_.parseInt('10', undefined), 10); + }); + + QUnit.test('should use a radix of `16`, for hexadecimals, if `radix` is `undefined` or `0`', function(assert) { + assert.expect(8); + + lodashStable.each(['0x20', '0X20'], function(string) { + assert.strictEqual(_.parseInt(string), 32); + assert.strictEqual(_.parseInt(string, 0), 32); + assert.strictEqual(_.parseInt(string, 16), 32); + assert.strictEqual(_.parseInt(string, undefined), 32); + }); + }); + + QUnit.test('should use a radix of `10` for string with leading zeros', function(assert) { + assert.expect(2); + + assert.strictEqual(_.parseInt('08'), 8); + assert.strictEqual(_.parseInt('08', 10), 8); + }); + + QUnit.test('should parse strings with leading whitespace', function(assert) { + assert.expect(2); + + var expected = [8, 8, 10, 10, 32, 32, 32, 32]; + + lodashStable.times(2, function(index) { + var actual = [], + func = (index ? (lodashBizarro || {}) : _).parseInt; + + if (func) { + lodashStable.times(2, function(otherIndex) { + var string = otherIndex ? '10' : '08'; + actual.push( + func(whitespace + string, 10), + func(whitespace + string) + ); + }); + + lodashStable.each(['0x20', '0X20'], function(string) { + actual.push( + func(whitespace + string), + func(whitespace + string, 16) + ); + }); + + assert.deepEqual(actual, expected); + } + else { + skipAssert(assert); + } + }); + }); + + QUnit.test('should coerce `radix` to a number', function(assert) { + assert.expect(2); + + var object = { 'valueOf': stubZero }; + assert.strictEqual(_.parseInt('08', object), 8); + assert.strictEqual(_.parseInt('0x20', object), 32); + }); + + QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) { + assert.expect(2); + + var strings = lodashStable.map(['6', '08', '10'], Object), + actual = lodashStable.map(strings, _.parseInt); + + assert.deepEqual(actual, [6, 8, 10]); + + actual = lodashStable.map('123', _.parseInt); + assert.deepEqual(actual, [1, 2, 3]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('partial methods'); + + lodashStable.each(['partial', 'partialRight'], function(methodName) { + var func = _[methodName], + isPartial = methodName == 'partial', + ph = func.placeholder; + + QUnit.test('`_.' + methodName + '` partially applies arguments', function(assert) { + assert.expect(1); + + var par = func(identity, 'a'); + assert.strictEqual(par(), 'a'); + }); + + QUnit.test('`_.' + methodName + '` creates a function that can be invoked with additional arguments', function(assert) { + assert.expect(1); + + var fn = function(a, b) { return [a, b]; }, + par = func(fn, 'a'), + expected = isPartial ? ['a', 'b'] : ['b', 'a']; + + assert.deepEqual(par('b'), expected); + }); + + QUnit.test('`_.' + methodName + '` works when there are no partially applied arguments and the created function is invoked without additional arguments', function(assert) { + assert.expect(1); + + var fn = function() { return arguments.length; }, + par = func(fn); + + assert.strictEqual(par(), 0); + }); + + QUnit.test('`_.' + methodName + '` works when there are no partially applied arguments and the created function is invoked with additional arguments', function(assert) { + assert.expect(1); + + var par = func(identity); + assert.strictEqual(par('a'), 'a'); + }); + + QUnit.test('`_.' + methodName + '` should support placeholders', function(assert) { + assert.expect(4); + + var fn = function() { return slice.call(arguments); }, + par = func(fn, ph, 'b', ph); + + assert.deepEqual(par('a', 'c'), ['a', 'b', 'c']); + assert.deepEqual(par('a'), ['a', 'b', undefined]); + assert.deepEqual(par(), [undefined, 'b', undefined]); + + if (isPartial) { + assert.deepEqual(par('a', 'c', 'd'), ['a', 'b', 'c', 'd']); + } else { + par = func(fn, ph, 'c', ph); + assert.deepEqual(par('a', 'b', 'd'), ['a', 'b', 'c', 'd']); + } + }); + + QUnit.test('`_.' + methodName + '` should use `_.placeholder` when set', function(assert) { + assert.expect(1); + + if (!isModularize) { + var _ph = _.placeholder = {}, + fn = function() { return slice.call(arguments); }, + par = func(fn, _ph, 'b', ph), + expected = isPartial ? ['a', 'b', ph, 'c'] : ['a', 'c', 'b', ph]; + + assert.deepEqual(par('a', 'c'), expected); + delete _.placeholder; + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.' + methodName + '` creates a function with a `length` of `0`', function(assert) { + assert.expect(1); + + var fn = function(a, b, c) {}, + par = func(fn, 'a'); + + assert.strictEqual(par.length, 0); + }); + + QUnit.test('`_.' + methodName + '` should ensure `new par` is an instance of `func`', function(assert) { + assert.expect(2); + + function Foo(value) { + return value && object; + } + + var object = {}, + par = func(Foo); + + assert.ok(new par instanceof Foo); + assert.strictEqual(new par(true), object); + }); + + QUnit.test('`_.' + methodName + '` should clone metadata for created functions', function(assert) { + assert.expect(3); + + function greet(greeting, name) { + return greeting + ' ' + name; + } + + var par1 = func(greet, 'hi'), + par2 = func(par1, 'barney'), + par3 = func(par1, 'pebbles'); + + assert.strictEqual(par1('fred'), isPartial ? 'hi fred' : 'fred hi'); + assert.strictEqual(par2(), isPartial ? 'hi barney' : 'barney hi'); + assert.strictEqual(par3(), isPartial ? 'hi pebbles' : 'pebbles hi'); + }); + + QUnit.test('`_.' + methodName + '` should work with curried functions', function(assert) { + assert.expect(2); + + var fn = function(a, b, c) { return a + b + c; }, + curried = _.curry(func(fn, 1), 2); + + assert.strictEqual(curried(2, 3), 6); + assert.strictEqual(curried(2)(3), 6); + }); + + QUnit.test('should work with placeholders and curried functions', function(assert) { + assert.expect(1); + + var fn = function() { return slice.call(arguments); }, + curried = _.curry(fn), + par = func(curried, ph, 'b', ph, 'd'); + + assert.deepEqual(par('a', 'c'), ['a', 'b', 'c', 'd']); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.partialRight'); + + (function() { + QUnit.test('should work as a deep `_.defaults`', function(assert) { + assert.expect(1); + + var object = { 'a': { 'b': 2 } }, + source = { 'a': { 'b': 3, 'c': 3 } }, + expected = { 'a': { 'b': 2, 'c': 3 } }; + + var defaultsDeep = _.partialRight(_.mergeWith, function deep(value, other) { + return lodashStable.isObject(value) ? _.mergeWith(value, other, deep) : value; + }); + + assert.deepEqual(defaultsDeep(object, source), expected); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('methods using `createWrapper`'); + + (function() { + function fn() { + return slice.call(arguments); + } + + var ph1 = _.bind.placeholder, + ph2 = _.bindKey.placeholder, + ph3 = _.partial.placeholder, + ph4 = _.partialRight.placeholder; + + QUnit.test('should work with combinations of partial functions', function(assert) { + assert.expect(1); + + var a = _.partial(fn), + b = _.partialRight(a, 3), + c = _.partial(b, 1); + + assert.deepEqual(c(2), [1, 2, 3]); + }); + + QUnit.test('should work with combinations of bound and partial functions', function(assert) { + assert.expect(3); + + var fn = function() { + var result = [this.a]; + push.apply(result, arguments); + return result; + }; + + var expected = [1, 2, 3, 4], + object = { 'a': 1, 'fn': fn }; + + var a = _.bindKey(object, 'fn'), + b = _.partialRight(a, 4), + c = _.partial(b, 2); + + assert.deepEqual(c(3), expected); + + a = _.bind(fn, object); + b = _.partialRight(a, 4); + c = _.partial(b, 2); + + assert.deepEqual(c(3), expected); + + a = _.partial(fn, 2); + b = _.bind(a, object); + c = _.partialRight(b, 4); + + assert.deepEqual(c(3), expected); + }); + + QUnit.test('should ensure `new combo` is an instance of `func`', function(assert) { + assert.expect(2); + + function Foo(a, b, c) { + return b === 0 && object; + } + + var combo = _.partial(_.partialRight(Foo, 3), 1), + object = {}; + + assert.ok(new combo(2) instanceof Foo); + assert.strictEqual(new combo(0), object); + }); + + QUnit.test('should work with combinations of functions with placeholders', function(assert) { + assert.expect(3); + + var expected = [1, 2, 3, 4, 5, 6], + object = { 'fn': fn }; + + var a = _.bindKey(object, 'fn', ph2, 2), + b = _.partialRight(a, ph4, 6), + c = _.partial(b, 1, ph3, 4); + + assert.deepEqual(c(3, 5), expected); + + a = _.bind(fn, object, ph1, 2); + b = _.partialRight(a, ph4, 6); + c = _.partial(b, 1, ph3, 4); + + assert.deepEqual(c(3, 5), expected); + + a = _.partial(fn, ph3, 2); + b = _.bind(a, object, 1, ph1, 4); + c = _.partialRight(b, ph4, 6); + + assert.deepEqual(c(3, 5), expected); + }); + + QUnit.test('should work with combinations of functions with overlapping placeholders', function(assert) { + assert.expect(3); + + var expected = [1, 2, 3, 4], + object = { 'fn': fn }; + + var a = _.bindKey(object, 'fn', ph2, 2), + b = _.partialRight(a, ph4, 4), + c = _.partial(b, ph3, 3); + + assert.deepEqual(c(1), expected); + + a = _.bind(fn, object, ph1, 2); + b = _.partialRight(a, ph4, 4); + c = _.partial(b, ph3, 3); + + assert.deepEqual(c(1), expected); + + a = _.partial(fn, ph3, 2); + b = _.bind(a, object, ph1, 3); + c = _.partialRight(b, ph4, 4); + + assert.deepEqual(c(1), expected); + }); + + QUnit.test('should work with recursively bound functions', function(assert) { + assert.expect(1); + + var fn = function() { + return this.a; + }; + + var a = _.bind(fn, { 'a': 1 }), + b = _.bind(a, { 'a': 2 }), + c = _.bind(b, { 'a': 3 }); + + assert.strictEqual(c(), 1); + }); + + QUnit.test('should work when hot', function(assert) { + assert.expect(12); + + lodashStable.times(2, function(index) { + var fn = function() { + var result = [this]; + push.apply(result, arguments); + return result; + }; + + var object = {}, + bound1 = index ? _.bind(fn, object, 1) : _.bind(fn, object), + expected = [object, 1, 2, 3]; + + var actual = _.last(lodashStable.times(HOT_COUNT, function() { + var bound2 = index ? _.bind(bound1, null, 2) : _.bind(bound1); + return index ? bound2(3) : bound2(1, 2, 3); + })); + + assert.deepEqual(actual, expected); + + actual = _.last(lodashStable.times(HOT_COUNT, function() { + var bound1 = index ? _.bind(fn, object, 1) : _.bind(fn, object), + bound2 = index ? _.bind(bound1, null, 2) : _.bind(bound1); + + return index ? bound2(3) : bound2(1, 2, 3); + })); + + assert.deepEqual(actual, expected); + }); + + lodashStable.each(['curry', 'curryRight'], function(methodName, index) { + var fn = function(a, b, c) { return [a, b, c]; }, + curried = _[methodName](fn), + expected = index ? [3, 2, 1] : [1, 2, 3]; + + var actual = _.last(lodashStable.times(HOT_COUNT, function() { + return curried(1)(2)(3); + })); + + assert.deepEqual(actual, expected); + + actual = _.last(lodashStable.times(HOT_COUNT, function() { + var curried = _[methodName](fn); + return curried(1)(2)(3); + })); + + assert.deepEqual(actual, expected); + }); + + lodashStable.each(['partial', 'partialRight'], function(methodName, index) { + var func = _[methodName], + fn = function() { return slice.call(arguments); }, + par1 = func(fn, 1), + expected = index ? [3, 2, 1] : [1, 2, 3]; + + var actual = _.last(lodashStable.times(HOT_COUNT, function() { + var par2 = func(par1, 2); + return par2(3); + })); + + assert.deepEqual(actual, expected); + + actual = _.last(lodashStable.times(HOT_COUNT, function() { + var par1 = func(fn, 1), + par2 = func(par1, 2); + + return par2(3); + })); + + assert.deepEqual(actual, expected); + }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.partition'); + + (function() { + var array = [1, 0, 1]; + + QUnit.test('should split elements into two groups by `predicate`', function(assert) { + assert.expect(3); + + assert.deepEqual(_.partition([], identity), [[], []]); + assert.deepEqual(_.partition(array, stubTrue), [array, []]); + assert.deepEqual(_.partition(array, stubFalse), [[], array]); + }); + + QUnit.test('should use `_.identity` when `predicate` is nullish', function(assert) { + assert.expect(1); + + var values = [, null, undefined], + expected = lodashStable.map(values, lodashStable.constant([[1, 1], [0]])); + + var actual = lodashStable.map(values, function(value, index) { + return index ? _.partition(array, value) : _.partition(array); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should work with `_.property` shorthands', function(assert) { + assert.expect(1); + + var objects = [{ 'a': 1 }, { 'a': 1 }, { 'b': 2 }], + actual = _.partition(objects, 'a'); + + assert.deepEqual(actual, [objects.slice(0, 2), objects.slice(2)]); + }); + + QUnit.test('should work with a number for `predicate`', function(assert) { + assert.expect(2); + + var array = [ + [1, 0], + [0, 1], + [1, 0] + ]; + + assert.deepEqual(_.partition(array, 0), [[array[0], array[2]], [array[1]]]); + assert.deepEqual(_.partition(array, 1), [[array[1]], [array[0], array[2]]]); + }); + + QUnit.test('should work with an object for `collection`', function(assert) { + assert.expect(1); + + var actual = _.partition({ 'a': 1.1, 'b': 0.2, 'c': 1.3 }, Math.floor); + assert.deepEqual(actual, [[1.1, 1.3], [0.2]]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.pick'); + + (function() { + var args = toArgs(['a', 'c']), + object = { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }, + nested = { 'a': 1, 'b': { 'c': 2, 'd': 3 } }; + + QUnit.test('should flatten `paths`', function(assert) { + assert.expect(2); + + assert.deepEqual(_.pick(object, 'a', 'c'), { 'a': 1, 'c': 3 }); + assert.deepEqual(_.pick(object, ['a', 'd'], 'c'), { 'a': 1, 'c': 3, 'd': 4 }); + }); + + QUnit.test('should support deep paths', function(assert) { + assert.expect(1); + + assert.deepEqual(_.pick(nested, 'b.c'), { 'b': { 'c': 2 } }); + }); + + QUnit.test('should support path arrays', function(assert) { + assert.expect(1); + + var object = { 'a.b': 1, 'a': { 'b': 2 } }, + actual = _.pick(object, [['a.b']]); + + assert.deepEqual(actual, { 'a.b': 1 }); + }); + + QUnit.test('should pick a key over a path', function(assert) { + assert.expect(2); + + var object = { 'a.b': 1, 'a': { 'b': 2 } }; + + lodashStable.each(['a.b', ['a.b']], function(path) { + assert.deepEqual(_.pick(object, path), { 'a.b': 1 }); + }); + }); + + QUnit.test('should coerce `paths` to strings', function(assert) { + assert.expect(1); + + assert.deepEqual(_.pick({ '0': 'a', '1': 'b' }, 0), { '0': 'a' }); + }); + + QUnit.test('should return an empty object when `object` is nullish', function(assert) { + assert.expect(2); + + lodashStable.each([null, undefined], function(value) { + assert.deepEqual(_.pick(value, 'valueOf'), {}); + }); + }); + + QUnit.test('should work with a primitive `object`', function(assert) { + assert.expect(1); + + assert.deepEqual(_.pick('', 'slice'), { 'slice': ''.slice }); + }); + + QUnit.test('should work with `arguments` object `paths`', function(assert) { + assert.expect(1); + + assert.deepEqual(_.pick(object, args), { 'a': 1, 'c': 3 }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.pickBy'); + + (function() { + QUnit.test('should work with a predicate argument', function(assert) { + assert.expect(1); + + var object = { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }; + + var actual = _.pickBy(object, function(n) { + return n == 1 || n == 3; + }); + + assert.deepEqual(actual, { 'a': 1, 'c': 3 }); + }); + + QUnit.test('should not treat keys with dots as deep paths', function(assert) { + assert.expect(1); + + var object = { 'a.b.c': 1 }, + actual = _.pickBy(object, stubTrue); + + assert.deepEqual(actual, { 'a.b.c': 1 }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('pick methods'); + + lodashStable.each(['pick', 'pickBy'], function(methodName) { + var expected = { 'a': 1, 'c': 3 }, + func = _[methodName], + isPick = methodName == 'pick', + object = { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }, + resolve = lodashStable.nthArg(1); + + if (methodName == 'pickBy') { + resolve = function(object, props) { + props = lodashStable.castArray(props); + return function(value) { + return lodashStable.some(props, function(key) { + key = lodashStable.isSymbol(key) ? key : lodashStable.toString(key); + return object[key] === value; + }); + }; + }; + } + QUnit.test('`_.' + methodName + '` should create an object of picked string keyed properties', function(assert) { + assert.expect(2); + + assert.deepEqual(func(object, resolve(object, 'a')), { 'a': 1 }); + assert.deepEqual(func(object, resolve(object, ['a', 'c'])), expected); + }); + + QUnit.test('`_.' + methodName + '` should pick inherited string keyed properties', function(assert) { + assert.expect(1); + + function Foo() {} + Foo.prototype = object; + + var foo = new Foo; + assert.deepEqual(func(foo, resolve(foo, ['a', 'c'])), expected); + }); + + QUnit.test('`_.' + methodName + '` should preserve the sign of `0`', function(assert) { + assert.expect(1); + + var object = { '-0': 'a', '0': 'b' }, + props = [-0, Object(-0), 0, Object(0)], + expected = [{ '-0': 'a' }, { '-0': 'a' }, { '0': 'b' }, { '0': 'b' }]; + + var actual = lodashStable.map(props, function(key) { + return func(object, resolve(object, key)); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should pick symbols', function(assert) { + assert.expect(3); + + function Foo() { + this[symbol] = 1; + } + + if (Symbol) { + var symbol2 = Symbol('b'); + Foo.prototype[symbol2] = 2; + + var symbol3 = Symbol('c'); + defineProperty(Foo.prototype, symbol3, { + 'configurable': true, + 'enumerable': false, + 'writable': true, + 'value': 3 + }); + + var foo = new Foo, + actual = func(foo, resolve(foo, [symbol, symbol2, symbol3])); + + assert.strictEqual(actual[symbol], 1); + assert.strictEqual(actual[symbol2], 2); + + if (isPick) { + assert.strictEqual(actual[symbol3], 3); + } else { + assert.notOk(symbol3 in actual); + } + } + else { + skipAssert(assert, 3); + } + }); + + QUnit.test('`_.' + methodName + '` should work with an array `object`', function(assert) { + assert.expect(1); + + var array = [1, 2, 3]; + assert.deepEqual(func(array, resolve(array, '1')), { '1': 2 }); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.property'); + + (function() { + QUnit.test('should create a function that plucks a property value of a given object', function(assert) { + assert.expect(4); + + var object = { 'a': 1 }; + + lodashStable.each(['a', ['a']], function(path) { + var prop = _.property(path); + assert.strictEqual(prop.length, 1); + assert.strictEqual(prop(object), 1); + }); + }); + + QUnit.test('should pluck deep property values', function(assert) { + assert.expect(2); + + var object = { 'a': { 'b': 2 } }; + + lodashStable.each(['a.b', ['a', 'b']], function(path) { + var prop = _.property(path); + assert.strictEqual(prop(object), 2); + }); + }); + + QUnit.test('should pluck inherited property values', function(assert) { + assert.expect(2); + + function Foo() {} + Foo.prototype.a = 1; + + lodashStable.each(['a', ['a']], function(path) { + var prop = _.property(path); + assert.strictEqual(prop(new Foo), 1); + }); + }); + + QUnit.test('should work with a non-string `path`', function(assert) { + assert.expect(2); + + var array = [1, 2, 3]; + + lodashStable.each([1, [1]], function(path) { + var prop = _.property(path); + assert.strictEqual(prop(array), 2); + }); + }); + + QUnit.test('should preserve the sign of `0`', function(assert) { + assert.expect(1); + + var object = { '-0': 'a', '0': 'b' }, + props = [-0, Object(-0), 0, Object(0)]; + + var actual = lodashStable.map(props, function(key) { + var prop = _.property(key); + return prop(object); + }); + + assert.deepEqual(actual, ['a', 'a', 'b', 'b']); + }); + + QUnit.test('should coerce `path` to a string', function(assert) { + assert.expect(2); + + function fn() {} + fn.toString = lodashStable.constant('fn'); + + var expected = [1, 2, 3, 4], + object = { 'null': 1, 'undefined': 2, 'fn': 3, '[object Object]': 4 }, + paths = [null, undefined, fn, {}]; + + lodashStable.times(2, function(index) { + var actual = lodashStable.map(paths, function(path) { + var prop = _.property(index ? [path] : path); + return prop(object); + }); + + assert.deepEqual(actual, expected); + }); + }); + + QUnit.test('should pluck a key over a path', function(assert) { + assert.expect(2); + + var object = { 'a.b': 1, 'a': { 'b': 2 } }; + + lodashStable.each(['a.b', ['a.b']], function(path) { + var prop = _.property(path); + assert.strictEqual(prop(object), 1); + }); + }); + + QUnit.test('should return `undefined` when `object` is nullish', function(assert) { + assert.expect(2); + + var values = [, null, undefined], + expected = lodashStable.map(values, noop); + + lodashStable.each(['constructor', ['constructor']], function(path) { + var prop = _.property(path); + + var actual = lodashStable.map(values, function(value, index) { + return index ? prop(value) : prop(); + }); + + assert.deepEqual(actual, expected); + }); + }); + + QUnit.test('should return `undefined` for deep paths when `object` is nullish', function(assert) { + assert.expect(2); + + var values = [, null, undefined], + expected = lodashStable.map(values, noop); + + lodashStable.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], function(path) { + var prop = _.property(path); + + var actual = lodashStable.map(values, function(value, index) { + return index ? prop(value) : prop(); + }); + + assert.deepEqual(actual, expected); + }); + }); + + QUnit.test('should return `undefined` if parts of `path` are missing', function(assert) { + assert.expect(4); + + var object = {}; + + lodashStable.each(['a', 'a[1].b.c', ['a'], ['a', '1', 'b', 'c']], function(path) { + var prop = _.property(path); + assert.strictEqual(prop(object), undefined); + }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.propertyOf'); + + (function() { + QUnit.test('should create a function that plucks a property value of a given key', function(assert) { + assert.expect(3); + + var object = { 'a': 1 }, + propOf = _.propertyOf(object); + + assert.strictEqual(propOf.length, 1); + lodashStable.each(['a', ['a']], function(path) { + assert.strictEqual(propOf(path), 1); + }); + }); + + QUnit.test('should pluck deep property values', function(assert) { + assert.expect(2); + + var object = { 'a': { 'b': 2 } }, + propOf = _.propertyOf(object); + + lodashStable.each(['a.b', ['a', 'b']], function(path) { + assert.strictEqual(propOf(path), 2); + }); + }); + + QUnit.test('should pluck inherited property values', function(assert) { + assert.expect(2); + + function Foo() { + this.a = 1; + } + Foo.prototype.b = 2; + + var propOf = _.propertyOf(new Foo); + + lodashStable.each(['b', ['b']], function(path) { + assert.strictEqual(propOf(path), 2); + }); + }); + + QUnit.test('should work with a non-string `path`', function(assert) { + assert.expect(2); + + var array = [1, 2, 3], + propOf = _.propertyOf(array); + + lodashStable.each([1, [1]], function(path) { + assert.strictEqual(propOf(path), 2); + }); + }); + + QUnit.test('should preserve the sign of `0`', function(assert) { + assert.expect(1); + + var object = { '-0': 'a', '0': 'b' }, + props = [-0, Object(-0), 0, Object(0)]; + + var actual = lodashStable.map(props, function(key) { + var propOf = _.propertyOf(object); + return propOf(key); + }); + + assert.deepEqual(actual, ['a', 'a', 'b', 'b']); + }); + + QUnit.test('should coerce `path` to a string', function(assert) { + assert.expect(2); + + function fn() {} + fn.toString = lodashStable.constant('fn'); + + var expected = [1, 2, 3, 4], + object = { 'null': 1, 'undefined': 2, 'fn': 3, '[object Object]': 4 }, + paths = [null, undefined, fn, {}]; + + lodashStable.times(2, function(index) { + var actual = lodashStable.map(paths, function(path) { + var propOf = _.propertyOf(object); + return propOf(index ? [path] : path); + }); + + assert.deepEqual(actual, expected); + }); + }); + + QUnit.test('should pluck a key over a path', function(assert) { + assert.expect(2); + + var object = { 'a.b': 1, 'a': { 'b': 2 } }, + propOf = _.propertyOf(object); + + lodashStable.each(['a.b', ['a.b']], function(path) { + assert.strictEqual(propOf(path), 1); + }); + }); + + QUnit.test('should return `undefined` when `object` is nullish', function(assert) { + assert.expect(2); + + var values = [, null, undefined], + expected = lodashStable.map(values, noop); + + lodashStable.each(['constructor', ['constructor']], function(path) { + var actual = lodashStable.map(values, function(value, index) { + var propOf = index ? _.propertyOf(value) : _.propertyOf(); + return propOf(path); + }); + + assert.deepEqual(actual, expected); + }); + }); + + QUnit.test('should return `undefined` for deep paths when `object` is nullish', function(assert) { + assert.expect(2); + + var values = [, null, undefined], + expected = lodashStable.map(values, noop); + + lodashStable.each(['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']], function(path) { + var actual = lodashStable.map(values, function(value, index) { + var propOf = index ? _.propertyOf(value) : _.propertyOf(); + return propOf(path); + }); + + assert.deepEqual(actual, expected); + }); + }); + + QUnit.test('should return `undefined` if parts of `path` are missing', function(assert) { + assert.expect(4); + + var propOf = _.propertyOf({}); + + lodashStable.each(['a', 'a[1].b.c', ['a'], ['a', '1', 'b', 'c']], function(path) { + assert.strictEqual(propOf(path), undefined); + }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.pullAll'); + + (function() { + QUnit.test('should work with the same value for `array` and `values`', function(assert) { + assert.expect(1); + + var array = [{ 'a': 1 }, { 'b': 2 }], + actual = _.pullAll(array, array); + + assert.deepEqual(actual, []); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.pullAllBy'); + + (function() { + QUnit.test('should accept an `iteratee`', function(assert) { + assert.expect(1); + + var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }]; + + var actual = _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], function(object) { + return object.x; + }); + + assert.deepEqual(actual, [{ 'x': 2 }]); + }); + + QUnit.test('should provide correct `iteratee` arguments', function(assert) { + assert.expect(1); + + var args, + array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }]; + + _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], function() { + args || (args = slice.call(arguments)); + }); + + assert.deepEqual(args, [{ 'x': 1 }]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.pullAllWith'); + + (function() { + QUnit.test('should work with a `comparator`', function(assert) { + assert.expect(1); + + var objects = [{ 'x': 1, 'y': 1 }, { 'x': 2, 'y': 2 }, { 'x': 3, 'y': 3 }], + expected = [objects[0], objects[2]], + actual = _.pullAllWith(objects, [{ 'x': 2, 'y': 2 }], lodashStable.isEqual); + + assert.deepEqual(actual, expected); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('pull methods'); + + lodashStable.each(['pull', 'pullAll', 'pullAllWith'], function(methodName) { + var func = _[methodName], + isPull = methodName == 'pull'; + + function pull(array, values) { + return isPull + ? func.apply(undefined, [array].concat(values)) + : func(array, values); + } + + QUnit.test('`_.' + methodName + '` should modify and return the array', function(assert) { + assert.expect(2); + + var array = [1, 2, 3], + actual = pull(array, [1, 3]); + + assert.strictEqual(actual, array); + assert.deepEqual(array, [2]); + }); + + QUnit.test('`_.' + methodName + '` should preserve holes in arrays', function(assert) { + assert.expect(2); + + var array = [1, 2, 3, 4]; + delete array[1]; + delete array[3]; + + pull(array, [1]); + assert.notOk('0' in array); + assert.notOk('2' in array); + }); + + QUnit.test('`_.' + methodName + '` should treat holes as `undefined`', function(assert) { + assert.expect(1); + + var array = [1, 2, 3]; + delete array[1]; + + pull(array, [undefined]); + assert.deepEqual(array, [1, 3]); + }); + + QUnit.test('`_.' + methodName + '` should match `NaN`', function(assert) { + assert.expect(1); + + var array = [1, NaN, 3, NaN]; + + pull(array, [NaN]); + assert.deepEqual(array, [1, 3]); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.pullAt'); + + (function() { + QUnit.test('should modify the array and return removed elements', function(assert) { + assert.expect(2); + + var array = [1, 2, 3], + actual = _.pullAt(array, [0, 1]); + + assert.deepEqual(array, [3]); + assert.deepEqual(actual, [1, 2]); + }); + + QUnit.test('should work with unsorted indexes', function(assert) { + assert.expect(2); + + var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], + actual = _.pullAt(array, [1, 3, 11, 7, 5, 9]); + + assert.deepEqual(array, [1, 3, 5, 7, 9, 11]); + assert.deepEqual(actual, [2, 4, 12, 8, 6, 10]); + }); + + QUnit.test('should work with repeated indexes', function(assert) { + assert.expect(2); + + var array = [1, 2, 3, 4], + actual = _.pullAt(array, [0, 2, 0, 1, 0, 2]); + + assert.deepEqual(array, [4]); + assert.deepEqual(actual, [1, 3, 1, 2, 1, 3]); + }); + + QUnit.test('should use `undefined` for nonexistent indexes', function(assert) { + assert.expect(2); + + var array = ['a', 'b', 'c'], + actual = _.pullAt(array, [2, 4, 0]); + + assert.deepEqual(array, ['b']); + assert.deepEqual(actual, ['c', undefined, 'a']); + }); + + QUnit.test('should flatten `indexes`', function(assert) { + assert.expect(4); + + var array = ['a', 'b', 'c']; + assert.deepEqual(_.pullAt(array, 2, 0), ['c', 'a']); + assert.deepEqual(array, ['b']); + + array = ['a', 'b', 'c', 'd']; + assert.deepEqual(_.pullAt(array, [3, 0], 2), ['d', 'a', 'c']); + assert.deepEqual(array, ['b']); + }); + + QUnit.test('should return an empty array when no indexes are given', function(assert) { + assert.expect(4); + + var array = ['a', 'b', 'c'], + actual = _.pullAt(array); + + assert.deepEqual(array, ['a', 'b', 'c']); + assert.deepEqual(actual, []); + + actual = _.pullAt(array, [], []); + + assert.deepEqual(array, ['a', 'b', 'c']); + assert.deepEqual(actual, []); + }); + + QUnit.test('should work with non-index paths', function(assert) { + assert.expect(2); + + var values = lodashStable.reject(empties, function(value) { + return (value === 0) || lodashStable.isArray(value); + }).concat(-1, 1.1); + + var array = lodashStable.transform(values, function(result, value) { + result[value] = 1; + }, []); + + var expected = lodashStable.map(values, stubOne), + actual = _.pullAt(array, values); + + assert.deepEqual(actual, expected); + + expected = lodashStable.map(values, noop); + actual = lodashStable.at(array, values); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should preserve the sign of `0`', function(assert) { + assert.expect(1); + + var props = [-0, Object(-0), 0, Object(0)]; + + var actual = lodashStable.map(props, function(key) { + var array = [-1]; + array['-0'] = -2; + return _.pullAt(array, key); + }); + + assert.deepEqual(actual, [[-2], [-2], [-1], [-1]]); + }); + + QUnit.test('should support deep paths', function(assert) { + assert.expect(3); + + var array = []; + array.a = { 'b': 2 }; + + var actual = _.pullAt(array, 'a.b'); + + assert.deepEqual(actual, [2]); + assert.deepEqual(array.a, {}); + + try { + actual = _.pullAt(array, 'a.b.c'); + } catch (e) {} + + assert.deepEqual(actual, [undefined]); + }); + + QUnit.test('should work with a falsey `array` when keys are given', function(assert) { + assert.expect(1); + + var values = falsey.slice(), + expected = lodashStable.map(values, lodashStable.constant(Array(4))); + + var actual = lodashStable.map(values, function(array) { + try { + return _.pullAt(array, 0, 1, 'pop', 'push'); + } catch (e) {} + }); + + assert.deepEqual(actual, expected); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.random'); + + (function() { + var array = Array(1000); + + QUnit.test('should return `0` or `1` when no arguments are given', function(assert) { + assert.expect(1); + + var actual = lodashStable.uniq(lodashStable.map(array, function() { + return _.random(); + })).sort(); + + assert.deepEqual(actual, [0, 1]); + }); + + QUnit.test('should support a `min` and `max`', function(assert) { + assert.expect(1); + + var min = 5, + max = 10; + + assert.ok(lodashStable.some(array, function() { + var result = _.random(min, max); + return result >= min && result <= max; + })); + }); + + QUnit.test('should support not providing a `max`', function(assert) { + assert.expect(1); + + var min = 0, + max = 5; + + assert.ok(lodashStable.some(array, function() { + var result = _.random(max); + return result >= min && result <= max; + })); + }); + + QUnit.test('should swap `min` and `max` when `min` > `max`', function(assert) { + assert.expect(1); + + var min = 4, + max = 2, + expected = [2, 3, 4]; + + var actual = lodashStable.uniq(lodashStable.map(array, function() { + return _.random(min, max); + })).sort(); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should support large integer values', function(assert) { + assert.expect(2); + + var min = Math.pow(2, 31), + max = Math.pow(2, 62); + + assert.ok(lodashStable.every(array, function() { + var result = _.random(min, max); + return result >= min && result <= max; + })); + + assert.ok(lodashStable.some(array, function() { + return _.random(MAX_INTEGER); + })); + }); + + QUnit.test('should coerce arguments to finite numbers', function(assert) { + assert.expect(1); + + var actual = [ + _.random(NaN, NaN), + _.random('1', '1'), + _.random(Infinity, Infinity) + ]; + + assert.deepEqual(actual, [0, 1, MAX_INTEGER]); + }); + + QUnit.test('should support floats', function(assert) { + assert.expect(2); + + var min = 1.5, + max = 1.6, + actual = _.random(min, max); + + assert.ok(actual % 1); + assert.ok(actual >= min && actual <= max); + }); + + QUnit.test('should support providing a `floating`', function(assert) { + assert.expect(3); + + var actual = _.random(true); + assert.ok(actual % 1 && actual >= 0 && actual <= 1); + + actual = _.random(2, true); + assert.ok(actual % 1 && actual >= 0 && actual <= 2); + + actual = _.random(2, 4, true); + assert.ok(actual % 1 && actual >= 2 && actual <= 4); + }); + + QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) { + assert.expect(1); + + var array = [1, 2, 3], + expected = lodashStable.map(array, stubTrue), + randoms = lodashStable.map(array, _.random); + + var actual = lodashStable.map(randoms, function(result, index) { + return result >= 0 && result <= array[index] && (result % 1) == 0; + }); + + assert.deepEqual(actual, expected); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('range methods'); + + lodashStable.each(['range', 'rangeRight'], function(methodName) { + var func = _[methodName], + isRange = methodName == 'range'; + + function resolve(range) { + return isRange ? range : range.reverse(); + } + + QUnit.test('`_.' + methodName + '` should infer the sign of `step` when only `end` is given', function(assert) { + assert.expect(2); + + assert.deepEqual(func(4), resolve([0, 1, 2, 3])); + assert.deepEqual(func(-4), resolve([0, -1, -2, -3])); + }); + + QUnit.test('`_.' + methodName + '` should infer the sign of `step` when only `start` and `end` are given', function(assert) { + assert.expect(2); + + assert.deepEqual(func(1, 5), resolve([1, 2, 3, 4])); + assert.deepEqual(func(5, 1), resolve([5, 4, 3, 2])); + }); + + QUnit.test('`_.' + methodName + '` should work with a `start`, `end`, and `step`', function(assert) { + assert.expect(3); + + assert.deepEqual(func(0, -4, -1), resolve([0, -1, -2, -3])); + assert.deepEqual(func(5, 1, -1), resolve([5, 4, 3, 2])); + assert.deepEqual(func(0, 20, 5), resolve([0, 5, 10, 15])); + }); + + QUnit.test('`_.' + methodName + '` should support a `step` of `0`', function(assert) { + assert.expect(1); + + assert.deepEqual(func(1, 4, 0), [1, 1, 1]); + }); + + QUnit.test('`_.' + methodName + '` should work with a `step` larger than `end`', function(assert) { + assert.expect(1); + + assert.deepEqual(func(1, 5, 20), [1]); + }); + + QUnit.test('`_.' + methodName + '` should work with a negative `step`', function(assert) { + assert.expect(2); + + assert.deepEqual(func(0, -4, -1), resolve([0, -1, -2, -3])); + assert.deepEqual(func(21, 10, -3), resolve([21, 18, 15, 12])); + }); + + QUnit.test('`_.' + methodName + '` should support `start` of `-0`', function(assert) { + assert.expect(1); + + var actual = func(-0, 1); + assert.strictEqual(1 / actual[0], -Infinity); + }); + + QUnit.test('`_.' + methodName + '` should treat falsey `start` as `0`', function(assert) { + assert.expect(13); + + lodashStable.each(falsey, function(value, index) { + if (index) { + assert.deepEqual(func(value), []); + assert.deepEqual(func(value, 1), [0]); + } else { + assert.deepEqual(func(), []); + } + }); + }); + + QUnit.test('`_.' + methodName + '` should coerce arguments to finite numbers', function(assert) { + assert.expect(1); + + var actual = [ + func('1'), + func('0', 1), + func(0, 1, '1'), + func(NaN), + func(NaN, NaN) + ]; + + assert.deepEqual(actual, [[0], [0], [0], [], []]); + }); + + QUnit.test('`_.' + methodName + '` should work as an iteratee for methods like `_.map`', function(assert) { + assert.expect(2); + + var array = [1, 2, 3], + object = { 'a': 1, 'b': 2, 'c': 3 }, + expected = lodashStable.map([[0], [0, 1], [0, 1, 2]], resolve); + + lodashStable.each([array, object], function(collection) { + var actual = lodashStable.map(collection, func); + assert.deepEqual(actual, expected); + }); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.rearg'); + + (function() { + function fn() { + return slice.call(arguments); + } + + QUnit.test('should reorder arguments provided to `func`', function(assert) { + assert.expect(1); + + var rearged = _.rearg(fn, [2, 0, 1]); + assert.deepEqual(rearged('b', 'c', 'a'), ['a', 'b', 'c']); + }); + + QUnit.test('should work with repeated indexes', function(assert) { + assert.expect(1); + + var rearged = _.rearg(fn, [1, 1, 1]); + assert.deepEqual(rearged('c', 'a', 'b'), ['a', 'a', 'a']); + }); + + QUnit.test('should use `undefined` for nonexistent indexes', function(assert) { + assert.expect(1); + + var rearged = _.rearg(fn, [1, 4]); + assert.deepEqual(rearged('b', 'a', 'c'), ['a', undefined, 'c']); + }); + + QUnit.test('should use `undefined` for non-index values', function(assert) { + assert.expect(1); + + var values = lodashStable.reject(empties, function(value) { + return (value === 0) || lodashStable.isArray(value); + }).concat(-1, 1.1); + + var expected = lodashStable.map(values, lodashStable.constant([undefined, 'b', 'c'])); + + var actual = lodashStable.map(values, function(value) { + var rearged = _.rearg(fn, [value]); + return rearged('a', 'b', 'c'); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should not rearrange arguments when no indexes are given', function(assert) { + assert.expect(2); + + var rearged = _.rearg(fn); + assert.deepEqual(rearged('a', 'b', 'c'), ['a', 'b', 'c']); + + rearged = _.rearg(fn, [], []); + assert.deepEqual(rearged('a', 'b', 'c'), ['a', 'b', 'c']); + }); + + QUnit.test('should accept multiple index arguments', function(assert) { + assert.expect(1); + + var rearged = _.rearg(fn, 2, 0, 1); + assert.deepEqual(rearged('b', 'c', 'a'), ['a', 'b', 'c']); + }); + + QUnit.test('should accept multiple arrays of indexes', function(assert) { + assert.expect(1); + + var rearged = _.rearg(fn, [2], [0, 1]); + assert.deepEqual(rearged('b', 'c', 'a'), ['a', 'b', 'c']); + }); + + QUnit.test('should work with fewer indexes than arguments', function(assert) { + assert.expect(1); + + var rearged = _.rearg(fn, [1, 0]); + assert.deepEqual(rearged('b', 'a', 'c'), ['a', 'b', 'c']); + }); + + QUnit.test('should work on functions that have been rearged', function(assert) { + assert.expect(1); + + var rearged1 = _.rearg(fn, 2, 1, 0), + rearged2 = _.rearg(rearged1, 1, 0, 2); + + assert.deepEqual(rearged2('b', 'c', 'a'), ['a', 'b', 'c']); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.reduce'); + + (function() { + var array = [1, 2, 3]; + + QUnit.test('should use the first element of a collection as the default `accumulator`', function(assert) { + assert.expect(1); + + assert.strictEqual(_.reduce(array), 1); + }); + + QUnit.test('should provide correct `iteratee` arguments when iterating an array', function(assert) { + assert.expect(2); + + var args; + + _.reduce(array, function() { + args || (args = slice.call(arguments)); + }, 0); + + assert.deepEqual(args, [0, 1, 0, array]); + + args = undefined; + _.reduce(array, function() { + args || (args = slice.call(arguments)); + }); + + assert.deepEqual(args, [1, 2, 1, array]); + }); + + QUnit.test('should provide correct `iteratee` arguments when iterating an object', function(assert) { + assert.expect(2); + + var args, + object = { 'a': 1, 'b': 2 }, + firstKey = _.head(_.keys(object)); + + var expected = firstKey == 'a' + ? [0, 1, 'a', object] + : [0, 2, 'b', object]; + + _.reduce(object, function() { + args || (args = slice.call(arguments)); + }, 0); + + assert.deepEqual(args, expected); + + args = undefined; + expected = firstKey == 'a' + ? [1, 2, 'b', object] + : [2, 1, 'a', object]; + + _.reduce(object, function() { + args || (args = slice.call(arguments)); + }); + + assert.deepEqual(args, expected); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.reduceRight'); + + (function() { + var array = [1, 2, 3]; + + QUnit.test('should use the last element of a collection as the default `accumulator`', function(assert) { + assert.expect(1); + + assert.strictEqual(_.reduceRight(array), 3); + }); + + QUnit.test('should provide correct `iteratee` arguments when iterating an array', function(assert) { + assert.expect(2); + + var args; + + _.reduceRight(array, function() { + args || (args = slice.call(arguments)); + }, 0); + + assert.deepEqual(args, [0, 3, 2, array]); + + args = undefined; + _.reduceRight(array, function() { + args || (args = slice.call(arguments)); + }); + + assert.deepEqual(args, [3, 2, 1, array]); + }); + + QUnit.test('should provide correct `iteratee` arguments when iterating an object', function(assert) { + assert.expect(2); + + var args, + object = { 'a': 1, 'b': 2 }, + isFIFO = lodashStable.keys(object)[0] == 'a'; + + var expected = isFIFO + ? [0, 2, 'b', object] + : [0, 1, 'a', object]; + + _.reduceRight(object, function() { + args || (args = slice.call(arguments)); + }, 0); + + assert.deepEqual(args, expected); + + args = undefined; + expected = isFIFO + ? [2, 1, 'a', object] + : [1, 2, 'b', object]; + + _.reduceRight(object, function() { + args || (args = slice.call(arguments)); + }); + + assert.deepEqual(args, expected); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('reduce methods'); + + lodashStable.each(['reduce', 'reduceRight'], function(methodName) { + var func = _[methodName], + array = [1, 2, 3], + isReduce = methodName == 'reduce'; + + QUnit.test('`_.' + methodName + '` should reduce a collection to a single value', function(assert) { + assert.expect(1); + + var actual = func(['a', 'b', 'c'], function(accumulator, value) { + return accumulator + value; + }, ''); + + assert.strictEqual(actual, isReduce ? 'abc' : 'cba'); + }); + + QUnit.test('`_.' + methodName + '` should support empty collections without an initial `accumulator` value', function(assert) { + assert.expect(1); + + var actual = [], + expected = lodashStable.map(empties, noop); + + lodashStable.each(empties, function(value) { + try { + actual.push(func(value, noop)); + } catch (e) {} + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should support empty collections with an initial `accumulator` value', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(empties, lodashStable.constant('x')); + + var actual = lodashStable.map(empties, function(value) { + try { + return func(value, noop, 'x'); + } catch (e) {} + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should handle an initial `accumulator` value of `undefined`', function(assert) { + assert.expect(1); + + var actual = func([], noop, undefined); + assert.strictEqual(actual, undefined); + }); + + QUnit.test('`_.' + methodName + '` should return `undefined` for empty collections when no `accumulator` is given (test in IE > 9 and modern browsers)', function(assert) { + assert.expect(2); + + var array = [], + object = { '0': 1, 'length': 0 }; + + if ('__proto__' in array) { + array.__proto__ = object; + assert.strictEqual(func(array, noop), undefined); + } + else { + skipAssert(assert); + } + assert.strictEqual(func(object, noop), undefined); + }); + + QUnit.test('`_.' + methodName + '` should return an unwrapped value when implicitly chaining', function(assert) { + assert.expect(1); + + if (!isNpm) { + assert.strictEqual(_(array)[methodName](add), 6); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.' + methodName + '` should return a wrapped value when explicitly chaining', function(assert) { + assert.expect(1); + + if (!isNpm) { + assert.ok(_(array).chain()[methodName](add) instanceof _); + } + else { + skipAssert(assert); + } + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.reject'); + + (function() { + var array = [1, 2, 3]; + + QUnit.test('should return elements the `predicate` returns falsey for', function(assert) { + assert.expect(1); + + assert.deepEqual(_.reject(array, isEven), [1, 3]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('filter methods'); + + lodashStable.each(['filter', 'reject'], function(methodName) { + var array = [1, 2, 3, 4], + func = _[methodName], + isFilter = methodName == 'filter', + objects = [{ 'a': 0 }, { 'a': 1 }]; + + QUnit.test('`_.' + methodName + '` should not modify the resulting value from within `predicate`', function(assert) { + assert.expect(1); + + var actual = func([0], function(value, index, array) { + array[index] = 1; + return isFilter; + }); + + assert.deepEqual(actual, [0]); + }); + + QUnit.test('`_.' + methodName + '` should work with `_.property` shorthands', function(assert) { + assert.expect(1); + + assert.deepEqual(func(objects, 'a'), [objects[isFilter ? 1 : 0]]); + }); + + QUnit.test('`_.' + methodName + '` should work with `_.matches` shorthands', function(assert) { + assert.expect(1); + + assert.deepEqual(func(objects, objects[1]), [objects[isFilter ? 1 : 0]]); + }); + + QUnit.test('`_.' + methodName + '` should not modify wrapped values', function(assert) { + assert.expect(2); + + if (!isNpm) { + var wrapped = _(array); + + var actual = wrapped[methodName](function(n) { + return n < 3; + }); + + assert.deepEqual(actual.value(), isFilter ? [1, 2] : [3, 4]); + + actual = wrapped[methodName](function(n) { + return n > 2; + }); + + assert.deepEqual(actual.value(), isFilter ? [3, 4] : [1, 2]); + } + else { + skipAssert(assert, 2); + } + }); + + QUnit.test('`_.' + methodName + '` should work in a lazy sequence', function(assert) { + assert.expect(2); + + if (!isNpm) { + var array = lodashStable.range(LARGE_ARRAY_SIZE + 1), + predicate = function(value) { return isFilter ? isEven(value) : !isEven(value); }; + + var object = lodashStable.zipObject(lodashStable.times(LARGE_ARRAY_SIZE, function(index) { + return ['key' + index, index]; + })); + + var actual = _(array).slice(1).map(square)[methodName](predicate).value(); + assert.deepEqual(actual, _[methodName](lodashStable.map(array.slice(1), square), predicate)); + + actual = _(object).mapValues(square)[methodName](predicate).value(); + assert.deepEqual(actual, _[methodName](lodashStable.mapValues(object, square), predicate)); + } + else { + skipAssert(assert, 2); + } + }); + + QUnit.test('`_.' + methodName + '` should provide correct `predicate` arguments in a lazy sequence', function(assert) { + assert.expect(5); + + if (!isNpm) { + var args, + array = lodashStable.range(LARGE_ARRAY_SIZE + 1), + expected = [1, 0, lodashStable.map(array.slice(1), square)]; + + _(array).slice(1)[methodName](function(value, index, array) { + args || (args = slice.call(arguments)); + }).value(); + + assert.deepEqual(args, [1, 0, array.slice(1)]); + + args = undefined; + _(array).slice(1).map(square)[methodName](function(value, index, array) { + args || (args = slice.call(arguments)); + }).value(); + + assert.deepEqual(args, expected); + + args = undefined; + _(array).slice(1).map(square)[methodName](function(value, index) { + args || (args = slice.call(arguments)); + }).value(); + + assert.deepEqual(args, expected); + + args = undefined; + _(array).slice(1).map(square)[methodName](function(value) { + args || (args = slice.call(arguments)); + }).value(); + + assert.deepEqual(args, [1]); + + args = undefined; + _(array).slice(1).map(square)[methodName](function() { + args || (args = slice.call(arguments)); + }).value(); + + assert.deepEqual(args, expected); + } + else { + skipAssert(assert, 5); + } + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.remove'); + + (function() { + QUnit.test('should modify the array and return removed elements', function(assert) { + assert.expect(2); + + var array = [1, 2, 3, 4], + actual = _.remove(array, isEven); + + assert.deepEqual(array, [1, 3]); + assert.deepEqual(actual, [2, 4]); + }); + + QUnit.test('should provide correct `predicate` arguments', function(assert) { + assert.expect(1); + + var argsList = [], + array = [1, 2, 3], + clone = array.slice(); + + _.remove(array, function(n, index) { + var args = slice.call(arguments); + args[2] = args[2].slice(); + argsList.push(args); + return isEven(index); + }); + + assert.deepEqual(argsList, [[1, 0, clone], [2, 1, clone], [3, 2, clone]]); + }); + + QUnit.test('should work with `_.matches` shorthands', function(assert) { + assert.expect(1); + + var objects = [{ 'a': 0, 'b': 1 }, { 'a': 1, 'b': 2 }]; + _.remove(objects, { 'a': 1 }); + assert.deepEqual(objects, [{ 'a': 0, 'b': 1 }]); + }); + + QUnit.test('should work with `_.matchesProperty` shorthands', function(assert) { + assert.expect(1); + + var objects = [{ 'a': 0, 'b': 1 }, { 'a': 1, 'b': 2 }]; + _.remove(objects, ['a', 1]); + assert.deepEqual(objects, [{ 'a': 0, 'b': 1 }]); + }); + + QUnit.test('should work with `_.property` shorthands', function(assert) { + assert.expect(1); + + var objects = [{ 'a': 0 }, { 'a': 1 }]; + _.remove(objects, 'a'); + assert.deepEqual(objects, [{ 'a': 0 }]); + }); + + QUnit.test('should preserve holes in arrays', function(assert) { + assert.expect(2); + + var array = [1, 2, 3, 4]; + delete array[1]; + delete array[3]; + + _.remove(array, function(n) { + return n === 1; + }); + + assert.notOk('0' in array); + assert.notOk('2' in array); + }); + + QUnit.test('should treat holes as `undefined`', function(assert) { + assert.expect(1); + + var array = [1, 2, 3]; + delete array[1]; + + _.remove(array, function(n) { + return n == null; + }); + + assert.deepEqual(array, [1, 3]); + }); + + QUnit.test('should not mutate the array until all elements to remove are determined', function(assert) { + assert.expect(1); + + var array = [1, 2, 3]; + + _.remove(array, function(n, index) { + return isEven(index); + }); + + assert.deepEqual(array, [2]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.repeat'); + + (function() { + var string = 'abc'; + + QUnit.test('should repeat a string `n` times', function(assert) { + assert.expect(2); + + assert.strictEqual(_.repeat('*', 3), '***'); + assert.strictEqual(_.repeat(string, 2), 'abcabc'); + }); + + QUnit.test('should treat falsey `n` values, except `undefined`, as `0`', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(falsey, function(value) { + return value === undefined ? string : ''; + }); + + var actual = lodashStable.map(falsey, function(n, index) { + return index ? _.repeat(string, n) : _.repeat(string); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should return an empty string if `n` is <= `0`', function(assert) { + assert.expect(2); + + assert.strictEqual(_.repeat(string, 0), ''); + assert.strictEqual(_.repeat(string, -2), ''); + }); + + QUnit.test('should coerce `n` to an integer', function(assert) { + assert.expect(3); + + assert.strictEqual(_.repeat(string, '2'), 'abcabc'); + assert.strictEqual(_.repeat(string, 2.6), 'abcabc'); + assert.strictEqual(_.repeat('*', { 'valueOf': stubThree }), '***'); + }); + + QUnit.test('should coerce `string` to a string', function(assert) { + assert.expect(2); + + assert.strictEqual(_.repeat(Object(string), 2), 'abcabc'); + assert.strictEqual(_.repeat({ 'toString': lodashStable.constant('*') }, 3), '***'); + }); + + QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) { + assert.expect(1); + + var actual = lodashStable.map(['a', 'b', 'c'], _.repeat); + assert.deepEqual(actual, ['a', 'b', 'c']); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.replace'); + + (function() { + QUnit.test('should replace the matched pattern', function(assert) { + assert.expect(2); + + var string = 'abcde'; + assert.strictEqual(_.replace(string, 'de', '123'), 'abc123'); + assert.strictEqual(_.replace(string, /[bd]/g, '-'), 'a-c-e'); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.result'); + + (function() { + var object = { 'a': 1, 'b': stubB }; + + QUnit.test('should invoke function values', function(assert) { + assert.expect(1); + + assert.strictEqual(_.result(object, 'b'), 'b'); + }); + + QUnit.test('should invoke default function values', function(assert) { + assert.expect(1); + + var actual = _.result(object, 'c', object.b); + assert.strictEqual(actual, 'b'); + }); + + QUnit.test('should invoke nested function values', function(assert) { + assert.expect(2); + + var value = { 'a': lodashStable.constant({ 'b': stubB }) }; + + lodashStable.each(['a.b', ['a', 'b']], function(path) { + assert.strictEqual(_.result(value, path), 'b'); + }); + }); + + QUnit.test('should invoke deep property methods with the correct `this` binding', function(assert) { + assert.expect(2); + + var value = { 'a': { 'b': function() { return this.c; }, 'c': 1 } }; + + lodashStable.each(['a.b', ['a', 'b']], function(path) { + assert.strictEqual(_.result(value, path), 1); + }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.get and lodash.result'); + + lodashStable.each(['get', 'result'], function(methodName) { + var func = _[methodName]; + + QUnit.test('`_.' + methodName + '` should get string keyed property values', function(assert) { + assert.expect(2); + + var object = { 'a': 1 }; + + lodashStable.each(['a', ['a']], function(path) { + assert.strictEqual(func(object, path), 1); + }); + }); + + QUnit.test('`_.' + methodName + '` should preserve the sign of `0`', function(assert) { + assert.expect(1); + + var object = { '-0': 'a', '0': 'b' }, + props = [-0, Object(-0), 0, Object(0)]; + + var actual = lodashStable.map(props, function(key) { + return func(object, key); + }); + + assert.deepEqual(actual, ['a', 'a', 'b', 'b']); + }); + + QUnit.test('`_.' + methodName + '` should get symbol keyed property values', function(assert) { + assert.expect(1); + + if (Symbol) { + var object = {}; + object[symbol] = 1; + + assert.strictEqual(func(object, symbol), 1); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.' + methodName + '` should get deep property values', function(assert) { + assert.expect(2); + + var object = { 'a': { 'b': 2 } }; + + lodashStable.each(['a.b', ['a', 'b']], function(path) { + assert.strictEqual(func(object, path), 2); + }); + }); + + QUnit.test('`_.' + methodName + '` should get a key over a path', function(assert) { + assert.expect(2); + + var object = { 'a.b': 1, 'a': { 'b': 2 } }; + + lodashStable.each(['a.b', ['a.b']], function(path) { + assert.strictEqual(func(object, path), 1); + }); + }); + + QUnit.test('`_.' + methodName + '` should not coerce array paths to strings', function(assert) { + assert.expect(1); + + var object = { 'a,b,c': 3, 'a': { 'b': { 'c': 4 } } }; + assert.strictEqual(func(object, ['a', 'b', 'c']), 4); + }); + + QUnit.test('`_.' + methodName + '` should not ignore empty brackets', function(assert) { + assert.expect(1); + + var object = { 'a': { '': 1 } }; + assert.strictEqual(func(object, 'a[]'), 1); + }); + + QUnit.test('`_.' + methodName + '` should handle empty paths', function(assert) { + assert.expect(4); + + lodashStable.each([['', ''], [[], ['']]], function(pair) { + assert.strictEqual(func({}, pair[0]), undefined); + assert.strictEqual(func({ '': 3 }, pair[1]), 3); + }); + }); + + QUnit.test('`_.' + methodName + '` should handle complex paths', function(assert) { + assert.expect(2); + + var object = { 'a': { '-1.23': { '["b"]': { 'c': { "['d']": { '\ne\n': { 'f': { 'g': 8 } } } } } } } }; + + var paths = [ + 'a[-1.23]["[\\"b\\"]"].c[\'[\\\'d\\\']\'][\ne\n][f].g', + ['a', '-1.23', '["b"]', 'c', "['d']", '\ne\n', 'f', 'g'] + ]; + + lodashStable.each(paths, function(path) { + assert.strictEqual(func(object, path), 8); + }); + }); + + QUnit.test('`_.' + methodName + '` should return `undefined` when `object` is nullish', function(assert) { + assert.expect(4); + + lodashStable.each(['constructor', ['constructor']], function(path) { + assert.strictEqual(func(null, path), undefined); + assert.strictEqual(func(undefined, path), undefined); + }); + }); + + QUnit.test('`_.' + methodName + '` should return `undefined` for deep paths when `object` is nullish', function(assert) { + assert.expect(2); + + var values = [null, undefined], + expected = lodashStable.map(values, noop), + paths = ['constructor.prototype.valueOf', ['constructor', 'prototype', 'valueOf']]; + + lodashStable.each(paths, function(path) { + var actual = lodashStable.map(values, function(value) { + return func(value, path); + }); + + assert.deepEqual(actual, expected); + }); + }); + + QUnit.test('`_.' + methodName + '` should return `undefined` if parts of `path` are missing', function(assert) { + assert.expect(2); + + var object = { 'a': [, null] }; + + lodashStable.each(['a[1].b.c', ['a', '1', 'b', 'c']], function(path) { + assert.strictEqual(func(object, path), undefined); + }); + }); + + QUnit.test('`_.' + methodName + '` should be able to return `null` values', function(assert) { + assert.expect(2); + + var object = { 'a': { 'b': null } }; + + lodashStable.each(['a.b', ['a', 'b']], function(path) { + assert.strictEqual(func(object, path), null); + }); + }); + + QUnit.test('`_.' + methodName + '` should follow `path` over non-plain objects', function(assert) { + assert.expect(2); + + var paths = ['a.b', ['a', 'b']]; + + lodashStable.each(paths, function(path) { + numberProto.a = { 'b': 2 }; + assert.strictEqual(func(0, path), 2); + delete numberProto.a; + }); + }); + + QUnit.test('`_.' + methodName + '` should return the default value for `undefined` values', function(assert) { + assert.expect(2); + + var object = { 'a': {} }, + values = empties.concat(true, new Date, 1, /x/, 'a'), + expected = lodashStable.map(values, function(value) { return [value, value]; }); + + lodashStable.each(['a.b', ['a', 'b']], function(path) { + var actual = lodashStable.map(values, function(value) { + return [func(object, path, value), func(null, path, value)]; + }); + + assert.deepEqual(actual, expected); + }); + }); + + QUnit.test('`_.' + methodName + '` should return the default value when `path` is empty', function(assert) { + assert.expect(1); + + assert.strictEqual(func({}, [], 'a'), 'a'); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.rest'); + + (function() { + function fn(a, b, c) { + return slice.call(arguments); + } + + QUnit.test('should apply a rest parameter to `func`', function(assert) { + assert.expect(1); + + var rest = _.rest(fn); + assert.deepEqual(rest(1, 2, 3, 4), [1, 2, [3, 4]]); + }); + + QUnit.test('should work with `start`', function(assert) { + assert.expect(1); + + var rest = _.rest(fn, 1); + assert.deepEqual(rest(1, 2, 3, 4), [1, [2, 3, 4]]); + }); + + QUnit.test('should treat `start` as `0` for `NaN` or negative values', function(assert) { + assert.expect(1); + + var values = [-1, NaN, 'a'], + expected = lodashStable.map(values, lodashStable.constant([[1, 2, 3, 4]])); + + var actual = lodashStable.map(values, function(value) { + var rest = _.rest(fn, value); + return rest(1, 2, 3, 4); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should coerce `start` to an integer', function(assert) { + assert.expect(1); + + var rest = _.rest(fn, 1.6); + assert.deepEqual(rest(1, 2, 3), [1, [2, 3]]); + }); + + QUnit.test('should use an empty array when `start` is not reached', function(assert) { + assert.expect(1); + + var rest = _.rest(fn); + assert.deepEqual(rest(1), [1, undefined, []]); + }); + + QUnit.test('should work on functions with more than three parameters', function(assert) { + assert.expect(1); + + var rest = _.rest(function(a, b, c, d) { + return slice.call(arguments); + }); + + assert.deepEqual(rest(1, 2, 3, 4, 5), [1, 2, 3, [4, 5]]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.reverse'); + + (function() { + var largeArray = lodashStable.range(LARGE_ARRAY_SIZE).concat(null), + smallArray = [0, 1, 2, null]; + + QUnit.test('should reverse `array`', function(assert) { + assert.expect(2); + + var array = [1, 2, 3], + actual = _.reverse(array); + + assert.strictEqual(actual, array); + assert.deepEqual(array, [3, 2, 1]); + }); + + QUnit.test('should return the wrapped reversed `array`', function(assert) { + assert.expect(6); + + if (!isNpm) { + lodashStable.times(2, function(index) { + var array = (index ? largeArray : smallArray).slice(), + clone = array.slice(), + wrapped = _(array).reverse(), + actual = wrapped.value(); + + assert.ok(wrapped instanceof _); + assert.strictEqual(actual, array); + assert.deepEqual(actual, clone.slice().reverse()); + }); + } + else { + skipAssert(assert, 6); + } + }); + + QUnit.test('should work in a lazy sequence', function(assert) { + assert.expect(4); + + if (!isNpm) { + lodashStable.times(2, function(index) { + var array = (index ? largeArray : smallArray).slice(), + expected = array.slice(), + actual = _(array).slice(1).reverse().value(); + + assert.deepEqual(actual, expected.slice(1).reverse()); + assert.deepEqual(array, expected); + }); + } + else { + skipAssert(assert, 4); + } + }); + + QUnit.test('should be lazy when in a lazy sequence', function(assert) { + assert.expect(3); + + if (!isNpm) { + var spy = { + 'toString': function() { + throw new Error('spy was revealed'); + } + }; + + var array = largeArray.concat(spy), + expected = array.slice(); + + try { + var wrapped = _(array).slice(1).map(String).reverse(), + actual = wrapped.last(); + } catch (e) {} + + assert.ok(wrapped instanceof _); + assert.strictEqual(actual, '1'); + assert.deepEqual(array, expected); + } + else { + skipAssert(assert, 3); + } + }); + + QUnit.test('should work in a hybrid sequence', function(assert) { + assert.expect(8); + + if (!isNpm) { + lodashStable.times(2, function(index) { + var clone = (index ? largeArray : smallArray).slice(); + + lodashStable.each(['map', 'filter'], function(methodName) { + var array = clone.slice(), + expected = clone.slice(1, -1).reverse(), + actual = _(array)[methodName](identity).thru(_.compact).reverse().value(); + + assert.deepEqual(actual, expected); + + array = clone.slice(); + actual = _(array).thru(_.compact)[methodName](identity).pull(1).push(3).reverse().value(); + + assert.deepEqual(actual, [3].concat(expected.slice(0, -1))); + }); + }); + } + else { + skipAssert(assert, 8); + } + }); + + QUnit.test('should track the `__chain__` value of a wrapper', function(assert) { + assert.expect(6); + + if (!isNpm) { + lodashStable.times(2, function(index) { + var array = (index ? largeArray : smallArray).slice(), + expected = array.slice().reverse(), + wrapped = _(array).chain().reverse().head(); + + assert.ok(wrapped instanceof _); + assert.strictEqual(wrapped.value(), _.head(expected)); + assert.deepEqual(array, expected); + }); + } + else { + skipAssert(assert, 6); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('round methods'); + + lodashStable.each(['ceil', 'floor', 'round'], function(methodName) { + var func = _[methodName], + isCeil = methodName == 'ceil', + isFloor = methodName == 'floor'; + + QUnit.test('`_.' + methodName + '` should return a rounded number without a precision', function(assert) { + assert.expect(1); + + var actual = func(4.006); + assert.strictEqual(actual, isCeil ? 5 : 4); + }); + + QUnit.test('`_.' + methodName + '` should work with a precision of `0`', function(assert) { + assert.expect(1); + + var actual = func(4.006, 0); + assert.strictEqual(actual, isCeil ? 5 : 4); + }); + + QUnit.test('`_.' + methodName + '` should work with a positive precision', function(assert) { + assert.expect(2); + + var actual = func(4.016, 2); + assert.strictEqual(actual, isFloor ? 4.01 : 4.02); + + actual = func(4.1, 2); + assert.strictEqual(actual, 4.1); + }); + + QUnit.test('`_.' + methodName + '` should work with a negative precision', function(assert) { + assert.expect(1); + + var actual = func(4160, -2); + assert.strictEqual(actual, isFloor ? 4100 : 4200); + }); + + QUnit.test('`_.' + methodName + '` should coerce `precision` to an integer', function(assert) { + assert.expect(3); + + var actual = func(4.006, NaN); + assert.strictEqual(actual, isCeil ? 5 : 4); + + var expected = isFloor ? 4.01 : 4.02; + + actual = func(4.016, 2.6); + assert.strictEqual(actual, expected); + + actual = func(4.016, '+2'); + assert.strictEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should work with exponential notation and `precision`', function(assert) { + assert.expect(3); + + var actual = func(5e1, 2); + assert.deepEqual(actual, 50); + + actual = func('5e', 1); + assert.deepEqual(actual, NaN); + + actual = func('5e1e1', 1); + assert.deepEqual(actual, NaN); + }); + + QUnit.test('`_.' + methodName + '` should preserve the sign of `0`', function(assert) { + assert.expect(1); + + var values = [[0], [-0], ['0'], ['-0'], [0, 1], [-0, 1], ['0', 1], ['-0', 1]], + expected = [Infinity, -Infinity, Infinity, -Infinity, Infinity, -Infinity, Infinity, -Infinity]; + + var actual = lodashStable.map(values, function(args) { + return 1 / func.apply(undefined, args); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should not return `NaN` for large `precision` values', function(assert) { + assert.expect(1); + + var results = [ + _.round(10.0000001, 1000), + _.round(MAX_SAFE_INTEGER, 293) + ]; + + var expected = lodashStable.map(results, stubFalse), + actual = lodashStable.map(results, lodashStable.isNaN); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should return `Infinity` given `Infinity` regardless of `precision`', function(assert) { + assert.expect(6); + + var actual = func(Infinity); + assert.strictEqual(actual, Infinity); + + actual = func(Infinity, 0); + assert.strictEqual(actual, Infinity); + + actual = func(Infinity, 2); + assert.strictEqual(actual, Infinity); + + actual = func(Infinity, -2); + assert.strictEqual(actual, Infinity); + + actual = func(Infinity, 2); + assert.strictEqual(actual, isFloor ? Infinity : Infinity); + + actual = func(Infinity, 2); + assert.strictEqual(actual, isCeil ? Infinity : Infinity); + }); + + QUnit.test('`_.' + methodName + '` should return `-Infinity` given `-Infinity` regardless of `precision`', function(assert) { + assert.expect(6); + + var actual = func(-Infinity); + assert.strictEqual(actual, -Infinity); + + actual = func(-Infinity, 0); + assert.strictEqual(actual, -Infinity); + + actual = func(-Infinity, 2); + assert.strictEqual(actual, -Infinity); + + actual = func(-Infinity, -2); + assert.strictEqual(actual, -Infinity); + + actual = func(-Infinity, 2); + assert.strictEqual(actual, isFloor ? -Infinity : -Infinity); + + actual = func(-Infinity, 2); + assert.strictEqual(actual, isCeil ? -Infinity : -Infinity); + }); + + QUnit.test('`_.' + methodName + '` should return `NaN` given `NaN` regardless of `precision`', function(assert) { + assert.expect(6); + + var actual = func(NaN); + assert.deepEqual(actual, NaN); + + actual = func(NaN, 0); + assert.deepEqual(actual, NaN); + + actual = func(NaN, 2); + assert.deepEqual(actual, NaN); + + actual = func(NaN, -2); + assert.deepEqual(actual, NaN); + + actual = func(NaN, 2); + assert.deepEqual(actual, isFloor ? NaN : NaN); + + actual = func(NaN, 2); + assert.deepEqual(actual, isCeil ? NaN : NaN); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.runInContext'); + + (function() { + QUnit.test('should not require a fully populated `context` object', function(assert) { + assert.expect(1); + + if (!isModularize) { + var lodash = _.runInContext({ + 'setTimeout': function(func) { func(); } + }); + + var pass = false; + lodash.delay(function() { pass = true; }, 32); + assert.ok(pass); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should use a zeroed `_.uniqueId` counter', function(assert) { + assert.expect(3); + + if (!isModularize) { + lodashStable.times(2, _.uniqueId); + + var oldId = Number(_.uniqueId()), + lodash = _.runInContext(); + + assert.ok(_.uniqueId() > oldId); + + var id = lodash.uniqueId(); + assert.strictEqual(id, '1'); + assert.ok(id < oldId); + } + else { + skipAssert(assert, 3); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.sample'); + + (function() { + var array = [1, 2, 3]; + + QUnit.test('should return a random element', function(assert) { + assert.expect(1); + + var actual = _.sample(array); + assert.ok(lodashStable.includes(array, actual)); + }); + + QUnit.test('should return `undefined` when sampling empty collections', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(empties, noop); + + var actual = lodashStable.transform(empties, function(result, value) { + try { + result.push(_.sample(value)); + } catch (e) {} + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should sample an object', function(assert) { + assert.expect(1); + + var object = { 'a': 1, 'b': 2, 'c': 3 }, + actual = _.sample(object); + + assert.ok(lodashStable.includes(array, actual)); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.sampleSize'); + + (function() { + var array = [1, 2, 3]; + + QUnit.test('should return an array of random elements', function(assert) { + assert.expect(2); + + var actual = _.sampleSize(array, 2); + + assert.strictEqual(actual.length, 2); + assert.deepEqual(lodashStable.difference(actual, array), []); + }); + + QUnit.test('should contain elements of the collection', function(assert) { + assert.expect(1); + + var actual = _.sampleSize(array, array.length).sort(); + + assert.deepEqual(actual, array); + }); + + QUnit.test('should treat falsey `size` values, except `undefined`, as `0`', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(falsey, function(value) { + return value === undefined ? ['a'] : []; + }); + + var actual = lodashStable.map(falsey, function(size, index) { + return index ? _.sampleSize(['a'], size) : _.sampleSize(['a']); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should return an empty array when `n` < `1` or `NaN`', function(assert) { + assert.expect(3); + + lodashStable.each([0, -1, -Infinity], function(n) { + assert.deepEqual(_.sampleSize(array, n), []); + }); + }); + + QUnit.test('should return all elements when `n` >= `length`', function(assert) { + assert.expect(4); + + lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(n) { + var actual = _.sampleSize(array, n).sort(); + assert.deepEqual(actual, array); + }); + }); + + QUnit.test('should coerce `n` to an integer', function(assert) { + assert.expect(1); + + var actual = _.sampleSize(array, 1.6); + assert.strictEqual(actual.length, 1); + }); + + QUnit.test('should return an empty array for empty collections', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(empties, stubArray); + + var actual = lodashStable.transform(empties, function(result, value) { + try { + result.push(_.sampleSize(value, 1)); + } catch (e) {} + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should sample an object', function(assert) { + assert.expect(2); + + var object = { 'a': 1, 'b': 2, 'c': 3 }, + actual = _.sampleSize(object, 2); + + assert.strictEqual(actual.length, 2); + assert.deepEqual(lodashStable.difference(actual, lodashStable.values(object)), []); + }); + + QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) { + assert.expect(1); + + var actual = lodashStable.map([['a']], _.sampleSize); + assert.deepEqual(actual, [['a']]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.setWith'); + + (function() { + QUnit.test('should work with a `customizer` callback', function(assert) { + assert.expect(1); + + var actual = _.setWith({ '0': {} }, '[0][1][2]', 3, function(value) { + return lodashStable.isObject(value) ? undefined : {}; + }); + + assert.deepEqual(actual, { '0': { '1': { '2': 3 } } }); + }); + + QUnit.test('should work with a `customizer` that returns `undefined`', function(assert) { + assert.expect(1); + + var actual = _.setWith({}, 'a[0].b.c', 4, noop); + assert.deepEqual(actual, { 'a': [{ 'b': { 'c': 4 } }] }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('set methods'); + + lodashStable.each(['update', 'updateWith', 'set', 'setWith'], function(methodName) { + var func = _[methodName], + isUpdate = /^update/.test(methodName); + + var oldValue = 1, + value = 2, + updater = isUpdate ? lodashStable.constant(value) : value; + + QUnit.test('`_.' + methodName + '` should set property values', function(assert) { + assert.expect(4); + + lodashStable.each(['a', ['a']], function(path) { + var object = { 'a': oldValue }, + actual = func(object, path, updater); + + assert.strictEqual(actual, object); + assert.strictEqual(object.a, value); + }); + }); + + QUnit.test('`_.' + methodName + '` should preserve the sign of `0`', function(assert) { + assert.expect(1); + + var props = [-0, Object(-0), 0, Object(0)], + expected = lodashStable.map(props, lodashStable.constant(value)); + + var actual = lodashStable.map(props, function(key) { + var object = { '-0': 'a', '0': 'b' }; + func(object, key, updater); + return object[lodashStable.toString(key)]; + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should unset symbol keyed property values', function(assert) { + assert.expect(2); + + if (Symbol) { + var object = {}; + object[symbol] = 1; + + assert.strictEqual(_.unset(object, symbol), true); + assert.notOk(symbol in object); + } + else { + skipAssert(assert, 2); + } + }); + + QUnit.test('`_.' + methodName + '` should set deep property values', function(assert) { + assert.expect(4); + + lodashStable.each(['a.b', ['a', 'b']], function(path) { + var object = { 'a': { 'b': oldValue } }, + actual = func(object, path, updater); + + assert.strictEqual(actual, object); + assert.strictEqual(object.a.b, value); + }); + }); + + QUnit.test('`_.' + methodName + '` should set a key over a path', function(assert) { + assert.expect(4); + + lodashStable.each(['a.b', ['a.b']], function(path) { + var object = { 'a.b': oldValue }, + actual = func(object, path, updater); + + assert.strictEqual(actual, object); + assert.deepEqual(object, { 'a.b': value }); + }); + }); + + QUnit.test('`_.' + methodName + '` should not coerce array paths to strings', function(assert) { + assert.expect(1); + + var object = { 'a,b,c': 1, 'a': { 'b': { 'c': 1 } } }; + + func(object, ['a', 'b', 'c'], updater); + assert.strictEqual(object.a.b.c, value); + }); + + QUnit.test('`_.' + methodName + '` should not ignore empty brackets', function(assert) { + assert.expect(1); + + var object = {}; + + func(object, 'a[]', updater); + assert.deepEqual(object, { 'a': { '': value } }); + }); + + QUnit.test('`_.' + methodName + '` should handle empty paths', function(assert) { + assert.expect(4); + + lodashStable.each([['', ''], [[], ['']]], function(pair, index) { + var object = {}; + + func(object, pair[0], updater); + assert.deepEqual(object, index ? {} : { '': value }); + + func(object, pair[1], updater); + assert.deepEqual(object, { '': value }); + }); + }); + + QUnit.test('`_.' + methodName + '` should handle complex paths', function(assert) { + assert.expect(2); + + var object = { 'a': { '1.23': { '["b"]': { 'c': { "['d']": { '\ne\n': { 'f': { 'g': oldValue } } } } } } } }; + + var paths = [ + 'a[-1.23]["[\\"b\\"]"].c[\'[\\\'d\\\']\'][\ne\n][f].g', + ['a', '-1.23', '["b"]', 'c', "['d']", '\ne\n', 'f', 'g'] + ]; + + lodashStable.each(paths, function(path) { + func(object, path, updater); + assert.strictEqual(object.a[-1.23]['["b"]'].c["['d']"]['\ne\n'].f.g, value); + object.a[-1.23]['["b"]'].c["['d']"]['\ne\n'].f.g = oldValue; + }); + }); + + QUnit.test('`_.' + methodName + '` should create parts of `path` that are missing', function(assert) { + assert.expect(6); + + var object = {}; + + lodashStable.each(['a[1].b.c', ['a', '1', 'b', 'c']], function(path) { + var actual = func(object, path, updater); + + assert.strictEqual(actual, object); + assert.deepEqual(actual, { 'a': [undefined, { 'b': { 'c': value } }] }); + assert.notOk('0' in object.a); + + delete object.a; + }); + }); + + QUnit.test('`_.' + methodName + '` should not error when `object` is nullish', function(assert) { + assert.expect(1); + + var values = [null, undefined], + expected = [[null, null], [undefined, undefined]]; + + var actual = lodashStable.map(values, function(value) { + try { + return [func(value, 'a.b', updater), func(value, ['a', 'b'], updater)]; + } catch (e) { + return e.message; + } + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should overwrite primitives in the path', function(assert) { + assert.expect(2); + + lodashStable.each(['a.b', ['a', 'b']], function(path) { + var object = { 'a': '' }; + + func(object, path, updater); + assert.deepEqual(object, { 'a': { 'b': 2 } }); + });; + }); + + QUnit.test('`_.' + methodName + '` should not create an array for missing non-index property names that start with numbers', function(assert) { + assert.expect(1); + + var object = {}; + + func(object, ['1a', '2b', '3c'], updater); + assert.deepEqual(object, { '1a': { '2b': { '3c': value } } }); + }); + + QUnit.test('`_.' + methodName + '` should not assign values that are the same as their destinations', function(assert) { + assert.expect(4); + + lodashStable.each(['a', ['a'], { 'a': 1 }, NaN], function(value) { + var object = {}, + pass = true, + updater = isUpdate ? lodashStable.constant(value) : value; + + defineProperty(object, 'a', { + 'configurable': true, + 'enumerable': true, + 'get': lodashStable.constant(value), + 'set': function() { pass = false; } + }); + + func(object, 'a', updater); + assert.ok(pass); + }); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.shuffle'); + + (function() { + var array = [1, 2, 3], + object = { 'a': 1, 'b': 2, 'c': 3 }; + + QUnit.test('should return a new array', function(assert) { + assert.expect(1); + + assert.notStrictEqual(_.shuffle(array), array); + }); + + QUnit.test('should contain the same elements after a collection is shuffled', function(assert) { + assert.expect(2); + + assert.deepEqual(_.shuffle(array).sort(), array); + assert.deepEqual(_.shuffle(object).sort(), array); + }); + + QUnit.test('should shuffle small collections', function(assert) { + assert.expect(1); + + var actual = lodashStable.times(1000, function(assert) { + return _.shuffle([1, 2]); + }); + + assert.deepEqual(lodashStable.sortBy(lodashStable.uniqBy(actual, String), '0'), [[1, 2], [2, 1]]); + }); + + QUnit.test('should treat number values for `collection` as empty', function(assert) { + assert.expect(1); + + assert.deepEqual(_.shuffle(1), []); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.size'); + + (function() { + var array = [1, 2, 3]; + + QUnit.test('should return the number of own enumerable string keyed properties of an object', function(assert) { + assert.expect(1); + + assert.strictEqual(_.size({ 'one': 1, 'two': 2, 'three': 3 }), 3); + }); + + QUnit.test('should return the length of an array', function(assert) { + assert.expect(1); + + assert.strictEqual(_.size(array), 3); + }); + + QUnit.test('should accept a falsey `object`', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(falsey, stubZero); + + var actual = lodashStable.map(falsey, function(object, index) { + try { + return index ? _.size(object) : _.size(); + } catch (e) {} + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should work with `arguments` objects', function(assert) { + assert.expect(1); + + assert.strictEqual(_.size(args), 3); + }); + + QUnit.test('should work with jQuery/MooTools DOM query collections', function(assert) { + assert.expect(1); + + function Foo(elements) { + push.apply(this, elements); + } + Foo.prototype = { 'length': 0, 'splice': arrayProto.splice }; + + assert.strictEqual(_.size(new Foo(array)), 3); + }); + + QUnit.test('should work with maps', function(assert) { + assert.expect(2); + + if (Map) { + lodashStable.each([new Map, realm.map], function(map) { + map.set('a', 1); + map.set('b', 2); + assert.strictEqual(_.size(map), 2); + map.clear(); + }); + } + else { + skipAssert(assert, 2); + } + }); + + QUnit.test('should work with sets', function(assert) { + assert.expect(2); + + if (Set) { + lodashStable.each([new Set, realm.set], function(set) { + set.add(1); + set.add(2); + assert.strictEqual(_.size(set), 2); + set.clear(); + }); + } + else { + skipAssert(assert, 2); + } + }); + + QUnit.test('should not treat objects with negative lengths as array-like', function(assert) { + assert.expect(1); + + assert.strictEqual(_.size({ 'length': -1 }), 1); + }); + + QUnit.test('should not treat objects with lengths larger than `MAX_SAFE_INTEGER` as array-like', function(assert) { + assert.expect(1); + + assert.strictEqual(_.size({ 'length': MAX_SAFE_INTEGER + 1 }), 1); + }); + + QUnit.test('should not treat objects with non-number lengths as array-like', function(assert) { + assert.expect(1); + + assert.strictEqual(_.size({ 'length': '0' }), 1); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.slice'); + + (function() { + var array = [1, 2, 3]; + + QUnit.test('should use a default `start` of `0` and a default `end` of `length`', function(assert) { + assert.expect(2); + + var actual = _.slice(array); + assert.deepEqual(actual, array); + assert.notStrictEqual(actual, array); + }); + + QUnit.test('should work with a positive `start`', function(assert) { + assert.expect(2); + + assert.deepEqual(_.slice(array, 1), [2, 3]); + assert.deepEqual(_.slice(array, 1, 3), [2, 3]); + }); + + QUnit.test('should work with a `start` >= `length`', function(assert) { + assert.expect(4); + + lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(start) { + assert.deepEqual(_.slice(array, start), []); + }); + }); + + QUnit.test('should treat falsey `start` values as `0`', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(falsey, lodashStable.constant(array)); + + var actual = lodashStable.map(falsey, function(start) { + return _.slice(array, start); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should work with a negative `start`', function(assert) { + assert.expect(1); + + assert.deepEqual(_.slice(array, -1), [3]); + }); + + QUnit.test('should work with a negative `start` <= negative `length`', function(assert) { + assert.expect(3); + + lodashStable.each([-3, -4, -Infinity], function(start) { + assert.deepEqual(_.slice(array, start), array); + }); + }); + + QUnit.test('should work with `start` >= `end`', function(assert) { + assert.expect(2); + + lodashStable.each([2, 3], function(start) { + assert.deepEqual(_.slice(array, start, 2), []); + }); + }); + + QUnit.test('should work with a positive `end`', function(assert) { + assert.expect(1); + + assert.deepEqual(_.slice(array, 0, 1), [1]); + }); + + QUnit.test('should work with a `end` >= `length`', function(assert) { + assert.expect(4); + + lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(end) { + assert.deepEqual(_.slice(array, 0, end), array); + }); + }); + + QUnit.test('should treat falsey `end` values, except `undefined`, as `0`', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(falsey, function(value) { + return value === undefined ? array : []; + }); + + var actual = lodashStable.map(falsey, function(end, index) { + return index ? _.slice(array, 0, end) : _.slice(array, 0); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should work with a negative `end`', function(assert) { + assert.expect(1); + + assert.deepEqual(_.slice(array, 0, -1), [1, 2]); + }); + + QUnit.test('should work with a negative `end` <= negative `length`', function(assert) { + assert.expect(3); + + lodashStable.each([-3, -4, -Infinity], function(end) { + assert.deepEqual(_.slice(array, 0, end), []); + }); + }); + + QUnit.test('should coerce `start` and `end` to integers', function(assert) { + assert.expect(1); + + var positions = [[0.1, 1.6], ['0', 1], [0, '1'], ['1'], [NaN, 1], [1, NaN]]; + + var actual = lodashStable.map(positions, function(pos) { + return _.slice.apply(_, [array].concat(pos)); + }); + + assert.deepEqual(actual, [[1], [1], [1], [2, 3], [1], []]); + }); + + QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) { + assert.expect(2); + + var array = [[1], [2, 3]], + actual = lodashStable.map(array, _.slice); + + assert.deepEqual(actual, array); + assert.notStrictEqual(actual, array); + }); + + QUnit.test('should work in a lazy sequence', function(assert) { + assert.expect(38); + + if (!isNpm) { + var array = lodashStable.range(1, LARGE_ARRAY_SIZE + 1), + length = array.length, + wrapped = _(array); + + lodashStable.each(['map', 'filter'], function(methodName) { + assert.deepEqual(wrapped[methodName]().slice(0, -1).value(), array.slice(0, -1)); + assert.deepEqual(wrapped[methodName]().slice(1).value(), array.slice(1)); + assert.deepEqual(wrapped[methodName]().slice(1, 3).value(), array.slice(1, 3)); + assert.deepEqual(wrapped[methodName]().slice(-1).value(), array.slice(-1)); + + assert.deepEqual(wrapped[methodName]().slice(length).value(), array.slice(length)); + assert.deepEqual(wrapped[methodName]().slice(3, 2).value(), array.slice(3, 2)); + assert.deepEqual(wrapped[methodName]().slice(0, -length).value(), array.slice(0, -length)); + assert.deepEqual(wrapped[methodName]().slice(0, null).value(), array.slice(0, null)); + + assert.deepEqual(wrapped[methodName]().slice(0, length).value(), array.slice(0, length)); + assert.deepEqual(wrapped[methodName]().slice(-length).value(), array.slice(-length)); + assert.deepEqual(wrapped[methodName]().slice(null).value(), array.slice(null)); + + assert.deepEqual(wrapped[methodName]().slice(0, 1).value(), array.slice(0, 1)); + assert.deepEqual(wrapped[methodName]().slice(NaN, '1').value(), array.slice(NaN, '1')); + + assert.deepEqual(wrapped[methodName]().slice(0.1, 1.1).value(), array.slice(0.1, 1.1)); + assert.deepEqual(wrapped[methodName]().slice('0', 1).value(), array.slice('0', 1)); + assert.deepEqual(wrapped[methodName]().slice(0, '1').value(), array.slice(0, '1')); + assert.deepEqual(wrapped[methodName]().slice('1').value(), array.slice('1')); + assert.deepEqual(wrapped[methodName]().slice(NaN, 1).value(), array.slice(NaN, 1)); + assert.deepEqual(wrapped[methodName]().slice(1, NaN).value(), array.slice(1, NaN)); + }); + } + else { + skipAssert(assert, 38); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.some'); + + (function() { + QUnit.test('should return `true` if `predicate` returns truthy for any element', function(assert) { + assert.expect(2); + + assert.strictEqual(_.some([false, 1, ''], identity), true); + assert.strictEqual(_.some([null, 'a', 0], identity), true); + }); + + QUnit.test('should return `false` for empty collections', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(empties, stubFalse); + + var actual = lodashStable.map(empties, function(value) { + try { + return _.some(value, identity); + } catch (e) {} + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should return `true` as soon as `predicate` returns truthy', function(assert) { + assert.expect(2); + + var count = 0; + + assert.strictEqual(_.some([null, true, null], function(value) { + count++; + return value; + }), true); + + assert.strictEqual(count, 2); + }); + + QUnit.test('should return `false` if `predicate` returns falsey for all elements', function(assert) { + assert.expect(2); + + assert.strictEqual(_.some([false, false, false], identity), false); + assert.strictEqual(_.some([null, 0, ''], identity), false); + }); + + QUnit.test('should use `_.identity` when `predicate` is nullish', function(assert) { + assert.expect(2); + + var values = [, null, undefined], + expected = lodashStable.map(values, stubFalse); + + var actual = lodashStable.map(values, function(value, index) { + var array = [0, 0]; + return index ? _.some(array, value) : _.some(array); + }); + + assert.deepEqual(actual, expected); + + expected = lodashStable.map(values, stubTrue); + actual = lodashStable.map(values, function(value, index) { + var array = [0, 1]; + return index ? _.some(array, value) : _.some(array); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should work with `_.property` shorthands', function(assert) { + assert.expect(2); + + var objects = [{ 'a': 0, 'b': 0 }, { 'a': 0, 'b': 1 }]; + assert.strictEqual(_.some(objects, 'a'), false); + assert.strictEqual(_.some(objects, 'b'), true); + }); + + QUnit.test('should work with `_.matches` shorthands', function(assert) { + assert.expect(2); + + var objects = [{ 'a': 0, 'b': 0 }, { 'a': 1, 'b': 1}]; + assert.strictEqual(_.some(objects, { 'a': 0 }), true); + assert.strictEqual(_.some(objects, { 'b': 2 }), false); + }); + + QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) { + assert.expect(1); + + var actual = lodashStable.map([[1]], _.some); + assert.deepEqual(actual, [true]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.sortBy'); + + (function() { + var objects = [ + { 'a': 'x', 'b': 3 }, + { 'a': 'y', 'b': 4 }, + { 'a': 'x', 'b': 1 }, + { 'a': 'y', 'b': 2 } + ]; + + QUnit.test('should sort in ascending order by `iteratee`', function(assert) { + assert.expect(1); + + var actual = lodashStable.map(_.sortBy(objects, function(object) { + return object.b; + }), 'b'); + + assert.deepEqual(actual, [1, 2, 3, 4]); + }); + + QUnit.test('should use `_.identity` when `iteratee` is nullish', function(assert) { + assert.expect(1); + + var array = [3, 2, 1], + values = [, null, undefined], + expected = lodashStable.map(values, lodashStable.constant([1, 2, 3])); + + var actual = lodashStable.map(values, function(value, index) { + return index ? _.sortBy(array, value) : _.sortBy(array); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should work with `_.property` shorthands', function(assert) { + assert.expect(1); + + var actual = lodashStable.map(_.sortBy(objects.concat(undefined), 'b'), 'b'); + assert.deepEqual(actual, [1, 2, 3, 4, undefined]); + }); + + QUnit.test('should work with an object for `collection`', function(assert) { + assert.expect(1); + + var actual = _.sortBy({ 'a': 1, 'b': 2, 'c': 3 }, Math.sin); + assert.deepEqual(actual, [3, 1, 2]); + }); + + QUnit.test('should move `NaN`, nullish, and symbol values to the end', function(assert) { + assert.expect(2); + + var symbol1 = Symbol ? Symbol('a') : null, + symbol2 = Symbol ? Symbol('b') : null, + array = [NaN, undefined, null, 4, symbol1, null, 1, symbol2, undefined, 3, NaN, 2], + expected = [1, 2, 3, 4, symbol1, symbol2, null, null, undefined, undefined, NaN, NaN]; + + assert.deepEqual(_.sortBy(array), expected); + + array = [NaN, undefined, symbol1, null, 'd', null, 'a', symbol2, undefined, 'c', NaN, 'b']; + expected = ['a', 'b', 'c', 'd', symbol1, symbol2, null, null, undefined, undefined, NaN, NaN]; + + assert.deepEqual(_.sortBy(array), expected); + }); + + QUnit.test('should treat number values for `collection` as empty', function(assert) { + assert.expect(1); + + assert.deepEqual(_.sortBy(1), []); + }); + + QUnit.test('should coerce arrays returned from `iteratee`', function(assert) { + assert.expect(1); + + var actual = _.sortBy(objects, function(object) { + var result = [object.a, object.b]; + result.toString = function() { return String(this[0]); }; + return result; + }); + + assert.deepEqual(actual, [objects[0], objects[2], objects[1], objects[3]]); + }); + + QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) { + assert.expect(1); + + var actual = lodashStable.map([[2, 1, 3], [3, 2, 1]], _.sortBy); + assert.deepEqual(actual, [[1, 2, 3], [1, 2, 3]]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('sortBy methods'); + + lodashStable.each(['orderBy', 'sortBy'], function(methodName) { + var func = _[methodName]; + + function Pair(a, b, c) { + this.a = a; + this.b = b; + this.c = c; + } + + var objects = [ + { 'a': 'x', 'b': 3 }, + { 'a': 'y', 'b': 4 }, + { 'a': 'x', 'b': 1 }, + { 'a': 'y', 'b': 2 } + ]; + + var stableArray = [ + new Pair(1, 1, 1), new Pair(1, 2, 1), + new Pair(1, 1, 1), new Pair(1, 2, 1), + new Pair(1, 3, 1), new Pair(1, 4, 1), + new Pair(1, 5, 1), new Pair(1, 6, 1), + new Pair(2, 1, 2), new Pair(2, 2, 2), + new Pair(2, 3, 2), new Pair(2, 4, 2), + new Pair(2, 5, 2), new Pair(2, 6, 2), + new Pair(undefined, 1, 1), new Pair(undefined, 2, 1), + new Pair(undefined, 3, 1), new Pair(undefined, 4, 1), + new Pair(undefined, 5, 1), new Pair(undefined, 6, 1) + ]; + + var stableObject = lodashStable.zipObject('abcdefghijklmnopqrst'.split(''), stableArray); + + QUnit.test('`_.' + methodName + '` should sort multiple properties in ascending order', function(assert) { + assert.expect(1); + + var actual = func(objects, ['a', 'b']); + assert.deepEqual(actual, [objects[2], objects[0], objects[3], objects[1]]); + }); + + QUnit.test('`_.' + methodName + '` should support iteratees', function(assert) { + assert.expect(1); + + var actual = func(objects, ['a', function(object) { return object.b; }]); + assert.deepEqual(actual, [objects[2], objects[0], objects[3], objects[1]]); + }); + + QUnit.test('`_.' + methodName + '` should perform a stable sort (test in IE > 8 and V8)', function(assert) { + assert.expect(2); + + lodashStable.each([stableArray, stableObject], function(value, index) { + var actual = func(value, ['a', 'c']); + assert.deepEqual(actual, stableArray, index ? 'object' : 'array'); + }); + }); + + QUnit.test('`_.' + methodName + '` should not error on nullish elements', function(assert) { + assert.expect(1); + + try { + var actual = func(objects.concat(null, undefined), ['a', 'b']); + } catch (e) {} + + assert.deepEqual(actual, [objects[2], objects[0], objects[3], objects[1], null, undefined]); + }); + + QUnit.test('`_.' + methodName + '` should work as an iteratee for methods like `_.reduce`', function(assert) { + assert.expect(3); + + var objects = [ + { 'a': 'x', '0': 3 }, + { 'a': 'y', '0': 4 }, + { 'a': 'x', '0': 1 }, + { 'a': 'y', '0': 2 } + ]; + + var funcs = [func, lodashStable.partialRight(func, 'bogus')]; + + lodashStable.each(['a', 0, [0]], function(props, index) { + var expected = lodashStable.map(funcs, lodashStable.constant( + index + ? [objects[2], objects[3], objects[0], objects[1]] + : [objects[0], objects[2], objects[1], objects[3]] + )); + + var actual = lodashStable.map(funcs, function(func) { + return lodashStable.reduce([props], func, objects); + }); + + assert.deepEqual(actual, expected); + }); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('sortedIndex methods'); + + lodashStable.each(['sortedIndex', 'sortedLastIndex'], function(methodName) { + var func = _[methodName], + isSortedIndex = methodName == 'sortedIndex'; + + QUnit.test('`_.' + methodName + '` should return the insert index', function(assert) { + assert.expect(1); + + var array = [30, 50], + values = [30, 40, 50], + expected = isSortedIndex ? [0, 1, 1] : [1, 1, 2]; + + var actual = lodashStable.map(values, function(value) { + return func(array, value); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should work with an array of strings', function(assert) { + assert.expect(1); + + var array = ['a', 'c'], + values = ['a', 'b', 'c'], + expected = isSortedIndex ? [0, 1, 1] : [1, 1, 2]; + + var actual = lodashStable.map(values, function(value) { + return func(array, value); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should accept a nullish `array` and a `value`', function(assert) { + assert.expect(1); + + var values = [null, undefined], + expected = lodashStable.map(values, lodashStable.constant([0, 0, 0])); + + var actual = lodashStable.map(values, function(array) { + return [func(array, 1), func(array, undefined), func(array, NaN)]; + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should align with `_.sortBy`', function(assert) { + assert.expect(12); + + var symbol1 = Symbol ? Symbol('a') : null, + symbol2 = Symbol ? Symbol('b') : null, + symbol3 = Symbol ? Symbol('c') : null, + expected = [1, '2', {}, symbol1, symbol2, null, undefined, NaN, NaN]; + + lodashStable.each([ + [NaN, symbol1, null, 1, '2', {}, symbol2, NaN, undefined], + ['2', null, 1, symbol1, NaN, {}, NaN, symbol2, undefined] + ], function(array) { + assert.deepEqual(_.sortBy(array), expected); + assert.strictEqual(func(expected, 3), 2); + assert.strictEqual(func(expected, symbol3), isSortedIndex ? 3 : (Symbol ? 5 : 6)); + assert.strictEqual(func(expected, null), isSortedIndex ? (Symbol ? 5 : 3) : 6); + assert.strictEqual(func(expected, undefined), isSortedIndex ? 6 : 7); + assert.strictEqual(func(expected, NaN), isSortedIndex ? 7 : 9); + }); + }); + + QUnit.test('`_.' + methodName + '` should align with `_.sortBy` for nulls', function(assert) { + assert.expect(3); + + var array = [null, null]; + + assert.strictEqual(func(array, null), isSortedIndex ? 0 : 2); + assert.strictEqual(func(array, 1), 0); + assert.strictEqual(func(array, 'a'), 0); + }); + + QUnit.test('`_.' + methodName + '` should align with `_.sortBy` for symbols', function(assert) { + assert.expect(3); + + var symbol1 = Symbol ? Symbol('a') : null, + symbol2 = Symbol ? Symbol('b') : null, + symbol3 = Symbol ? Symbol('c') : null, + array = [symbol1, symbol2]; + + assert.strictEqual(func(array, symbol3), isSortedIndex ? 0 : 2); + assert.strictEqual(func(array, 1), 0); + assert.strictEqual(func(array, 'a'), 0); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('sortedIndexBy methods'); + + lodashStable.each(['sortedIndexBy', 'sortedLastIndexBy'], function(methodName) { + var func = _[methodName], + isSortedIndexBy = methodName == 'sortedIndexBy'; + + QUnit.test('`_.' + methodName + '` should provide correct `iteratee` arguments', function(assert) { + assert.expect(1); + + var args; + + func([30, 50], 40, function(assert) { + args || (args = slice.call(arguments)); + }); + + assert.deepEqual(args, [40]); + }); + + QUnit.test('`_.' + methodName + '` should work with `_.property` shorthands', function(assert) { + assert.expect(1); + + var objects = [{ 'x': 30 }, { 'x': 50 }], + actual = func(objects, { 'x': 40 }, 'x'); + + assert.strictEqual(actual, 1); + }); + + QUnit.test('`_.' + methodName + '` should avoid calling iteratee when length is 0', function(assert) { + var objects = [], + iteratee = function() { + throw new Error; + }, + actual = func(objects, { 'x': 50 }, iteratee); + + assert.strictEqual(actual, 0); + }); + + QUnit.test('`_.' + methodName + '` should support arrays larger than `MAX_ARRAY_LENGTH / 2`', function(assert) { + assert.expect(12); + + lodashStable.each([Math.ceil(MAX_ARRAY_LENGTH / 2), MAX_ARRAY_LENGTH], function(length) { + var array = [], + values = [MAX_ARRAY_LENGTH, NaN, undefined]; + + array.length = length; + + lodashStable.each(values, function(value) { + var steps = 0; + + var actual = func(array, value, function(value) { + steps++; + return value; + }); + + var expected = (isSortedIndexBy ? !lodashStable.isNaN(value) : lodashStable.isFinite(value)) + ? 0 + : Math.min(length, MAX_ARRAY_INDEX); + + assert.ok(steps == 32 || steps == 33); + assert.strictEqual(actual, expected); + }); + }); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('sortedIndexOf methods'); + + lodashStable.each(['sortedIndexOf', 'sortedLastIndexOf'], function(methodName) { + var func = _[methodName], + isSortedIndexOf = methodName == 'sortedIndexOf'; + + QUnit.test('`_.' + methodName + '` should perform a binary search', function(assert) { + assert.expect(1); + + var sorted = [4, 4, 5, 5, 6, 6]; + assert.deepEqual(func(sorted, 5), isSortedIndexOf ? 2 : 3); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.sortedUniq'); + + (function() { + QUnit.test('should return unique values of a sorted array', function(assert) { + assert.expect(3); + + var expected = [1, 2, 3]; + + lodashStable.each([[1, 2, 3], [1, 1, 2, 2, 3], [1, 2, 3, 3, 3, 3, 3]], function(array) { + assert.deepEqual(_.sortedUniq(array), expected); + }); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.split'); + + (function() { + QUnit.test('should split a string by `separator`', function(assert) { + assert.expect(3); + + var string = 'abcde'; + assert.deepEqual(_.split(string, 'c'), ['ab', 'de']); + assert.deepEqual(_.split(string, /[bd]/), ['a', 'c', 'e']); + assert.deepEqual(_.split(string, '', 2), ['a', 'b']); + }); + + QUnit.test('should return an array containing an empty string for empty values', function(assert) { + assert.expect(1); + + var values = [, null, undefined, ''], + expected = lodashStable.map(values, lodashStable.constant([''])); + + var actual = lodashStable.map(values, function(value, index) { + return index ? _.split(value) : _.split(); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) { + assert.expect(1); + + var strings = ['abc', 'def', 'ghi'], + actual = lodashStable.map(strings, _.split); + + assert.deepEqual(actual, [['abc'], ['def'], ['ghi']]); + }); + + QUnit.test('should allow mixed string and array prototype methods', function(assert) { + assert.expect(1); + + if (!isNpm) { + var wrapped = _('abc'); + assert.strictEqual(wrapped.split('b').join(','), 'a,c'); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.spread'); + + (function() { + function fn(a, b, c) { + return slice.call(arguments); + } + + QUnit.test('should spread arguments to `func`', function(assert) { + assert.expect(2); + + var spread = _.spread(fn), + expected = [1, 2]; + + assert.deepEqual(spread([1, 2]), expected); + assert.deepEqual(spread([1, 2], 3), expected); + }); + + QUnit.test('should accept a falsey `array`', function(assert) { + assert.expect(1); + + var spread = _.spread(stubTrue), + expected = lodashStable.map(falsey, stubTrue); + + var actual = lodashStable.map(falsey, function(array, index) { + try { + return index ? spread(array) : spread(); + } catch (e) {} + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should work with `start`', function(assert) { + assert.expect(2); + + var spread = _.spread(fn, 1), + expected = [1, 2, 3]; + + assert.deepEqual(spread(1, [2, 3]), expected); + assert.deepEqual(spread(1, [2, 3], 4), expected); + }); + + QUnit.test('should treat `start` as `0` for negative or `NaN` values', function(assert) { + assert.expect(1); + + var values = [-1, NaN, 'a'], + expected = lodashStable.map(values, lodashStable.constant([1, 2])); + + var actual = lodashStable.map(values, function(value) { + var spread = _.spread(fn, value); + return spread([1, 2]); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should coerce `start` to an integer', function(assert) { + assert.expect(2); + + var spread = _.spread(fn, 1.6), + expected = [1, 2, 3]; + + assert.deepEqual(spread(1, [2, 3]), expected); + assert.deepEqual(spread(1, [2, 3], 4), expected); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.startCase'); + + (function() { + QUnit.test('should uppercase only the first character of each word', function(assert) { + assert.expect(3); + + assert.strictEqual(_.startCase('--foo-bar--'), 'Foo Bar'); + assert.strictEqual(_.startCase('fooBar'), 'Foo Bar'); + assert.strictEqual(_.startCase('__FOO_BAR__'), 'FOO BAR'); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.startsWith'); + + (function() { + var string = 'abc'; + + QUnit.test('should return `true` if a string starts with `target`', function(assert) { + assert.expect(1); + + assert.strictEqual(_.startsWith(string, 'a'), true); + }); + + QUnit.test('should return `false` if a string does not start with `target`', function(assert) { + assert.expect(1); + + assert.strictEqual(_.startsWith(string, 'b'), false); + }); + + QUnit.test('should work with a `position`', function(assert) { + assert.expect(1); + + assert.strictEqual(_.startsWith(string, 'b', 1), true); + }); + + QUnit.test('should work with `position` >= `length`', function(assert) { + assert.expect(4); + + lodashStable.each([3, 5, MAX_SAFE_INTEGER, Infinity], function(position) { + assert.strictEqual(_.startsWith(string, 'a', position), false); + }); + }); + + QUnit.test('should treat falsey `position` values as `0`', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(falsey, stubTrue); + + var actual = lodashStable.map(falsey, function(position) { + return _.startsWith(string, 'a', position); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should treat a negative `position` as `0`', function(assert) { + assert.expect(6); + + lodashStable.each([-1, -3, -Infinity], function(position) { + assert.strictEqual(_.startsWith(string, 'a', position), true); + assert.strictEqual(_.startsWith(string, 'b', position), false); + }); + }); + + QUnit.test('should coerce `position` to an integer', function(assert) { + assert.expect(1); + + assert.strictEqual(_.startsWith(string, 'bc', 1.2), true); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.startsWith and lodash.endsWith'); + + lodashStable.each(['startsWith', 'endsWith'], function(methodName) { + var func = _[methodName], + isStartsWith = methodName == 'startsWith'; + + var string = 'abc', + chr = isStartsWith ? 'a' : 'c'; + + QUnit.test('`_.' + methodName + '` should coerce `string` to a string', function(assert) { + assert.expect(2); + + assert.strictEqual(func(Object(string), chr), true); + assert.strictEqual(func({ 'toString': lodashStable.constant(string) }, chr), true); + }); + + QUnit.test('`_.' + methodName + '` should coerce `target` to a string', function(assert) { + assert.expect(2); + + assert.strictEqual(func(string, Object(chr)), true); + assert.strictEqual(func(string, { 'toString': lodashStable.constant(chr) }), true); + }); + + QUnit.test('`_.' + methodName + '` should coerce `position` to a number', function(assert) { + assert.expect(2); + + var position = isStartsWith ? 1 : 2; + + assert.strictEqual(func(string, 'b', Object(position)), true); + assert.strictEqual(func(string, 'b', { 'toString': lodashStable.constant(String(position)) }), true); + }); + + QUnit.test('should return `true` when `target` is an empty string regardless of `position`', function(assert) { + assert.expect(1); + + var positions = [-Infinity, NaN, -3, -1, 0, 1, 2, 3, 5, MAX_SAFE_INTEGER, Infinity]; + + assert.ok(lodashStable.every(positions, function(position) { + return func(string, '', position); + })); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('stub methods'); + + lodashStable.each(['noop', 'stubTrue', 'stubFalse', 'stubArray', 'stubObject', 'stubString'], function(methodName) { + var func = _[methodName]; + + var pair = ({ + 'stubArray': [[], 'an empty array'], + 'stubFalse': [false, '`false`'], + 'stubObject': [{}, 'an empty object'], + 'stubString': ['', 'an empty string'], + 'stubTrue': [true, '`true`'], + 'noop': [undefined, '`undefined`'] + })[methodName]; + + var values = Array(2).concat(empties, true, 1, 'a'), + expected = lodashStable.map(values, lodashStable.constant(pair[0])); + + QUnit.test('`_.' + methodName + '` should return ' + pair[1], function(assert) { + assert.expect(1); + + var actual = lodashStable.map(values, function(value, index) { + if (index < 2) { + return index ? func.call({}) : func(); + } + return func(value); + }); + + assert.deepEqual(actual, expected); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.subtract'); + + (function() { + QUnit.test('should subtract two numbers', function(assert) { + assert.expect(3); + + assert.strictEqual(_.subtract(6, 4), 2); + assert.strictEqual(_.subtract(-6, 4), -10); + assert.strictEqual(_.subtract(-6, -4), -2); + }); + + QUnit.test('should coerce arguments to numbers', function(assert) { + assert.expect(2); + + assert.strictEqual(_.subtract('6', '4'), 2); + assert.deepEqual(_.subtract('x', 'y'), NaN); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('math operator methods'); + + lodashStable.each(['add', 'divide', 'multiply', 'subtract'], function(methodName) { + var func = _[methodName], + isAddSub = methodName == 'add' || methodName == 'subtract'; + + QUnit.test('`_.' + methodName + '` should return `' + (isAddSub ? 0 : 1) + '` when no arguments are given', function(assert) { + assert.expect(1); + + assert.strictEqual(func(), isAddSub ? 0 : 1); + }); + + QUnit.test('`_.' + methodName + '` should work with only one defined argument', function(assert) { + assert.expect(3); + + assert.strictEqual(func(6), 6); + assert.strictEqual(func(6, undefined), 6); + assert.strictEqual(func(undefined, 4), 4); + }); + + QUnit.test('`_.' + methodName + '` should preserve the sign of `0`', function(assert) { + assert.expect(2); + + var values = [0, '0', -0, '-0'], + expected = [[0, Infinity], ['0', Infinity], [-0, -Infinity], ['-0', -Infinity]]; + + lodashStable.times(2, function(index) { + var actual = lodashStable.map(values, function(value) { + var result = index ? func(undefined, value) : func(value); + return [result, 1 / result]; + }); + + assert.deepEqual(actual, expected); + }); + }); + + QUnit.test('`_.' + methodName + '` should convert objects to `NaN`', function(assert) { + assert.expect(2); + + assert.deepEqual(func(0, {}), NaN); + assert.deepEqual(func({}, 0), NaN); + }); + + QUnit.test('`_.' + methodName + '` should convert symbols to `NaN`', function(assert) { + assert.expect(2); + + if (Symbol) { + assert.deepEqual(func(0, symbol), NaN); + assert.deepEqual(func(symbol, 0), NaN); + } + else { + skipAssert(assert, 2); + } + }); + + QUnit.test('`_.' + methodName + '` should return an unwrapped value when implicitly chaining', function(assert) { + assert.expect(1); + + if (!isNpm) { + var actual = _(1)[methodName](2); + assert.notOk(actual instanceof _); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.' + methodName + '` should return a wrapped value when explicitly chaining', function(assert) { + assert.expect(1); + + if (!isNpm) { + var actual = _(1).chain()[methodName](2); + assert.ok(actual instanceof _); + } + else { + skipAssert(assert); + } + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.sumBy'); + + (function() { + var array = [6, 4, 2], + objects = [{ 'a': 2 }, { 'a': 3 }, { 'a': 1 }]; + + QUnit.test('should work with an `iteratee`', function(assert) { + assert.expect(1); + + var actual = _.sumBy(objects, function(object) { + return object.a; + }); + + assert.deepEqual(actual, 6); + }); + + QUnit.test('should provide correct `iteratee` arguments', function(assert) { + assert.expect(1); + + var args; + + _.sumBy(array, function() { + args || (args = slice.call(arguments)); + }); + + assert.deepEqual(args, [6]); + }); + + QUnit.test('should work with `_.property` shorthands', function(assert) { + assert.expect(2); + + var arrays = [[2], [3], [1]]; + assert.strictEqual(_.sumBy(arrays, 0), 6); + assert.strictEqual(_.sumBy(objects, 'a'), 6); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('sum methods'); + + lodashStable.each(['sum', 'sumBy'], function(methodName) { + var array = [6, 4, 2], + func = _[methodName]; + + QUnit.test('`_.' + methodName + '` should return the sum of an array of numbers', function(assert) { + assert.expect(1); + + assert.strictEqual(func(array), 12); + }); + + QUnit.test('`_.' + methodName + '` should return `0` when passing empty `array` values', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(empties, stubZero); + + var actual = lodashStable.map(empties, function(value) { + return func(value); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should skip `undefined` values', function(assert) { + assert.expect(1); + + assert.strictEqual(func([1, undefined]), 1); + }); + + QUnit.test('`_.' + methodName + '` should not skip `NaN` values', function(assert) { + assert.expect(1); + + assert.deepEqual(func([1, NaN]), NaN); + }); + + QUnit.test('`_.' + methodName + '` should not coerce values to numbers', function(assert) { + assert.expect(1); + + assert.strictEqual(func(['1', '2']), '12'); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.tail'); + + (function() { + var array = [1, 2, 3]; + + QUnit.test('should accept a falsey `array`', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(falsey, stubArray); + + var actual = lodashStable.map(falsey, function(array, index) { + try { + return index ? _.tail(array) : _.tail(); + } catch (e) {} + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should exclude the first element', function(assert) { + assert.expect(1); + + assert.deepEqual(_.tail(array), [2, 3]); + }); + + QUnit.test('should return an empty when querying empty arrays', function(assert) { + assert.expect(1); + + assert.deepEqual(_.tail([]), []); + }); + + QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) { + assert.expect(1); + + var array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]], + actual = lodashStable.map(array, _.tail); + + assert.deepEqual(actual, [[2, 3], [5, 6], [8, 9]]); + }); + + QUnit.test('should work in a lazy sequence', function(assert) { + assert.expect(4); + + if (!isNpm) { + var array = lodashStable.range(LARGE_ARRAY_SIZE), + values = []; + + var actual = _(array).tail().filter(function(value) { + values.push(value); + return false; + }) + .value(); + + assert.deepEqual(actual, []); + assert.deepEqual(values, array.slice(1)); + + values = []; + + actual = _(array).filter(function(value) { + values.push(value); + return isEven(value); + }) + .tail() + .value(); + + assert.deepEqual(actual, _.tail(_.filter(array, isEven))); + assert.deepEqual(values, array); + } + else { + skipAssert(assert, 4); + } + }); + + QUnit.test('should not execute subsequent iteratees on an empty array in a lazy sequence', function(assert) { + assert.expect(4); + + if (!isNpm) { + var array = lodashStable.range(LARGE_ARRAY_SIZE), + iteratee = function() { pass = false; }, + pass = true, + actual = _(array).slice(0, 1).tail().map(iteratee).value(); + + assert.ok(pass); + assert.deepEqual(actual, []); + + pass = true; + actual = _(array).filter().slice(0, 1).tail().map(iteratee).value(); + + assert.ok(pass); + assert.deepEqual(actual, []); + } + else { + skipAssert(assert, 4); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.take'); + + (function() { + var array = [1, 2, 3]; + + QUnit.test('should take the first two elements', function(assert) { + assert.expect(1); + + assert.deepEqual(_.take(array, 2), [1, 2]); + }); + + QUnit.test('should treat falsey `n` values, except `undefined`, as `0`', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(falsey, function(value) { + return value === undefined ? [1] : []; + }); + + var actual = lodashStable.map(falsey, function(n) { + return _.take(array, n); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should return an empty array when `n` < `1`', function(assert) { + assert.expect(3); + + lodashStable.each([0, -1, -Infinity], function(n) { + assert.deepEqual(_.take(array, n), []); + }); + }); + + QUnit.test('should return all elements when `n` >= `length`', function(assert) { + assert.expect(4); + + lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(n) { + assert.deepEqual(_.take(array, n), array); + }); + }); + + QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) { + assert.expect(1); + + var array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]], + actual = lodashStable.map(array, _.take); + + assert.deepEqual(actual, [[1], [4], [7]]); + }); + + QUnit.test('should work in a lazy sequence', function(assert) { + assert.expect(6); + + if (!isNpm) { + var array = lodashStable.range(1, LARGE_ARRAY_SIZE + 1), + predicate = function(value) { values.push(value); return isEven(value); }, + values = [], + actual = _(array).take(2).take().value(); + + assert.deepEqual(actual, _.take(_.take(array, 2))); + + actual = _(array).filter(predicate).take(2).take().value(); + assert.deepEqual(values, [1, 2]); + assert.deepEqual(actual, _.take(_.take(_.filter(array, predicate), 2))); + + actual = _(array).take(6).takeRight(4).take(2).takeRight().value(); + assert.deepEqual(actual, _.takeRight(_.take(_.takeRight(_.take(array, 6), 4), 2))); + + values = []; + + actual = _(array).take(array.length - 1).filter(predicate).take(6).takeRight(4).take(2).takeRight().value(); + assert.deepEqual(values, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]); + assert.deepEqual(actual, _.takeRight(_.take(_.takeRight(_.take(_.filter(_.take(array, array.length - 1), predicate), 6), 4), 2))); + } + else { + skipAssert(assert, 6); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.takeRight'); + + (function() { + var array = [1, 2, 3]; + + QUnit.test('should take the last two elements', function(assert) { + assert.expect(1); + + assert.deepEqual(_.takeRight(array, 2), [2, 3]); + }); + + QUnit.test('should treat falsey `n` values, except `undefined`, as `0`', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(falsey, function(value) { + return value === undefined ? [3] : []; + }); + + var actual = lodashStable.map(falsey, function(n) { + return _.takeRight(array, n); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should return an empty array when `n` < `1`', function(assert) { + assert.expect(3); + + lodashStable.each([0, -1, -Infinity], function(n) { + assert.deepEqual(_.takeRight(array, n), []); + }); + }); + + QUnit.test('should return all elements when `n` >= `length`', function(assert) { + assert.expect(4); + + lodashStable.each([3, 4, Math.pow(2, 32), Infinity], function(n) { + assert.deepEqual(_.takeRight(array, n), array); + }); + }); + + QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) { + assert.expect(1); + + var array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]], + actual = lodashStable.map(array, _.takeRight); + + assert.deepEqual(actual, [[3], [6], [9]]); + }); + + QUnit.test('should work in a lazy sequence', function(assert) { + assert.expect(6); + + if (!isNpm) { + var array = lodashStable.range(LARGE_ARRAY_SIZE), + predicate = function(value) { values.push(value); return isEven(value); }, + values = [], + actual = _(array).takeRight(2).takeRight().value(); + + assert.deepEqual(actual, _.takeRight(_.takeRight(array))); + + actual = _(array).filter(predicate).takeRight(2).takeRight().value(); + assert.deepEqual(values, array); + assert.deepEqual(actual, _.takeRight(_.takeRight(_.filter(array, predicate), 2))); + + actual = _(array).takeRight(6).take(4).takeRight(2).take().value(); + assert.deepEqual(actual, _.take(_.takeRight(_.take(_.takeRight(array, 6), 4), 2))); + + values = []; + + actual = _(array).filter(predicate).takeRight(6).take(4).takeRight(2).take().value(); + assert.deepEqual(values, array); + assert.deepEqual(actual, _.take(_.takeRight(_.take(_.takeRight(_.filter(array, predicate), 6), 4), 2))); + } + else { + skipAssert(assert, 6); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.takeRightWhile'); + + (function() { + var array = [1, 2, 3, 4]; + + var objects = [ + { 'a': 0, 'b': 0 }, + { 'a': 1, 'b': 1 }, + { 'a': 2, 'b': 2 } + ]; + + QUnit.test('should take elements while `predicate` returns truthy', function(assert) { + assert.expect(1); + + var actual = _.takeRightWhile(array, function(n) { + return n > 2; + }); + + assert.deepEqual(actual, [3, 4]); + }); + + QUnit.test('should provide correct `predicate` arguments', function(assert) { + assert.expect(1); + + var args; + + _.takeRightWhile(array, function() { + args = slice.call(arguments); + }); + + assert.deepEqual(args, [4, 3, array]); + }); + + QUnit.test('should work with `_.matches` shorthands', function(assert) { + assert.expect(1); + + assert.deepEqual(_.takeRightWhile(objects, { 'b': 2 }), objects.slice(2)); + }); + + QUnit.test('should work with `_.matchesProperty` shorthands', function(assert) { + assert.expect(1); + + assert.deepEqual(_.takeRightWhile(objects, ['b', 2]), objects.slice(2)); + }); + + QUnit.test('should work with `_.property` shorthands', function(assert) { + assert.expect(1); + + assert.deepEqual(_.takeRightWhile(objects, 'b'), objects.slice(1)); + }); + + QUnit.test('should work in a lazy sequence', function(assert) { + assert.expect(3); + + if (!isNpm) { + var array = lodashStable.range(LARGE_ARRAY_SIZE), + predicate = function(n) { return n > 2; }, + expected = _.takeRightWhile(array, predicate), + wrapped = _(array).takeRightWhile(predicate); + + assert.deepEqual(wrapped.value(), expected); + assert.deepEqual(wrapped.reverse().value(), expected.slice().reverse()); + assert.strictEqual(wrapped.last(), _.last(expected)); + } + else { + skipAssert(assert, 3); + } + }); + + QUnit.test('should provide correct `predicate` arguments in a lazy sequence', function(assert) { + assert.expect(5); + + if (!isNpm) { + var args, + array = lodashStable.range(LARGE_ARRAY_SIZE + 1); + + var expected = [ + square(LARGE_ARRAY_SIZE), + LARGE_ARRAY_SIZE - 1, + lodashStable.map(array.slice(1), square) + ]; + + _(array).slice(1).takeRightWhile(function(value, index, array) { + args = slice.call(arguments); + }).value(); + + assert.deepEqual(args, [LARGE_ARRAY_SIZE, LARGE_ARRAY_SIZE - 1, array.slice(1)]); + + _(array).slice(1).map(square).takeRightWhile(function(value, index, array) { + args = slice.call(arguments); + }).value(); + + assert.deepEqual(args, expected); + + _(array).slice(1).map(square).takeRightWhile(function(value, index) { + args = slice.call(arguments); + }).value(); + + assert.deepEqual(args, expected); + + _(array).slice(1).map(square).takeRightWhile(function(index) { + args = slice.call(arguments); + }).value(); + + assert.deepEqual(args, [square(LARGE_ARRAY_SIZE)]); + + _(array).slice(1).map(square).takeRightWhile(function() { + args = slice.call(arguments); + }).value(); + + assert.deepEqual(args, expected); + } + else { + skipAssert(assert, 5); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.takeWhile'); + + (function() { + var array = [1, 2, 3, 4]; + + var objects = [ + { 'a': 2, 'b': 2 }, + { 'a': 1, 'b': 1 }, + { 'a': 0, 'b': 0 } + ]; + + QUnit.test('should take elements while `predicate` returns truthy', function(assert) { + assert.expect(1); + + var actual = _.takeWhile(array, function(n) { + return n < 3; + }); + + assert.deepEqual(actual, [1, 2]); + }); + + QUnit.test('should provide correct `predicate` arguments', function(assert) { + assert.expect(1); + + var args; + + _.takeWhile(array, function() { + args = slice.call(arguments); + }); + + assert.deepEqual(args, [1, 0, array]); + }); + + QUnit.test('should work with `_.matches` shorthands', function(assert) { + assert.expect(1); + + assert.deepEqual(_.takeWhile(objects, { 'b': 2 }), objects.slice(0, 1)); + }); + + QUnit.test('should work with `_.matchesProperty` shorthands', function(assert) { + assert.expect(1); + + assert.deepEqual(_.takeWhile(objects, ['b', 2]), objects.slice(0, 1)); + }); + QUnit.test('should work with `_.property` shorthands', function(assert) { + assert.expect(1); + + assert.deepEqual(_.takeWhile(objects, 'b'), objects.slice(0, 2)); + }); + + QUnit.test('should work in a lazy sequence', function(assert) { + assert.expect(3); + + if (!isNpm) { + var array = lodashStable.range(LARGE_ARRAY_SIZE), + predicate = function(n) { return n < 3; }, + expected = _.takeWhile(array, predicate), + wrapped = _(array).takeWhile(predicate); + + assert.deepEqual(wrapped.value(), expected); + assert.deepEqual(wrapped.reverse().value(), expected.slice().reverse()); + assert.strictEqual(wrapped.last(), _.last(expected)); + } + else { + skipAssert(assert, 3); + } + }); + + QUnit.test('should work in a lazy sequence with `take`', function(assert) { + assert.expect(1); + + if (!isNpm) { + var array = lodashStable.range(LARGE_ARRAY_SIZE); + + var actual = _(array) + .takeWhile(function(n) { return n < 4; }) + .take(2) + .takeWhile(function(n) { return n == 0; }) + .value(); + + assert.deepEqual(actual, [0]); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should provide correct `predicate` arguments in a lazy sequence', function(assert) { + assert.expect(5); + + if (!isNpm) { + var args, + array = lodashStable.range(LARGE_ARRAY_SIZE + 1), + expected = [1, 0, lodashStable.map(array.slice(1), square)]; + + _(array).slice(1).takeWhile(function(value, index, array) { + args = slice.call(arguments); + }).value(); + + assert.deepEqual(args, [1, 0, array.slice(1)]); + + _(array).slice(1).map(square).takeWhile(function(value, index, array) { + args = slice.call(arguments); + }).value(); + + assert.deepEqual(args, expected); + + _(array).slice(1).map(square).takeWhile(function(value, index) { + args = slice.call(arguments); + }).value(); + + assert.deepEqual(args, expected); + + _(array).slice(1).map(square).takeWhile(function(value) { + args = slice.call(arguments); + }).value(); + + assert.deepEqual(args, [1]); + + _(array).slice(1).map(square).takeWhile(function() { + args = slice.call(arguments); + }).value(); + + assert.deepEqual(args, expected); + } + else { + skipAssert(assert, 5); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.tap'); + + (function() { + QUnit.test('should intercept and return the given value', function(assert) { + assert.expect(2); + + if (!isNpm) { + var intercepted, + array = [1, 2, 3]; + + var actual = _.tap(array, function(value) { + intercepted = value; + }); + + assert.strictEqual(actual, array); + assert.strictEqual(intercepted, array); + } + else { + skipAssert(assert, 2); + } + }); + + QUnit.test('should intercept unwrapped values and return wrapped values when chaining', function(assert) { + assert.expect(2); + + if (!isNpm) { + var intercepted, + array = [1, 2, 3]; + + var wrapped = _(array).tap(function(value) { + intercepted = value; + value.pop(); + }); + + assert.ok(wrapped instanceof _); + + wrapped.value(); + assert.strictEqual(intercepted, array); + } + else { + skipAssert(assert, 2); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.template'); + + (function() { + QUnit.test('should escape values in "escape" delimiters', function(assert) { + assert.expect(1); + + var strings = ['

<%- value %>

', '

<%-value%>

', '

<%-\nvalue\n%>

'], + expected = lodashStable.map(strings, lodashStable.constant('

&<>"'/

')), + data = { 'value': '&<>"\'/' }; + + var actual = lodashStable.map(strings, function(string) { + return _.template(string)(data); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should not reference `_.escape` when "escape" delimiters are not used', function(assert) { + assert.expect(1); + + var compiled = _.template('<%= typeof __e %>'); + assert.strictEqual(compiled({}), 'undefined'); + }); + + QUnit.test('should evaluate JavaScript in "evaluate" delimiters', function(assert) { + assert.expect(1); + + var compiled = _.template( + '

<%= collection[key] %>

' + ); + + var data = { 'collection': { 'a': 'A', 'b': 'B' } }, + actual = compiled(data); + + assert.strictEqual(actual, '

'); + }); + + QUnit.test('should support "evaluate" delimiters with single line comments (test production builds)', function(assert) { + assert.expect(1); + + var compiled = _.template('<% // A code comment. %><% if (value) { %>yap<% } else { %>nope<% } %>'), + data = { 'value': true }; + + assert.strictEqual(compiled(data), 'yap'); + }); + + QUnit.test('should support referencing variables declared in "evaluate" delimiters from other delimiters', function(assert) { + assert.expect(1); + + var compiled = _.template('<% var b = a; %><%= b.value %>'), + data = { 'a': { 'value': 1 } }; + + assert.strictEqual(compiled(data), '1'); + }); + + QUnit.test('should interpolate data properties in "interpolate" delimiters', function(assert) { + assert.expect(1); + + var strings = ['<%= a %>BC', '<%=a%>BC', '<%=\na\n%>BC'], + expected = lodashStable.map(strings, lodashStable.constant('ABC')), + data = { 'a': 'A' }; + + var actual = lodashStable.map(strings, function(string) { + return _.template(string)(data); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should support "interpolate" delimiters with escaped values', function(assert) { + assert.expect(1); + + var compiled = _.template('<%= a ? "a=\\"A\\"" : "" %>'), + data = { 'a': true }; + + assert.strictEqual(compiled(data), 'a="A"'); + }); + + QUnit.test('should support "interpolate" delimiters containing ternary operators', function(assert) { + assert.expect(1); + + var compiled = _.template('<%= value ? value : "b" %>'), + data = { 'value': 'a' }; + + assert.strictEqual(compiled(data), 'a'); + }); + + QUnit.test('should support "interpolate" delimiters containing global values', function(assert) { + assert.expect(1); + + var compiled = _.template('<%= typeof Math.abs %>'); + + try { + var actual = compiled(); + } catch (e) {} + + assert.strictEqual(actual, 'function'); + }); + + QUnit.test('should support complex "interpolate" delimiters', function(assert) { + assert.expect(22); + + lodashStable.forOwn({ + '<%= a + b %>': '3', + '<%= b - a %>': '1', + '<%= a = b %>': '2', + '<%= !a %>': 'false', + '<%= ~a %>': '-2', + '<%= a * b %>': '2', + '<%= a / b %>': '0.5', + '<%= a % b %>': '1', + '<%= a >> b %>': '0', + '<%= a << b %>': '4', + '<%= a & b %>': '0', + '<%= a ^ b %>': '3', + '<%= a | b %>': '3', + '<%= {}.toString.call(0) %>': numberTag, + '<%= a.toFixed(2) %>': '1.00', + '<%= obj["a"] %>': '1', + '<%= delete a %>': 'true', + '<%= "a" in obj %>': 'true', + '<%= obj instanceof Object %>': 'true', + '<%= new Boolean %>': 'false', + '<%= typeof a %>': 'number', + '<%= void a %>': '' + }, + function(value, key) { + var compiled = _.template(key), + data = { 'a': 1, 'b': 2 }; + + assert.strictEqual(compiled(data), value, key); + }); + }); + + QUnit.test('should support ES6 template delimiters', function(assert) { + assert.expect(2); + + var data = { 'value': 2 }; + assert.strictEqual(_.template('1${value}3')(data), '123'); + assert.strictEqual(_.template('${"{" + value + "\\}"}')(data), '{2}'); + }); + + QUnit.test('should support the "imports" option', function(assert) { + assert.expect(1); + + var compiled = _.template('<%= a %>', { 'imports': { 'a': 1 } }); + assert.strictEqual(compiled({}), '1'); + }); + + QUnit.test('should support the "variable" options', function(assert) { + assert.expect(1); + + var compiled = _.template( + '<% _.each( data.a, function( value ) { %>' + + '<%= value.valueOf() %>' + + '<% }) %>', { 'variable': 'data' } + ); + + var data = { 'a': [1, 2, 3] }; + + try { + assert.strictEqual(compiled(data), '123'); + } catch (e) { + assert.ok(false, e.message); + } + }); + + QUnit.test('should forbid code injection through the "variable" options', function(assert) { + assert.expect(1); + + assert.raises(function () { + _.template('', { 'variable': '){console.log(process.env)}; with(obj' }); + }); + }); + + QUnit.test('should support custom delimiters', function(assert) { + assert.expect(2); + + lodashStable.times(2, function(index) { + var settingsClone = lodashStable.clone(_.templateSettings); + + var settings = lodashStable.assign(index ? _.templateSettings : {}, { + 'escape': /\{\{-([\s\S]+?)\}\}/g, + 'evaluate': /\{\{([\s\S]+?)\}\}/g, + 'interpolate': /\{\{=([\s\S]+?)\}\}/g + }); + + var expected = '

0: a & A
1: b & B

', + compiled = _.template('

{{= index }}: {{- value }}

', index ? null : settings), + data = { 'collection': ['a & A', 'b & B'] }; + + assert.strictEqual(compiled(data), expected); + lodashStable.assign(_.templateSettings, settingsClone); + }); + }); + + QUnit.test('should support custom delimiters containing special characters', function(assert) { + assert.expect(2); + + lodashStable.times(2, function(index) { + var settingsClone = lodashStable.clone(_.templateSettings); + + var settings = lodashStable.assign(index ? _.templateSettings : {}, { + 'escape': /<\?-([\s\S]+?)\?>/g, + 'evaluate': /<\?([\s\S]+?)\?>/g, + 'interpolate': /<\?=([\s\S]+?)\?>/g + }); + + var expected = '

0: a & A
1: b & B

', + compiled = _.template('

', index ? null : settings), + data = { 'collection': ['a & A', 'b & B'] }; + + assert.strictEqual(compiled(data), expected); + lodashStable.assign(_.templateSettings, settingsClone); + }); + }); + + QUnit.test('should use a `with` statement by default', function(assert) { + assert.expect(1); + + var compiled = _.template('<%= index %><%= collection[index] %><% _.each(collection, function(value, index) { %><%= index %><% }); %>'), + actual = compiled({ 'index': 1, 'collection': ['a', 'b', 'c'] }); + + assert.strictEqual(actual, '1b012'); + }); + + QUnit.test('should use `_.templateSettings.imports._.templateSettings`', function(assert) { + assert.expect(1); + + var lodash = _.templateSettings.imports._, + settingsClone = lodashStable.clone(lodash.templateSettings); + + lodash.templateSettings = lodashStable.assign(lodash.templateSettings, { + 'interpolate': /\{\{=([\s\S]+?)\}\}/g + }); + + var compiled = _.template('{{= a }}'); + assert.strictEqual(compiled({ 'a': 1 }), '1'); + + if (settingsClone) { + lodashStable.assign(lodash.templateSettings, settingsClone); + } else { + delete lodash.templateSettings; + } + }); + + QUnit.test('should fallback to `_.templateSettings`', function(assert) { + assert.expect(1); + + var lodash = _.templateSettings.imports._, + delimiter = _.templateSettings.interpolate; + + _.templateSettings.imports._ = { 'escape': lodashStable.escape }; + _.templateSettings.interpolate = /\{\{=([\s\S]+?)\}\}/g; + + var compiled = _.template('{{= a }}'); + assert.strictEqual(compiled({ 'a': 1 }), '1'); + + _.templateSettings.imports._ = lodash; + _.templateSettings.interpolate = delimiter; + }); + + QUnit.test('should ignore `null` delimiters', function(assert) { + assert.expect(3); + + var delimiter = { + 'escape': /\{\{-([\s\S]+?)\}\}/g, + 'evaluate': /\{\{([\s\S]+?)\}\}/g, + 'interpolate': /\{\{=([\s\S]+?)\}\}/g + }; + + lodashStable.forOwn({ + 'escape': '{{- a }}', + 'evaluate': '{{ print(a) }}', + 'interpolate': '{{= a }}' + }, + function(value, key) { + var settings = { 'escape': null, 'evaluate': null, 'interpolate': null }; + settings[key] = delimiter[key]; + + var expected = '1 <%- a %> <% print(a) %> <%= a %>', + compiled = _.template(value + ' <%- a %> <% print(a) %> <%= a %>', settings), + data = { 'a': 1 }; + + assert.strictEqual(compiled(data), expected); + }); + }); + + QUnit.test('should work without delimiters', function(assert) { + assert.expect(1); + + var expected = 'abc'; + assert.strictEqual(_.template(expected)({}), expected); + }); + + QUnit.test('should work with `this` references', function(assert) { + assert.expect(2); + + var compiled = _.template('a<%= this.String("b") %>c'); + assert.strictEqual(compiled(), 'abc'); + + var object = { 'b': 'B' }; + object.compiled = _.template('A<%= this.b %>C', { 'variable': 'obj' }); + assert.strictEqual(object.compiled(), 'ABC'); + }); + + QUnit.test('should work with backslashes', function(assert) { + assert.expect(1); + + var compiled = _.template('<%= a %> \\b'), + data = { 'a': 'A' }; + + assert.strictEqual(compiled(data), 'A \\b'); + }); + + QUnit.test('should work with escaped characters in string literals', function(assert) { + assert.expect(2); + + var compiled = _.template('<% print("\'\\n\\r\\t\\u2028\\u2029\\\\") %>'); + assert.strictEqual(compiled(), "'\n\r\t\u2028\u2029\\"); + + var data = { 'a': 'A' }; + compiled = _.template('\'\n\r\t<%= a %>\u2028\u2029\\"'); + assert.strictEqual(compiled(data), '\'\n\r\tA\u2028\u2029\\"'); + }); + + QUnit.test('should handle \\u2028 & \\u2029 characters', function(assert) { + assert.expect(1); + + var compiled = _.template('\u2028<%= "\\u2028\\u2029" %>\u2029'); + assert.strictEqual(compiled(), '\u2028\u2028\u2029\u2029'); + }); + + QUnit.test('should work with statements containing quotes', function(assert) { + assert.expect(1); + + var compiled = _.template("<%\ + if (a == 'A' || a == \"a\") {\ + %>'a',\"A\"<%\ + } %>" + ); + + var data = { 'a': 'A' }; + assert.strictEqual(compiled(data), "'a',\"A\""); + }); + + QUnit.test('should work with templates containing newlines and comments', function(assert) { + assert.expect(1); + + var compiled = _.template('<%\n\ + // A code comment.\n\ + if (value) { value += 3; }\n\ + %>

<%= value %>

' + ); + + assert.strictEqual(compiled({ 'value': 3 }), '

'); + }); + + QUnit.test('should tokenize delimiters', function(assert) { + assert.expect(1); + + var compiled = _.template(''), + data = { 'type': 1 }; + + assert.strictEqual(compiled(data), ''); + }); + + QUnit.test('should evaluate delimiters once', function(assert) { + assert.expect(1); + + var actual = [], + compiled = _.template('<%= func("a") %><%- func("b") %><% func("c") %>'), + data = { 'func': function(value) { actual.push(value); } }; + + compiled(data); + assert.deepEqual(actual, ['a', 'b', 'c']); + }); + + QUnit.test('should match delimiters before escaping text', function(assert) { + assert.expect(1); + + var compiled = _.template('<<\n a \n>>', { 'evaluate': /<<(.*?)>>/g }); + assert.strictEqual(compiled(), '<<\n a \n>>'); + }); + + QUnit.test('should resolve nullish values to an empty string', function(assert) { + assert.expect(3); + + var compiled = _.template('<%= a %><%- a %>'), + data = { 'a': null }; + + assert.strictEqual(compiled(data), ''); + + data = { 'a': undefined }; + assert.strictEqual(compiled(data), ''); + + data = { 'a': {} }; + compiled = _.template('<%= a.b %><%- a.b %>'); + assert.strictEqual(compiled(data), ''); + }); + + QUnit.test('should return an empty string for empty values', function(assert) { + assert.expect(1); + + var values = [, null, undefined, ''], + expected = lodashStable.map(values, stubString), + data = { 'a': 1 }; + + var actual = lodashStable.map(values, function(value, index) { + var compiled = index ? _.template(value) : _.template(); + return compiled(data); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should parse delimiters without newlines', function(assert) { + assert.expect(1); + + var expected = '<<\nprint("

" + (value ? "yes" : "no") + "

")\n>>', + compiled = _.template(expected, { 'evaluate': /<<(.+?)>>/g }), + data = { 'value': true }; + + assert.strictEqual(compiled(data), expected); + }); + + QUnit.test('should support recursive calls', function(assert) { + assert.expect(1); + + var compiled = _.template('<%= a %><% a = _.template(c)(obj) %><%= a %>'), + data = { 'a': 'A', 'b': 'B', 'c': '<%= b %>' }; + + assert.strictEqual(compiled(data), 'AB'); + }); + + QUnit.test('should coerce `text` to a string', function(assert) { + assert.expect(1); + + var object = { 'toString': lodashStable.constant('<%= a %>') }, + data = { 'a': 1 }; + + assert.strictEqual(_.template(object)(data), '1'); + }); + + QUnit.test('should not modify the `options` object', function(assert) { + assert.expect(1); + + var options = {}; + _.template('', options); + assert.deepEqual(options, {}); + }); + + QUnit.test('should not modify `_.templateSettings` when `options` are given', function(assert) { + assert.expect(2); + + var data = { 'a': 1 }; + + assert.notOk('a' in _.templateSettings); + _.template('', {}, data); + assert.notOk('a' in _.templateSettings); + + delete _.templateSettings.a; + }); + + QUnit.test('should not error for non-object `data` and `options` values', function(assert) { + assert.expect(2); + + _.template('')(1); + assert.ok(true, '`data` value'); + + _.template('', 1)(1); + assert.ok(true, '`options` value'); + }); + + QUnit.test('should expose the source on compiled templates', function(assert) { + assert.expect(1); + + var compiled = _.template('x'), + values = [String(compiled), compiled.source], + expected = lodashStable.map(values, stubTrue); + + var actual = lodashStable.map(values, function(value) { + return lodashStable.includes(value, '__p'); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should expose the source on SyntaxErrors', function(assert) { + assert.expect(1); + + try { + _.template('<% if x %>'); + } catch (e) { + var source = e.source; + } + assert.ok(lodashStable.includes(source, '__p')); + }); + + QUnit.test('should not include sourceURLs in the source', function(assert) { + assert.expect(1); + + var options = { 'sourceURL': '/a/b/c' }, + compiled = _.template('x', options), + values = [compiled.source, undefined]; + + try { + _.template('<% if x %>', options); + } catch (e) { + values[1] = e.source; + } + var expected = lodashStable.map(values, stubFalse); + + var actual = lodashStable.map(values, function(value) { + return lodashStable.includes(value, 'sourceURL'); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should not let a sourceURL inject code', function(assert) { + assert.expect(1); + + var actual, + expected = 'no error'; + try { + actual = _.template(expected, {'sourceURL': '\u2028\u2029\n!this would err if it was executed!'})(); + } catch (e) {} + + assert.equal(actual, expected); + }); + + QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) { + assert.expect(1); + + var array = ['<%= a %>', '<%- b %>', '<% print(c) %>'], + compiles = lodashStable.map(array, _.template), + data = { 'a': 'one', 'b': '"two"', 'c': 'three' }; + + var actual = lodashStable.map(compiles, function(compiled) { + return compiled(data); + }); + + assert.deepEqual(actual, ['one', '"two"', 'three']); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.truncate'); + + (function() { + var string = 'hi-diddly-ho there, neighborino'; + + QUnit.test('should use a default `length` of `30`', function(assert) { + assert.expect(1); + + assert.strictEqual(_.truncate(string), 'hi-diddly-ho there, neighbo...'); + }); + + QUnit.test('should not truncate if `string` is <= `length`', function(assert) { + assert.expect(2); + + assert.strictEqual(_.truncate(string, { 'length': string.length }), string); + assert.strictEqual(_.truncate(string, { 'length': string.length + 2 }), string); + }); + + QUnit.test('should truncate string the given length', function(assert) { + assert.expect(1); + + assert.strictEqual(_.truncate(string, { 'length': 24 }), 'hi-diddly-ho there, n...'); + }); + + QUnit.test('should support a `omission` option', function(assert) { + assert.expect(1); + + assert.strictEqual(_.truncate(string, { 'omission': ' [...]' }), 'hi-diddly-ho there, neig [...]'); + }); + + QUnit.test('should coerce nullish `omission` values to strings', function(assert) { + assert.expect(2); + + assert.strictEqual(_.truncate(string, { 'omission': null }), 'hi-diddly-ho there, neighbnull'); + assert.strictEqual(_.truncate(string, { 'omission': undefined }), 'hi-diddly-ho there, nundefined'); + }); + + QUnit.test('should support a `length` option', function(assert) { + assert.expect(1); + + assert.strictEqual(_.truncate(string, { 'length': 4 }), 'h...'); + }); + + QUnit.test('should support a `separator` option', function(assert) { + assert.expect(3); + + assert.strictEqual(_.truncate(string, { 'length': 24, 'separator': ' ' }), 'hi-diddly-ho there,...'); + assert.strictEqual(_.truncate(string, { 'length': 24, 'separator': /,? +/ }), 'hi-diddly-ho there...'); + assert.strictEqual(_.truncate(string, { 'length': 24, 'separator': /,? +/g }), 'hi-diddly-ho there...'); + }); + + QUnit.test('should treat negative `length` as `0`', function(assert) { + assert.expect(2); + + lodashStable.each([0, -2], function(length) { + assert.strictEqual(_.truncate(string, { 'length': length }), '...'); + }); + }); + + QUnit.test('should coerce `length` to an integer', function(assert) { + assert.expect(4); + + lodashStable.each(['', NaN, 4.6, '4'], function(length, index) { + var actual = index > 1 ? 'h...' : '...'; + assert.strictEqual(_.truncate(string, { 'length': { 'valueOf': lodashStable.constant(length) } }), actual); + }); + }); + + QUnit.test('should coerce `string` to a string', function(assert) { + assert.expect(2); + + assert.strictEqual(_.truncate(Object(string), { 'length': 4 }), 'h...'); + assert.strictEqual(_.truncate({ 'toString': lodashStable.constant(string) }, { 'length': 5 }), 'hi...'); + }); + + QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) { + assert.expect(1); + + var actual = lodashStable.map([string, string, string], _.truncate), + truncated = 'hi-diddly-ho there, neighbo...'; + + assert.deepEqual(actual, [truncated, truncated, truncated]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.throttle'); + + (function() { + QUnit.test('should throttle a function', function(assert) { + assert.expect(2); + + var done = assert.async(); + + var callCount = 0, + throttled = _.throttle(function() { callCount++; }, 32); + + throttled(); + throttled(); + throttled(); + + var lastCount = callCount; + assert.ok(callCount); + + setTimeout(function() { + assert.ok(callCount > lastCount); + done(); + }, 64); + }); + + QUnit.test('subsequent calls should return the result of the first call', function(assert) { + assert.expect(5); + + var done = assert.async(); + + var throttled = _.throttle(identity, 32), + results = [throttled('a'), throttled('b')]; + + assert.deepEqual(results, ['a', 'a']); + + setTimeout(function() { + var results = [throttled('c'), throttled('d')]; + assert.notEqual(results[0], 'a'); + assert.notStrictEqual(results[0], undefined); + + assert.notEqual(results[1], 'd'); + assert.notStrictEqual(results[1], undefined); + done(); + }, 64); + }); + + QUnit.test('should clear timeout when `func` is called', function(assert) { + assert.expect(1); + + var done = assert.async(); + + if (!isModularize) { + var callCount = 0, + dateCount = 0; + + var lodash = _.runInContext({ + 'Date': { + 'now': function() { + return ++dateCount == 5 ? Infinity : +new Date; + } + } + }); + + var throttled = lodash.throttle(function() { callCount++; }, 32); + + throttled(); + throttled(); + + setTimeout(function() { + assert.strictEqual(callCount, 2); + done(); + }, 64); + } + else { + skipAssert(assert); + done(); + } + }); + + QUnit.test('should not trigger a trailing call when invoked once', function(assert) { + assert.expect(2); + + var done = assert.async(); + + var callCount = 0, + throttled = _.throttle(function() { callCount++; }, 32); + + throttled(); + assert.strictEqual(callCount, 1); + + setTimeout(function() { + assert.strictEqual(callCount, 1); + done(); + }, 64); + }); + + lodashStable.times(2, function(index) { + QUnit.test('should trigger a call when invoked repeatedly' + (index ? ' and `leading` is `false`' : ''), function(assert) { + assert.expect(1); + + var done = assert.async(); + + var callCount = 0, + limit = (argv || isPhantom) ? 1000 : 320, + options = index ? { 'leading': false } : {}, + throttled = _.throttle(function() { callCount++; }, 32, options); + + var start = +new Date; + while ((new Date - start) < limit) { + throttled(); + } + var actual = callCount > 1; + setTimeout(function() { + assert.ok(actual); + done(); + }, 1); + }); + }); + + QUnit.test('should trigger a second throttled call as soon as possible', function(assert) { + assert.expect(3); + + var done = assert.async(); + + var callCount = 0; + + var throttled = _.throttle(function() { + callCount++; + }, 128, { 'leading': false }); + + throttled(); + + setTimeout(function() { + assert.strictEqual(callCount, 1); + throttled(); + }, 192); + + setTimeout(function() { + assert.strictEqual(callCount, 1); + }, 254); + + setTimeout(function() { + assert.strictEqual(callCount, 2); + done(); + }, 384); + }); + + QUnit.test('should apply default options', function(assert) { + assert.expect(2); + + var done = assert.async(); + + var callCount = 0, + throttled = _.throttle(function() { callCount++; }, 32, {}); + + throttled(); + throttled(); + assert.strictEqual(callCount, 1); + + setTimeout(function() { + assert.strictEqual(callCount, 2); + done(); + }, 128); + }); + + QUnit.test('should support a `leading` option', function(assert) { + assert.expect(2); + + var withLeading = _.throttle(identity, 32, { 'leading': true }); + assert.strictEqual(withLeading('a'), 'a'); + + var withoutLeading = _.throttle(identity, 32, { 'leading': false }); + assert.strictEqual(withoutLeading('a'), undefined); + }); + + QUnit.test('should support a `trailing` option', function(assert) { + assert.expect(6); + + var done = assert.async(); + + var withCount = 0, + withoutCount = 0; + + var withTrailing = _.throttle(function(value) { + withCount++; + return value; + }, 64, { 'trailing': true }); + + var withoutTrailing = _.throttle(function(value) { + withoutCount++; + return value; + }, 64, { 'trailing': false }); + + assert.strictEqual(withTrailing('a'), 'a'); + assert.strictEqual(withTrailing('b'), 'a'); + + assert.strictEqual(withoutTrailing('a'), 'a'); + assert.strictEqual(withoutTrailing('b'), 'a'); + + setTimeout(function() { + assert.strictEqual(withCount, 2); + assert.strictEqual(withoutCount, 1); + done(); + }, 256); + }); + + QUnit.test('should not update `lastCalled`, at the end of the timeout, when `trailing` is `false`', function(assert) { + assert.expect(1); + + var done = assert.async(); + + var callCount = 0; + + var throttled = _.throttle(function() { + callCount++; + }, 64, { 'trailing': false }); + + throttled(); + throttled(); + + setTimeout(function() { + throttled(); + throttled(); + }, 96); + + setTimeout(function() { + assert.ok(callCount > 1); + done(); + }, 192); + }); + + QUnit.test('should work with a system time of `0`', function(assert) { + assert.expect(3); + + var done = assert.async(); + + if (!isModularize) { + var callCount = 0, + dateCount = 0; + + var lodash = _.runInContext({ + 'Date': { + 'now': function() { + return ++dateCount < 4 ? 0 : +new Date; + } + } + }); + + var throttled = lodash.throttle(function(value) { + callCount++; + return value; + }, 32); + + var results = [throttled('a'), throttled('b'), throttled('c')]; + assert.deepEqual(results, ['a', 'a', 'a']); + assert.strictEqual(callCount, 1); + + setTimeout(function() { + assert.strictEqual(callCount, 2); + done(); + }, 64); + } + else { + skipAssert(assert, 3); + done(); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.debounce and lodash.throttle'); + + lodashStable.each(['debounce', 'throttle'], function(methodName) { + var func = _[methodName], + isDebounce = methodName == 'debounce'; + + QUnit.test('`_.' + methodName + '` should not error for non-object `options` values', function(assert) { + assert.expect(1); + + func(noop, 32, 1); + assert.ok(true); + }); + + QUnit.test('`_.' + methodName + '` should use a default `wait` of `0`', function(assert) { + assert.expect(1); + + var done = assert.async(); + + var callCount = 0, + funced = func(function() { callCount++; }); + + funced(); + + setTimeout(function() { + funced(); + assert.strictEqual(callCount, isDebounce ? 1 : 2); + done(); + }, 32); + }); + + QUnit.test('`_.' + methodName + '` should invoke `func` with the correct `this` binding', function(assert) { + assert.expect(1); + + var done = assert.async(); + + var actual = [], + object = { 'funced': func(function() { actual.push(this); }, 32) }, + expected = lodashStable.times(isDebounce ? 1 : 2, lodashStable.constant(object)); + + object.funced(); + if (!isDebounce) { + object.funced(); + } + setTimeout(function() { + assert.deepEqual(actual, expected); + done(); + }, 64); + }); + + QUnit.test('`_.' + methodName + '` supports recursive calls', function(assert) { + assert.expect(2); + + var done = assert.async(); + + var actual = [], + args = lodashStable.map(['a', 'b', 'c'], function(chr) { return [{}, chr]; }), + expected = args.slice(), + queue = args.slice(); + + var funced = func(function() { + var current = [this]; + push.apply(current, arguments); + actual.push(current); + + var next = queue.shift(); + if (next) { + funced.call(next[0], next[1]); + } + }, 32); + + var next = queue.shift(); + funced.call(next[0], next[1]); + assert.deepEqual(actual, expected.slice(0, isDebounce ? 0 : 1)); + + setTimeout(function() { + assert.deepEqual(actual, expected.slice(0, actual.length)); + done(); + }, 256); + }); + + QUnit.test('`_.' + methodName + '` should work if the system time is set backwards', function(assert) { + assert.expect(1); + + var done = assert.async(); + + if (!isModularize) { + var callCount = 0, + dateCount = 0; + + var lodash = _.runInContext({ + 'Date': { + 'now': function() { + return ++dateCount == 4 + ? +new Date(2012, 3, 23, 23, 27, 18) + : +new Date; + } + } + }); + + var funced = lodash[methodName](function() { + callCount++; + }, 32); + + funced(); + + setTimeout(function() { + funced(); + assert.strictEqual(callCount, isDebounce ? 1 : 2); + done(); + }, 64); + } + else { + skipAssert(assert); + done(); + } + }); + + QUnit.test('`_.' + methodName + '` should support cancelling delayed calls', function(assert) { + assert.expect(1); + + var done = assert.async(); + + var callCount = 0; + + var funced = func(function() { + callCount++; + }, 32, { 'leading': false }); + + funced(); + funced.cancel(); + + setTimeout(function() { + assert.strictEqual(callCount, 0); + done(); + }, 64); + }); + + QUnit.test('`_.' + methodName + '` should reset `lastCalled` after cancelling', function(assert) { + assert.expect(3); + + var done = assert.async(); + + var callCount = 0; + + var funced = func(function() { + return ++callCount; + }, 32, { 'leading': true }); + + assert.strictEqual(funced(), 1); + funced.cancel(); + + assert.strictEqual(funced(), 2); + funced(); + + setTimeout(function() { + assert.strictEqual(callCount, 3); + done(); + }, 64); + }); + + QUnit.test('`_.' + methodName + '` should support flushing delayed calls', function(assert) { + assert.expect(2); + + var done = assert.async(); + + var callCount = 0; + + var funced = func(function() { + return ++callCount; + }, 32, { 'leading': false }); + + funced(); + assert.strictEqual(funced.flush(), 1); + + setTimeout(function() { + assert.strictEqual(callCount, 1); + done(); + }, 64); + }); + + QUnit.test('`_.' + methodName + '` should noop `cancel` and `flush` when nothing is queued', function(assert) { + assert.expect(2); + + var done = assert.async(); + + var callCount = 0, + funced = func(function() { callCount++; }, 32); + + funced.cancel(); + assert.strictEqual(funced.flush(), undefined); + + setTimeout(function() { + assert.strictEqual(callCount, 0); + done(); + }, 64); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.times'); + + (function() { + QUnit.test('should coerce non-finite `n` values to `0`', function(assert) { + assert.expect(3); + + lodashStable.each([-Infinity, NaN, Infinity], function(n) { + assert.deepEqual(_.times(n), []); + }); + }); + + QUnit.test('should coerce `n` to an integer', function(assert) { + assert.expect(1); + + var actual = _.times(2.6, _.identity); + assert.deepEqual(actual, [0, 1]); + }); + + QUnit.test('should provide correct `iteratee` arguments', function(assert) { + assert.expect(1); + + var args; + + _.times(1, function(assert) { + args || (args = slice.call(arguments)); + }); + + assert.deepEqual(args, [0]); + }); + + QUnit.test('should use `_.identity` when `iteratee` is nullish', function(assert) { + assert.expect(1); + + var values = [, null, undefined], + expected = lodashStable.map(values, lodashStable.constant([0, 1, 2])); + + var actual = lodashStable.map(values, function(value, index) { + return index ? _.times(3, value) : _.times(3); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should return an array of the results of each `iteratee` execution', function(assert) { + assert.expect(1); + + assert.deepEqual(_.times(3, doubled), [0, 2, 4]); + }); + + QUnit.test('should return an empty array for falsey and negative `n` values', function(assert) { + assert.expect(1); + + var values = falsey.concat(-1, -Infinity), + expected = lodashStable.map(values, stubArray); + + var actual = lodashStable.map(values, function(value, index) { + return index ? _.times(value) : _.times(); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should return an unwrapped value when implicitly chaining', function(assert) { + assert.expect(1); + + if (!isNpm) { + assert.deepEqual(_(3).times(), [0, 1, 2]); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should return a wrapped value when explicitly chaining', function(assert) { + assert.expect(1); + + if (!isNpm) { + assert.ok(_(3).chain().times() instanceof _); + } + else { + skipAssert(assert); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.toArray'); + + (function() { + QUnit.test('should convert objects to arrays', function(assert) { + assert.expect(1); + + assert.deepEqual(_.toArray({ 'a': 1, 'b': 2 }), [1, 2]); + }); + + QUnit.test('should convert iterables to arrays', function(assert) { + assert.expect(1); + + if (Symbol && Symbol.iterator) { + var object = { '0': 'a', 'length': 1 }; + object[Symbol.iterator] = arrayProto[Symbol.iterator]; + + assert.deepEqual(_.toArray(object), ['a']); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should convert maps to arrays', function(assert) { + assert.expect(1); + + if (Map) { + var map = new Map; + map.set('a', 1); + map.set('b', 2); + assert.deepEqual(_.toArray(map), [['a', 1], ['b', 2]]); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should convert strings to arrays', function(assert) { + assert.expect(3); + + assert.deepEqual(_.toArray(''), []); + assert.deepEqual(_.toArray('ab'), ['a', 'b']); + assert.deepEqual(_.toArray(Object('ab')), ['a', 'b']); + }); + + QUnit.test('should work in a lazy sequence', function(assert) { + assert.expect(2); + + if (!isNpm) { + var array = lodashStable.range(LARGE_ARRAY_SIZE + 1); + + var object = lodashStable.zipObject(lodashStable.times(LARGE_ARRAY_SIZE, function(index) { + return ['key' + index, index]; + })); + + var actual = _(array).slice(1).map(String).toArray().value(); + assert.deepEqual(actual, lodashStable.map(array.slice(1), String)); + + actual = _(object).toArray().slice(1).map(String).value(); + assert.deepEqual(actual, _.map(_.toArray(object).slice(1), String)); + } + else { + skipAssert(assert, 2); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.toLower'); + + (function() { + QUnit.test('should convert whole string to lower case', function(assert) { + assert.expect(3); + + assert.deepEqual(_.toLower('--Foo-Bar--'), '--foo-bar--'); + assert.deepEqual(_.toLower('fooBar'), 'foobar'); + assert.deepEqual(_.toLower('__FOO_BAR__'), '__foo_bar__'); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.toUpper'); + + (function() { + QUnit.test('should convert whole string to upper case', function(assert) { + assert.expect(3); + + assert.deepEqual(_.toUpper('--Foo-Bar'), '--FOO-BAR'); + assert.deepEqual(_.toUpper('fooBar'), 'FOOBAR'); + assert.deepEqual(_.toUpper('__FOO_BAR__'), '__FOO_BAR__'); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.slice and lodash.toArray'); + + lodashStable.each(['slice', 'toArray'], function(methodName) { + var array = [1, 2, 3], + func = _[methodName]; + + QUnit.test('`_.' + methodName + '` should return a dense array', function(assert) { + assert.expect(3); + + var sparse = Array(3); + sparse[1] = 2; + + var actual = func(sparse); + + assert.ok('0' in actual); + assert.ok('2' in actual); + assert.deepEqual(actual, sparse); + }); + + QUnit.test('`_.' + methodName + '` should treat array-like objects like arrays', function(assert) { + assert.expect(2); + + var object = { '0': 'a', 'length': 1 }; + assert.deepEqual(func(object), ['a']); + assert.deepEqual(func(args), array); + }); + + QUnit.test('`_.' + methodName + '` should return a shallow clone of arrays', function(assert) { + assert.expect(2); + + var actual = func(array); + assert.deepEqual(actual, array); + assert.notStrictEqual(actual, array); + }); + + QUnit.test('`_.' + methodName + '` should work with a node list for `collection`', function(assert) { + assert.expect(1); + + if (document) { + try { + var actual = func(document.getElementsByTagName('body')); + } catch (e) {} + + assert.deepEqual(actual, [body]); + } + else { + skipAssert(assert); + } + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('toInteger methods'); + + lodashStable.each(['toInteger', 'toSafeInteger'], function(methodName) { + var func = _[methodName], + isSafe = methodName == 'toSafeInteger'; + + QUnit.test('`_.' + methodName + '` should convert values to integers', function(assert) { + assert.expect(6); + + assert.strictEqual(func(-5.6), -5); + assert.strictEqual(func('5.6'), 5); + assert.strictEqual(func(), 0); + assert.strictEqual(func(NaN), 0); + + var expected = isSafe ? MAX_SAFE_INTEGER : MAX_INTEGER; + assert.strictEqual(func(Infinity), expected); + assert.strictEqual(func(-Infinity), -expected); + }); + + QUnit.test('`_.' + methodName + '` should support `value` of `-0`', function(assert) { + assert.expect(1); + + assert.strictEqual(1 / func(-0), -Infinity); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.toLength'); + + (function() { + QUnit.test('should return a valid length', function(assert) { + assert.expect(4); + + assert.strictEqual(_.toLength(-1), 0); + assert.strictEqual(_.toLength('1'), 1); + assert.strictEqual(_.toLength(1.1), 1); + assert.strictEqual(_.toLength(MAX_INTEGER), MAX_ARRAY_LENGTH); + }); + + QUnit.test('should return `value` if a valid length', function(assert) { + assert.expect(3); + + assert.strictEqual(_.toLength(0), 0); + assert.strictEqual(_.toLength(3), 3); + assert.strictEqual(_.toLength(MAX_ARRAY_LENGTH), MAX_ARRAY_LENGTH); + }); + + QUnit.test('should convert `-0` to `0`', function(assert) { + assert.expect(1); + + assert.strictEqual(1 / _.toLength(-0), Infinity); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('number coercion methods'); + + lodashStable.each(['toFinite', 'toInteger', 'toNumber', 'toSafeInteger'], function(methodName) { + var func = _[methodName]; + + QUnit.test('`_.' + methodName + '` should preserve the sign of `0`', function(assert) { + assert.expect(2); + + var values = [0, '0', -0, '-0'], + expected = [[0, Infinity], [0, Infinity], [-0, -Infinity], [-0, -Infinity]]; + + lodashStable.times(2, function(index) { + var others = lodashStable.map(values, index ? Object : identity); + + var actual = lodashStable.map(others, function(value) { + var result = func(value); + return [result, 1 / result]; + }); + + assert.deepEqual(actual, expected); + }); + }); + }); + + lodashStable.each(['toFinite', 'toInteger', 'toLength', 'toNumber', 'toSafeInteger'], function(methodName) { + var func = _[methodName], + isToFinite = methodName == 'toFinite', + isToLength = methodName == 'toLength', + isToNumber = methodName == 'toNumber', + isToSafeInteger = methodName == 'toSafeInteger'; + + function negative(string) { + return '-' + string; + } + + function pad(string) { + return whitespace + string + whitespace; + } + + function positive(string) { + return '+' + string; + } + + QUnit.test('`_.' + methodName + '` should pass thru primitive number values', function(assert) { + assert.expect(1); + + var values = [0, 1, NaN]; + + var expected = lodashStable.map(values, function(value) { + return (!isToNumber && value !== value) ? 0 : value; + }); + + var actual = lodashStable.map(values, func); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should convert number primitives and objects to numbers', function(assert) { + assert.expect(1); + + var values = [2, 1.2, MAX_SAFE_INTEGER, MAX_INTEGER, Infinity, NaN]; + + var expected = lodashStable.map(values, function(value) { + if (!isToNumber) { + if (!isToFinite && value == 1.2) { + value = 1; + } + else if (value == Infinity) { + value = MAX_INTEGER; + } + else if (value !== value) { + value = 0; + } + if (isToLength || isToSafeInteger) { + value = Math.min(value, isToLength ? MAX_ARRAY_LENGTH : MAX_SAFE_INTEGER); + } + } + var neg = isToLength ? 0 : -value; + return [value, value, neg, neg]; + }); + + var actual = lodashStable.map(values, function(value) { + return [func(value), func(Object(value)), func(-value), func(Object(-value))]; + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should convert string primitives and objects to numbers', function(assert) { + assert.expect(1); + + var transforms = [identity, pad, positive, negative]; + + var values = [ + '10', '1.234567890', (MAX_SAFE_INTEGER + ''), + '1e+308', '1e308', '1E+308', '1E308', + '5e-324', '5E-324', + 'Infinity', 'NaN' + ]; + + var expected = lodashStable.map(values, function(value) { + var n = +value; + if (!isToNumber) { + if (!isToFinite && n == 1.234567890) { + n = 1; + } + else if (n == Infinity) { + n = MAX_INTEGER; + } + else if ((!isToFinite && n == Number.MIN_VALUE) || n !== n) { + n = 0; + } + if (isToLength || isToSafeInteger) { + n = Math.min(n, isToLength ? MAX_ARRAY_LENGTH : MAX_SAFE_INTEGER); + } + } + var neg = isToLength ? 0 : -n; + return [n, n, n, n, n, n, neg, neg]; + }); + + var actual = lodashStable.map(values, function(value) { + return lodashStable.flatMap(transforms, function(mod) { + return [func(mod(value)), func(Object(mod(value)))]; + }); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should convert binary/octal strings to numbers', function(assert) { + assert.expect(1); + + var numbers = [42, 5349, 1715004], + transforms = [identity, pad], + values = ['0b101010', '0o12345', '0x1a2b3c']; + + var expected = lodashStable.map(numbers, function(n) { + return lodashStable.times(8, lodashStable.constant(n)); + }); + + var actual = lodashStable.map(values, function(value) { + var upper = value.toUpperCase(); + return lodashStable.flatMap(transforms, function(mod) { + return [func(mod(value)), func(Object(mod(value))), func(mod(upper)), func(Object(mod(upper)))]; + }); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should convert invalid binary/octal strings to `' + (isToNumber ? 'NaN' : '0') + '`', function(assert) { + assert.expect(1); + + var transforms = [identity, pad, positive, negative], + values = ['0b', '0o', '0x', '0b1010102', '0o123458', '0x1a2b3x']; + + var expected = lodashStable.map(values, function(n) { + return lodashStable.times(8, lodashStable.constant(isToNumber ? NaN : 0)); + }); + + var actual = lodashStable.map(values, function(value) { + return lodashStable.flatMap(transforms, function(mod) { + return [func(mod(value)), func(Object(mod(value)))]; + }); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should convert symbols to `' + (isToNumber ? 'NaN' : '0') + '`', function(assert) { + assert.expect(1); + + if (Symbol) { + var object1 = Object(symbol), + object2 = Object(symbol), + values = [symbol, object1, object2], + expected = lodashStable.map(values, lodashStable.constant(isToNumber ? NaN : 0)); + + object2.valueOf = undefined; + var actual = lodashStable.map(values, func); + + assert.deepEqual(actual, expected); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.' + methodName + '` should convert empty values to `0` or `NaN`', function(assert) { + assert.expect(1); + + var values = falsey.concat(whitespace); + + var expected = lodashStable.map(values, function(value) { + return (isToNumber && value !== whitespace) ? Number(value) : 0; + }); + + var actual = lodashStable.map(values, function(value, index) { + return index ? func(value) : func(); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should coerce objects to numbers', function(assert) { + assert.expect(1); + + var values = [ + {}, + [], + [1], + [1, 2], + { 'valueOf': '1.1' }, + { 'valueOf': '1.1', 'toString': lodashStable.constant('2.2') }, + { 'valueOf': lodashStable.constant('1.1'), 'toString': '2.2' }, + { 'valueOf': lodashStable.constant('1.1'), 'toString': lodashStable.constant('2.2') }, + { 'valueOf': lodashStable.constant('-0x1a2b3c') }, + { 'toString': lodashStable.constant('-0x1a2b3c') }, + { 'valueOf': lodashStable.constant('0o12345') }, + { 'toString': lodashStable.constant('0o12345') }, + { 'valueOf': lodashStable.constant('0b101010') }, + { 'toString': lodashStable.constant('0b101010') } + ]; + + var expected = [ + NaN, 0, 1, NaN, + NaN, 2.2, 1.1, 1.1, + NaN, NaN, + 5349, 5349, + 42, 42 + ]; + + if (isToFinite) { + expected = [ + 0, 0, 1, 0, + 0, 2.2, 1.1, 1.1, + 0, 0, + 5349, 5349, + 42, 42 + ]; + } + else if (!isToNumber) { + expected = [ + 0, 0, 1, 0, + 0, 2, 1, 1, + 0, 0, + 5349, 5349, + 42, 42 + ]; + } + var actual = lodashStable.map(values, func); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.`' + methodName + '` should prevent ReDoS', function(assert) { + assert.expect(2); + + var largeStrLen = 50000, + largeStr = '1' + lodashStable.repeat(' ', largeStrLen) + '1', + maxMs = 1000, + startTime = lodashStable.now(); + + assert.deepEqual(_[methodName](largeStr), methodName == 'toNumber' ? NaN : 0); + + var endTime = lodashStable.now(), + timeSpent = endTime - startTime; + + assert.ok(timeSpent < maxMs, 'operation took ' + timeSpent + 'ms'); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.toPairs'); + + (function() { + QUnit.test('should be aliased', function(assert) { + assert.expect(1); + + assert.strictEqual(_.entries, _.toPairs); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.toPairsIn'); + + (function() { + QUnit.test('should be aliased', function(assert) { + assert.expect(1); + + assert.strictEqual(_.entriesIn, _.toPairsIn); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('toPairs methods'); + + lodashStable.each(['toPairs', 'toPairsIn'], function(methodName) { + var func = _[methodName], + isToPairs = methodName == 'toPairs'; + + QUnit.test('`_.' + methodName + '` should create an array of string keyed-value pairs', function(assert) { + assert.expect(1); + + var object = { 'a': 1, 'b': 2 }, + actual = lodashStable.sortBy(func(object), 0); + + assert.deepEqual(actual, [['a', 1], ['b', 2]]); + }); + + QUnit.test('`_.' + methodName + '` should ' + (isToPairs ? 'not ' : '') + 'include inherited string keyed property values', function(assert) { + assert.expect(1); + + function Foo() { + this.a = 1; + } + Foo.prototype.b = 2; + + var expected = isToPairs ? [['a', 1]] : [['a', 1], ['b', 2]], + actual = lodashStable.sortBy(func(new Foo), 0); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should convert objects with a `length` property', function(assert) { + assert.expect(1); + + var object = { '0': 'a', '1': 'b', 'length': 2 }, + actual = lodashStable.sortBy(func(object), 0); + + assert.deepEqual(actual, [['0', 'a'], ['1', 'b'], ['length', 2]]); + }); + + QUnit.test('`_.' + methodName + '` should convert maps', function(assert) { + assert.expect(1); + + if (Map) { + var map = new Map; + map.set('a', 1); + map.set('b', 2); + assert.deepEqual(func(map), [['a', 1], ['b', 2]]); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.' + methodName + '` should convert sets', function(assert) { + assert.expect(1); + + if (Set) { + var set = new Set; + set.add(1); + set.add(2); + assert.deepEqual(func(set), [[1, 1], [2, 2]]); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('`_.' + methodName + '` should convert strings', function(assert) { + assert.expect(2); + + lodashStable.each(['xo', Object('xo')], function(string) { + var actual = lodashStable.sortBy(func(string), 0); + assert.deepEqual(actual, [['0', 'x'], ['1', 'o']]); + }); + }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.toPath'); + + (function() { + QUnit.test('should convert a string to a path', function(assert) { + assert.expect(2); + + assert.deepEqual(_.toPath('a.b.c'), ['a', 'b', 'c']); + assert.deepEqual(_.toPath('a[0].b.c'), ['a', '0', 'b', 'c']); + }); + + QUnit.test('should coerce array elements to strings', function(assert) { + assert.expect(4); + + var array = ['a', 'b', 'c']; + + lodashStable.each([array, lodashStable.map(array, Object)], function(value) { + var actual = _.toPath(value); + assert.deepEqual(actual, array); + assert.notStrictEqual(actual, array); + }); + }); + + QUnit.test('should return new path array', function(assert) { + assert.expect(1); + + assert.notStrictEqual(_.toPath('a.b.c'), _.toPath('a.b.c')); + }); + + QUnit.test('should not coerce symbols to strings', function(assert) { + assert.expect(4); + + if (Symbol) { + var object = Object(symbol); + lodashStable.each([symbol, object, [symbol], [object]], function(value) { + var actual = _.toPath(value); + assert.ok(lodashStable.isSymbol(actual[0])); + }); + } + else { + skipAssert(assert, 4); + } + }); + + QUnit.test('should handle complex paths', function(assert) { + assert.expect(1); + + var actual = _.toPath('a[-1.23]["[\\"b\\"]"].c[\'[\\\'d\\\']\'][\ne\n][f].g'); + assert.deepEqual(actual, ['a', '-1.23', '["b"]', 'c', "['d']", '\ne\n', 'f', 'g']); + }); + + QUnit.test('should handle consecutive empty brackets and dots', function(assert) { + assert.expect(12); + + var expected = ['', 'a']; + assert.deepEqual(_.toPath('.a'), expected); + assert.deepEqual(_.toPath('[].a'), expected); + + expected = ['', '', 'a']; + assert.deepEqual(_.toPath('..a'), expected); + assert.deepEqual(_.toPath('[][].a'), expected); + + expected = ['a', '', 'b']; + assert.deepEqual(_.toPath('a..b'), expected); + assert.deepEqual(_.toPath('a[].b'), expected); + + expected = ['a', '', '', 'b']; + assert.deepEqual(_.toPath('a...b'), expected); + assert.deepEqual(_.toPath('a[][].b'), expected); + + expected = ['a', '']; + assert.deepEqual(_.toPath('a.'), expected); + assert.deepEqual(_.toPath('a[]'), expected); + + expected = ['a', '', '']; + assert.deepEqual(_.toPath('a..'), expected); + assert.deepEqual(_.toPath('a[][]'), expected); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.toPlainObject'); + + (function() { + QUnit.test('should flatten inherited string keyed properties', function(assert) { + assert.expect(1); + + function Foo() { + this.b = 2; + } + Foo.prototype.c = 3; + + var actual = lodashStable.assign({ 'a': 1 }, _.toPlainObject(new Foo)); + assert.deepEqual(actual, { 'a': 1, 'b': 2, 'c': 3 }); + }); + + QUnit.test('should convert `arguments` objects to plain objects', function(assert) { + assert.expect(1); + + var actual = _.toPlainObject(args), + expected = { '0': 1, '1': 2, '2': 3 }; + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should convert arrays to plain objects', function(assert) { + assert.expect(1); + + var actual = _.toPlainObject(['a', 'b', 'c']), + expected = { '0': 'a', '1': 'b', '2': 'c' }; + + assert.deepEqual(actual, expected); + }); + }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.runInContext'); + QUnit.module('lodash.toString'); (function() { - test('should not require a fully populated `context` object', 1, function() { - if (!isModularize) { - var lodash = _.runInContext({ - 'setTimeout': function(callback) { - callback(); - } - }); + QUnit.test('should treat nullish values as empty strings', function(assert) { + assert.expect(1); - var pass = false; - lodash.delay(function() { pass = true; }, 32); - ok(pass); + var values = [, null, undefined], + expected = lodashStable.map(values, stubString); + + var actual = lodashStable.map(values, function(value, index) { + return index ? _.toString(value) : _.toString(); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should preserve the sign of `0`', function(assert) { + assert.expect(1); + + var values = [-0, Object(-0), 0, Object(0)], + expected = ['-0', '-0', '0', '0'], + actual = lodashStable.map(values, _.toString); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should preserve the sign of `0` in an array', function(assert) { + assert.expect(1); + + var values = [-0, Object(-0), 0, Object(0)]; + assert.deepEqual(_.toString(values), '-0,-0,0,0'); + }); + + QUnit.test('should not error on symbols', function(assert) { + assert.expect(1); + + if (Symbol) { + try { + assert.strictEqual(_.toString(symbol), 'Symbol(a)'); + } catch (e) { + assert.ok(false, e.message); + } + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should not error on an array of symbols', function(assert) { + assert.expect(1); + + if (Symbol) { + try { + assert.strictEqual(_.toString([symbol]), 'Symbol(a)'); + } catch (e) { + assert.ok(false, e.message); + } + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should return the `toString` result of the wrapped value', function(assert) { + assert.expect(1); + + if (!isNpm) { + var wrapped = _([1, 2, 3]); + assert.strictEqual(wrapped.toString(), '1,2,3'); } else { - skipTest(); + skipAssert(assert); } }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.sample'); + QUnit.module('lodash.transform'); (function() { - var array = [1, 2, 3]; + function Foo() { + this.a = 1; + this.b = 2; + this.c = 3; + } - test('should return a random element', 1, function() { - var actual = _.sample(array); - ok(_.contains(array, actual)); + QUnit.test('should create an object with the same `[[Prototype]]` as `object` when `accumulator` is nullish', function(assert) { + assert.expect(4); + + var accumulators = [, null, undefined], + object = new Foo, + expected = lodashStable.map(accumulators, stubTrue); + + var iteratee = function(result, value, key) { + result[key] = square(value); + }; + + var mapper = function(accumulator, index) { + return index ? _.transform(object, iteratee, accumulator) : _.transform(object, iteratee); + }; + + var results = lodashStable.map(accumulators, mapper); + + var actual = lodashStable.map(results, function(result) { + return result instanceof Foo; + }); + + assert.deepEqual(actual, expected); + + expected = lodashStable.map(accumulators, lodashStable.constant({ 'a': 1, 'b': 4, 'c': 9 })); + actual = lodashStable.map(results, lodashStable.toPlainObject); + + assert.deepEqual(actual, expected); + + object = { 'a': 1, 'b': 2, 'c': 3 }; + actual = lodashStable.map(accumulators, mapper); + + assert.deepEqual(actual, expected); + + object = [1, 2, 3]; + expected = lodashStable.map(accumulators, lodashStable.constant([1, 4, 9])); + actual = lodashStable.map(accumulators, mapper); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should create regular arrays from typed arrays', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(typedArrays, stubTrue); + + var actual = lodashStable.map(typedArrays, function(type) { + var Ctor = root[type], + array = Ctor ? new Ctor(new ArrayBuffer(24)) : []; + + return lodashStable.isArray(_.transform(array, noop)); + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should support an `accumulator` value', function(assert) { + assert.expect(6); + + var values = [new Foo, [1, 2, 3], { 'a': 1, 'b': 2, 'c': 3 }], + expected = lodashStable.map(values, lodashStable.constant([1, 4, 9])); + + var actual = lodashStable.map(values, function(value) { + return _.transform(value, function(result, value) { + result.push(square(value)); + }, []); + }); + + assert.deepEqual(actual, expected); + + var object = { 'a': 1, 'b': 4, 'c': 9 }, + expected = [object, { '0': 1, '1': 4, '2': 9 }, object]; + + actual = lodashStable.map(values, function(value) { + return _.transform(value, function(result, value, key) { + result[key] = square(value); + }, {}); + }); + + assert.deepEqual(actual, expected); + + lodashStable.each([[], {}], function(accumulator) { + var actual = lodashStable.map(values, function(value) { + return _.transform(value, noop, accumulator); + }); + + assert.ok(lodashStable.every(actual, function(result) { + return result === accumulator; + })); + + assert.strictEqual(_.transform(null, null, accumulator), accumulator); + }); }); - test('should return two random elements', 1, function() { - var actual = _.sample(array, 2); - ok(actual[0] !== actual[1] && _.contains(array, actual[0]) && _.contains(array, actual[1])); + QUnit.test('should treat sparse arrays as dense', function(assert) { + assert.expect(1); + + var actual = _.transform(Array(1), function(result, value, index) { + result[index] = String(value); + }); + + assert.deepEqual(actual, ['undefined']); }); - test('should contain elements of the collection', 1, function() { - var actual = _.sample(array, array.length); - deepEqual(actual.sort(), array); + QUnit.test('should work without an `iteratee`', function(assert) { + assert.expect(1); + + assert.ok(_.transform(new Foo) instanceof Foo); }); - test('should return an empty array when `n` < `1`', 3, function() { - _.forEach([0, -1, -2], function(n) { - deepEqual(_.sample(array, n), []); + QUnit.test('should ensure `object` is an object before using its `[[Prototype]]`', function(assert) { + assert.expect(2); + + var Ctors = [Boolean, Boolean, Number, Number, Number, String, String], + values = [false, true, 0, 1, NaN, '', 'a'], + expected = lodashStable.map(values, stubObject); + + var results = lodashStable.map(values, function(value) { + return _.transform(value); }); + + assert.deepEqual(results, expected); + + expected = lodashStable.map(values, stubFalse); + + var actual = lodashStable.map(results, function(value, index) { + return value instanceof Ctors[index]; + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should ensure `object` constructor is a function before using its `[[Prototype]]`', function(assert) { + assert.expect(1); + + Foo.prototype.constructor = null; + assert.notOk(_.transform(new Foo) instanceof Foo); + Foo.prototype.constructor = Foo; }); - test('should return all elements when `n` >= `array.length`', 2, function() { - _.forEach([3, 4], function(n) { - deepEqual(_.sample(array, n).sort(), array); + QUnit.test('should create an empty object when given a falsey `object`', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(falsey, stubObject); + + var actual = lodashStable.map(falsey, function(object, index) { + return index ? _.transform(object) : _.transform(); }); + + assert.deepEqual(actual, expected); }); - test('should return `undefined` when sampling an empty array', 1, function() { - strictEqual(_.sample([]), undefined); + lodashStable.each({ + 'array': [1, 2, 3], + 'object': { 'a': 1, 'b': 2, 'c': 3 } + }, + function(object, key) { + QUnit.test('should provide correct `iteratee` arguments when transforming an ' + key, function(assert) { + assert.expect(2); + + var args; + + _.transform(object, function() { + args || (args = slice.call(arguments)); + }); + + var first = args[0]; + if (key == 'array') { + assert.ok(first !== object && lodashStable.isArray(first)); + assert.deepEqual(args, [first, 1, 0, object]); + } else { + assert.ok(first !== object && lodashStable.isPlainObject(first)); + assert.deepEqual(args, [first, 1, 'a', object]); + } + }); }); - test('should return an empty array for empty or falsey collections', 1, function() { - var actual = []; + QUnit.test('should create an object from the same realm as `object`', function(assert) { + assert.expect(1); - var expected = _.transform(empties, function(result) { - result.push([], []); + var objects = lodashStable.filter(realm, function(value) { + return lodashStable.isObject(value) && !lodashStable.isElement(value); }); - _.forEach(empties, function(value) { - try { - actual.push(_.shuffle(value), _.shuffle(value, 1)); - } catch(e) { } + var expected = lodashStable.map(objects, stubTrue); + + var actual = lodashStable.map(objects, function(object) { + var Ctor = object.constructor, + result = _.transform(object); + + if (result === object) { + return false; + } + if (lodashStable.isTypedArray(object)) { + return result instanceof Array; + } + return result instanceof Ctor || !(new Ctor instanceof Ctor); }); - deepEqual(actual, expected); + assert.deepEqual(actual, expected); }); + }()); - test('should sample an object', 2, function() { - var object = { 'a': 1, 'b': 2, 'c': 3 }, - actual = _.sample(object); + /*--------------------------------------------------------------------------*/ + + QUnit.module('trim methods'); + + lodashStable.each(['trim', 'trimStart', 'trimEnd'], function(methodName, index) { + var func = _[methodName], + parts = []; + + if (index != 2) { + parts.push('leading'); + } + if (index != 1) { + parts.push('trailing'); + } + parts = parts.join(' and '); + + QUnit.test('`_.' + methodName + '` should remove ' + parts + ' whitespace', function(assert) { + assert.expect(1); + + var string = whitespace + 'a b c' + whitespace, + expected = (index == 2 ? whitespace : '') + 'a b c' + (index == 1 ? whitespace : ''); + + assert.strictEqual(func(string), expected); + }); + + QUnit.test('`_.' + methodName + '` should coerce `string` to a string', function(assert) { + assert.expect(1); + + var object = { 'toString': lodashStable.constant(whitespace + 'a b c' + whitespace) }, + expected = (index == 2 ? whitespace : '') + 'a b c' + (index == 1 ? whitespace : ''); + + assert.strictEqual(func(object), expected); + }); + + QUnit.test('`_.' + methodName + '` should remove ' + parts + ' `chars`', function(assert) { + assert.expect(1); + + var string = '-_-a-b-c-_-', + expected = (index == 2 ? '-_-' : '') + 'a-b-c' + (index == 1 ? '-_-' : ''); + + assert.strictEqual(func(string, '_-'), expected); + }); + + QUnit.test('`_.' + methodName + '` should coerce `chars` to a string', function(assert) { + assert.expect(1); + + var object = { 'toString': lodashStable.constant('_-') }, + string = '-_-a-b-c-_-', + expected = (index == 2 ? '-_-' : '') + 'a-b-c' + (index == 1 ? '-_-' : ''); + + assert.strictEqual(func(string, object), expected); + }); + + QUnit.test('`_.' + methodName + '` should return an empty string for empty values and `chars`', function(assert) { + assert.expect(6); + + lodashStable.each([null, '_-'], function(chars) { + assert.strictEqual(func(null, chars), ''); + assert.strictEqual(func(undefined, chars), ''); + assert.strictEqual(func('', chars), ''); + }); + }); - ok(_.contains(array, actual)); + QUnit.test('`_.' + methodName + '` should work with `undefined` or empty string values for `chars`', function(assert) { + assert.expect(2); - actual = _.sample(object, 2); - ok(actual[0] !== actual[1] && _.contains(array, actual[0]) && _.contains(array, actual[1])); + var string = whitespace + 'a b c' + whitespace, + expected = (index == 2 ? whitespace : '') + 'a b c' + (index == 1 ? whitespace : ''); + + assert.strictEqual(func(string, undefined), expected); + assert.strictEqual(func(string, ''), string); + }); + + QUnit.test('`_.`' + methodName + '` should prevent ReDoS', function(assert) { + assert.expect(2); + + var largeStrLen = 50000, + largeStr = 'A' + lodashStable.repeat(' ', largeStrLen) + 'A', + maxMs = 1000, + startTime = lodashStable.now(); + + assert.strictEqual(_[methodName](largeStr), largeStr); + + var endTime = lodashStable.now(), + timeSpent = endTime - startTime; + + assert.ok(timeSpent < maxMs, 'operation took ' + timeSpent + 'ms'); }); - test('should work when used as `callback` for `_.map`', 1, function() { - var a = [1, 2, 3], - b = [4, 5, 6], - c = [7, 8, 9], - actual = _.map([a, b, c], _.sample); + QUnit.test('`_.' + methodName + '` should work as an iteratee for methods like `_.map`', function(assert) { + assert.expect(1); + + var string = Object(whitespace + 'a b c' + whitespace), + trimmed = (index == 2 ? whitespace : '') + 'a b c' + (index == 1 ? whitespace : ''), + actual = lodashStable.map([string, string, string], func); - ok(_.contains(a, actual[0]) && _.contains(b, actual[1]) && _.contains(c, actual[2])); + assert.deepEqual(actual, [trimmed, trimmed, trimmed]); }); - test('should chain when passing `n`', 1, function() { + QUnit.test('`_.' + methodName + '` should return an unwrapped value when implicitly chaining', function(assert) { + assert.expect(1); + if (!isNpm) { - var actual = _(array).sample(2); - ok(actual instanceof _); + var string = whitespace + 'a b c' + whitespace, + expected = (index == 2 ? whitespace : '') + 'a b c' + (index == 1 ? whitespace : ''); + + assert.strictEqual(_(string)[methodName](), expected); } else { - skipTest(); + skipAssert(assert); } }); - test('should not chain when arguments are not provided', 1, function() { + QUnit.test('`_.' + methodName + '` should return a wrapped value when explicitly chaining', function(assert) { + assert.expect(1); + if (!isNpm) { - var actual = _(array).sample(); - ok(_.contains(array, actual)); + var string = whitespace + 'a b c' + whitespace; + assert.ok(_(string).chain()[methodName]() instanceof _); } else { - skipTest(); + skipAssert(assert); } }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('uncommon symbols'); + + (function() { + var flag = '\ud83c\uddfa\ud83c\uddf8', + heart = '\u2764' + emojiVar, + hearts = '\ud83d\udc95', + comboGlyph = '\ud83d\udc68\u200d' + heart + '\u200d\ud83d\udc8B\u200d\ud83d\udc68', + hashKeycap = '#' + emojiVar + '\u20e3', + leafs = '\ud83c\udf42', + mic = '\ud83c\udf99', + noMic = mic + '\u20e0', + raisedHand = '\u270B' + emojiVar, + rocket = '\ud83d\ude80', + thumbsUp = '\ud83d\udc4d'; + + QUnit.test('should account for astral symbols', function(assert) { + assert.expect(34); + + var allHearts = _.repeat(hearts, 10), + chars = hearts + comboGlyph, + string = 'A ' + leafs + ', ' + comboGlyph + ', and ' + rocket, + trimChars = comboGlyph + hearts, + trimString = trimChars + string + trimChars; + + assert.strictEqual(_.camelCase(hearts + ' the ' + leafs), hearts + 'The' + leafs); + assert.strictEqual(_.camelCase(string), 'a' + leafs + comboGlyph + 'And' + rocket); + assert.strictEqual(_.capitalize(rocket), rocket); + + assert.strictEqual(_.pad(string, 16), ' ' + string + ' '); + assert.strictEqual(_.padStart(string, 16), ' ' + string); + assert.strictEqual(_.padEnd(string, 16), string + ' '); + + assert.strictEqual(_.pad(string, 16, chars), hearts + string + chars); + assert.strictEqual(_.padStart(string, 16, chars), chars + hearts + string); + assert.strictEqual(_.padEnd(string, 16, chars), string + chars + hearts); + + assert.strictEqual(_.size(string), 13); + assert.deepEqual(_.split(string, ' '), ['A', leafs + ',', comboGlyph + ',', 'and', rocket]); + assert.deepEqual(_.split(string, ' ', 3), ['A', leafs + ',', comboGlyph + ',']); + assert.deepEqual(_.split(string, undefined), [string]); + assert.deepEqual(_.split(string, undefined, -1), [string]); + assert.deepEqual(_.split(string, undefined, 0), []); + + var expected = ['A', ' ', leafs, ',', ' ', comboGlyph, ',', ' ', 'a', 'n', 'd', ' ', rocket]; + + assert.deepEqual(_.split(string, ''), expected); + assert.deepEqual(_.split(string, '', 6), expected.slice(0, 6)); + assert.deepEqual(_.toArray(string), expected); + + assert.strictEqual(_.trim(trimString, chars), string); + assert.strictEqual(_.trimStart(trimString, chars), string + trimChars); + assert.strictEqual(_.trimEnd(trimString, chars), trimChars + string); + + assert.strictEqual(_.truncate(string, { 'length': 13 }), string); + assert.strictEqual(_.truncate(string, { 'length': 6 }), 'A ' + leafs + '...'); + + assert.deepEqual(_.words(string), ['A', leafs, comboGlyph, 'and', rocket]); + assert.deepEqual(_.toArray(hashKeycap), [hashKeycap]); + assert.deepEqual(_.toArray(noMic), [noMic]); + + lodashStable.times(2, function(index) { + var separator = index ? RegExp(hearts) : hearts, + options = { 'length': 4, 'separator': separator }, + actual = _.truncate(string, options); + + assert.strictEqual(actual, 'A...'); + assert.strictEqual(actual.length, 4); + + actual = _.truncate(allHearts, options); + assert.strictEqual(actual, hearts + '...'); + assert.strictEqual(actual.length, 5); + }); + }); + + QUnit.test('should account for combining diacritical marks', function(assert) { + assert.expect(1); + + var values = lodashStable.map(comboMarks, function(mark) { + return 'o' + mark; + }); + + var expected = lodashStable.map(values, function(value) { + return [1, [value], [value]]; + }); + + var actual = lodashStable.map(values, function(value) { + return [_.size(value), _.toArray(value), _.words(value)]; + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should account for fitzpatrick modifiers', function(assert) { + assert.expect(1); + + var values = lodashStable.map(fitzModifiers, function(modifier) { + return thumbsUp + modifier; + }); + + var expected = lodashStable.map(values, function(value) { + return [1, [value], [value]]; + }); + + var actual = lodashStable.map(values, function(value) { + return [_.size(value), _.toArray(value), _.words(value)]; + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should account for regional symbols', function(assert) { + assert.expect(6); + + var pair = flag.match(/\ud83c[\udde6-\uddff]/g), + regionals = pair.join(' '); + + assert.strictEqual(_.size(flag), 1); + assert.strictEqual(_.size(regionals), 3); + + assert.deepEqual(_.toArray(flag), [flag]); + assert.deepEqual(_.toArray(regionals), [pair[0], ' ', pair[1]]); + + assert.deepEqual(_.words(flag), [flag]); + assert.deepEqual(_.words(regionals), [pair[0], pair[1]]); + }); + + QUnit.test('should account for variation selectors', function(assert) { + assert.expect(3); + + assert.strictEqual(_.size(heart), 1); + assert.deepEqual(_.toArray(heart), [heart]); + assert.deepEqual(_.words(heart), [heart]); + }); + + QUnit.test('should account for variation selectors with fitzpatrick modifiers', function(assert) { + assert.expect(1); + + var values = lodashStable.map(fitzModifiers, function(modifier) { + return raisedHand + modifier; + }); + + var expected = lodashStable.map(values, function(value) { + return [1, [value], [value]]; + }); + + var actual = lodashStable.map(values, function(value) { + return [_.size(value), _.toArray(value), _.words(value)]; + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should match lone surrogates', function(assert) { + assert.expect(3); + + var pair = hearts.split(''), + surrogates = pair[0] + ' ' + pair[1]; + + assert.strictEqual(_.size(surrogates), 3); + assert.deepEqual(_.toArray(surrogates), [pair[0], ' ', pair[1]]); + assert.deepEqual(_.words(surrogates), []); + }); + + QUnit.test('should match side by side fitzpatrick modifiers separately ', function(assert) { + assert.expect(1); + + var string = fitzModifiers[0] + fitzModifiers[0]; + assert.deepEqual(_.toArray(string), [fitzModifiers[0], fitzModifiers[0]]); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.unary'); + + (function() { + function fn() { + return slice.call(arguments); + } + + QUnit.test('should cap the number of arguments provided to `func`', function(assert) { + assert.expect(1); + + var actual = lodashStable.map(['6', '8', '10'], _.unary(parseInt)); + assert.deepEqual(actual, [6, 8, 10]); + }); + + QUnit.test('should not force a minimum argument count', function(assert) { + assert.expect(1); + + var capped = _.unary(fn); + assert.deepEqual(capped(), []); + }); + + QUnit.test('should use `this` binding of function', function(assert) { + assert.expect(1); + + var capped = _.unary(function(a, b) { return this; }), + object = { 'capped': capped }; + + assert.strictEqual(object.capped(), object); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.unescape'); + + (function() { + var escaped = '&<>"'/', + unescaped = '&<>"\'/'; + + escaped += escaped; + unescaped += unescaped; + + QUnit.test('should unescape entities in order', function(assert) { + assert.expect(1); + + assert.strictEqual(_.unescape('<'), '<'); + }); + + QUnit.test('should unescape the proper entities', function(assert) { + assert.expect(1); + + assert.strictEqual(_.unescape(escaped), unescaped); + }); + + QUnit.test('should handle strings with nothing to unescape', function(assert) { + assert.expect(1); + + assert.strictEqual(_.unescape('abc'), 'abc'); + }); - _.forEach({ - 'literal': 'abc', - 'object': Object('abc') - }, - function(collection, key) { - test('should work with a string ' + key + ' for `collection`', 2, function() { - var actual = _.sample(collection); - ok(_.contains(collection, actual)); + QUnit.test('should unescape the same characters escaped by `_.escape`', function(assert) { + assert.expect(1); - actual = _.sample(collection, 2); - ok(actual[0] !== actual[1] && _.contains(collection, actual[0]) && _.contains(collection, actual[1])); + assert.strictEqual(_.unescape(_.escape(unescaped)), unescaped); + }); + + lodashStable.each(['`', '/'], function(entity) { + QUnit.test('should not unescape the "' + entity + '" entity', function(assert) { + assert.expect(1); + + assert.strictEqual(_.unescape(entity), entity); }); }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.shuffle'); + QUnit.module('union methods'); - (function() { - var array = [1, 2, 3], - object = { 'a': 1, 'b': 2, 'c': 3 }; + lodashStable.each(['union', 'unionBy', 'unionWith'], function(methodName) { + var func = _[methodName]; - test('should return a new array', 1, function() { - notStrictEqual(_.shuffle(array), array); + QUnit.test('`_.' + methodName + '` should return the union of two arrays', function(assert) { + assert.expect(1); + + var actual = func([2], [1, 2]); + assert.deepEqual(actual, [2, 1]); }); - test('should contain the same elements after a collection is shuffled', 2, function() { - deepEqual(_.shuffle(array).sort(), array); - deepEqual(_.shuffle(object).sort(), array); + QUnit.test('`_.' + methodName + '` should return the union of multiple arrays', function(assert) { + assert.expect(1); + + var actual = func([2], [1, 2], [2, 3]); + assert.deepEqual(actual, [2, 1, 3]); }); - test('should shuffle an object', 1, function() { - var actual = _.shuffle(object); - deepEqual(actual.sort(), array); + QUnit.test('`_.' + methodName + '` should not flatten nested arrays', function(assert) { + assert.expect(1); + + var actual = func([1, 3, 2], [1, [5]], [2, [4]]); + assert.deepEqual(actual, [1, 3, 2, [5], [4]]); }); - _.forEach({ - 'literal': 'abc', - 'object': Object('abc') - }, - function(collection, key) { - test('should work with a string ' + key + ' for `collection`', 1, function() { - var actual = _.shuffle(collection); - deepEqual(actual.sort(), ['a','b', 'c']); - }); + QUnit.test('`_.' + methodName + '` should ignore values that are not arrays or `arguments` objects', function(assert) { + assert.expect(3); + + var array = [0]; + assert.deepEqual(func(array, 3, { '0': 1 }, null), array); + assert.deepEqual(func(null, array, null, [2, 1]), [0, 2, 1]); + assert.deepEqual(func(array, null, args, null), [0, 1, 2, 3]); }); - }()); + }); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.size'); + QUnit.module('lodash.unionBy'); (function() { - var args = arguments, - array = [1, 2, 3]; + QUnit.test('should accept an `iteratee`', function(assert) { + assert.expect(2); - test('should return the number of own enumerable properties of an object', 1, function() { - equal(_.size({ 'one': 1, 'two': 2, 'three': 3 }), 3); - }); + var actual = _.unionBy([2.1], [1.2, 2.3], Math.floor); + assert.deepEqual(actual, [2.1, 1.2]); - test('should return the length of an array', 1, function() { - equal(_.size(array), 3); + actual = _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); + assert.deepEqual(actual, [{ 'x': 1 }, { 'x': 2 }]); }); - test('should accept a falsey `object` argument', 1, function() { - var expected = _.map(falsey, function() { return 0; }); + QUnit.test('should provide correct `iteratee` arguments', function(assert) { + assert.expect(1); - var actual = _.map(falsey, function(value, index) { - try { - return index ? _.size(value) : _.size(); - } catch(e) { } + var args; + + _.unionBy([2.1], [1.2, 2.3], function() { + args || (args = slice.call(arguments)); }); - deepEqual(actual, expected); + assert.deepEqual(args, [2.1]); }); - test('should work with jQuery/MooTools DOM query collections', 1, function() { - function Foo(elements) { push.apply(this, elements); } - Foo.prototype = { 'length': 0, 'splice': Array.prototype.splice }; + QUnit.test('should output values from the first possible array', function(assert) { + assert.expect(1); - equal(_.size(new Foo(array)), 3); + var actual = _.unionBy([{ 'x': 1, 'y': 1 }], [{ 'x': 1, 'y': 2 }], 'x'); + assert.deepEqual(actual, [{ 'x': 1, 'y': 1 }]); }); + }()); - test('should work with `arguments` objects (test in IE < 9)', 1, function() { - if (!isPhantomPage) { - equal(_.size(args), 3); - } else { - skipTest(); - } - }); + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.unionWith'); + + (function() { + QUnit.test('should work with a `comparator`', function(assert) { + assert.expect(1); + + var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }], + others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }], + actual = _.unionWith(objects, others, lodashStable.isEqual); - test('fixes the JScript [[DontEnum]] bug (test in IE < 9)', 1, function() { - equal(_.size(shadowedObject), 7); + assert.deepEqual(actual, [objects[0], objects[1], others[0]]); }); - _.forEach({ - 'literal': 'abc', - 'object': Object('abc') - }, - function(collection, key) { - test('should work with a string ' + key + ' for `collection`', 1, function() { - deepEqual(_.size(collection), 3); + QUnit.test('should output values from the first possible array', function(assert) { + assert.expect(1); + + var objects = [{ 'x': 1, 'y': 1 }], + others = [{ 'x': 1, 'y': 2 }]; + + var actual = _.unionWith(objects, others, function(a, b) { + return a.x == b.x; }); + + assert.deepEqual(actual, [{ 'x': 1, 'y': 1 }]); }); - }(1, 2, 3)); + }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.some'); + QUnit.module('uniq methods'); - (function() { - test('should return `false` for empty or falsey collections', 1, function() { - var expected = _.map(empties, function() { return false; }); + lodashStable.each(['uniq', 'uniqBy', 'uniqWith', 'sortedUniq', 'sortedUniqBy'], function(methodName) { + var func = _[methodName], + isSorted = /^sorted/.test(methodName), + objects = [{ 'a': 2 }, { 'a': 3 }, { 'a': 1 }, { 'a': 2 }, { 'a': 3 }, { 'a': 1 }]; - var actual = _.map(empties, function(value) { - try { - return _.some(value, _.identity); - } catch(e) { } + if (isSorted) { + objects = _.sortBy(objects, 'a'); + } + else { + QUnit.test('`_.' + methodName + '` should return unique values of an unsorted array', function(assert) { + assert.expect(1); + + var array = [2, 1, 2]; + assert.deepEqual(func(array), [2, 1]); }); + } + QUnit.test('`_.' + methodName + '` should return unique values of a sorted array', function(assert) { + assert.expect(1); - deepEqual(actual, expected); + var array = [1, 2, 2]; + assert.deepEqual(func(array), [1, 2]); }); - test('should return `true` if the callback returns truey for any element in the collection', 2, function() { - strictEqual(_.some([false, 1, ''], _.identity), true); - strictEqual(_.some([null, 'x', 0], _.identity), true); - }); + QUnit.test('`_.' + methodName + '` should treat object instances as unique', function(assert) { + assert.expect(1); - test('should return `false` if the callback returns falsey for all elements in the collection', 2, function() { - strictEqual(_.some([false, false, false], _.identity), false); - strictEqual(_.some([null, 0, ''], _.identity), false); + assert.deepEqual(func(objects), objects); }); - test('should return `true` as soon as the `callback` result is truey', 1, function() { - strictEqual(_.some([null, true, null], _.identity), true); - }); + QUnit.test('`_.' + methodName + '` should treat `-0` as `0`', function(assert) { + assert.expect(1); - test('should use `_.identity` when no callback is provided', 2, function() { - strictEqual(_.some([0, 1]), true); - strictEqual(_.some([0, 0]), false); + var actual = lodashStable.map(func([-0, 0]), lodashStable.toString); + assert.deepEqual(actual, ['0']); }); - test('should be aliased', 1, function() { - strictEqual(_.any, _.some); + QUnit.test('`_.' + methodName + '` should match `NaN`', function(assert) { + assert.expect(1); + + assert.deepEqual(func([NaN, NaN]), [NaN]); }); - }()); - /*--------------------------------------------------------------------------*/ + QUnit.test('`_.' + methodName + '` should work with large arrays', function(assert) { + assert.expect(1); - QUnit.module('lodash.sortBy'); + var largeArray = [], + expected = [0, {}, 'a'], + count = Math.ceil(LARGE_ARRAY_SIZE / expected.length); - (function() { - var objects = [ - { 'a': 'x', 'b': 3 }, - { 'a': 'y', 'b': 4 }, - { 'a': 'x', 'b': 1 }, - { 'a': 'y', 'b': 2 } - ]; + lodashStable.each(expected, function(value) { + lodashStable.times(count, function() { + largeArray.push(value); + }); + }); - test('should sort in ascending order', 1, function() { - var actual = _.pluck(_.sortBy(objects, function(object) { - return object.b; - }), 'b'); + assert.deepEqual(func(largeArray), expected); + }); + + QUnit.test('`_.' + methodName + '` should work with large arrays of `-0` as `0`', function(assert) { + assert.expect(1); - deepEqual(actual, [1, 2, 3, 4]); + var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, function(index) { + return isEven(index) ? -0 : 0; + }); + + var actual = lodashStable.map(func(largeArray), lodashStable.toString); + assert.deepEqual(actual, ['0']); }); - test('should perform a stable sort (test in IE > 8, Opera, and V8)', 1, function() { - function Pair(x, y) { - this.x = x; - this.y = y; - } + QUnit.test('`_.' + methodName + '` should work with large arrays of boolean, `NaN`, and nullish values', function(assert) { + assert.expect(1); - var collection = [ - new Pair(1, 1), new Pair(1, 2), - new Pair(1, 3), new Pair(1, 4), - new Pair(1, 5), new Pair(1, 6), - new Pair(2, 1), new Pair(2, 2), - new Pair(2, 3), new Pair(2, 4), - new Pair(2, 5), new Pair(2, 6), - new Pair(undefined, 1), new Pair(undefined, 2), - new Pair(undefined, 3), new Pair(undefined, 4), - new Pair(undefined, 5), new Pair(undefined, 6) - ]; + var largeArray = [], + expected = [null, undefined, false, true, NaN], + count = Math.ceil(LARGE_ARRAY_SIZE / expected.length); - var actual = _.sortBy(collection, function(pair) { - return pair.x; + lodashStable.each(expected, function(value) { + lodashStable.times(count, function() { + largeArray.push(value); + }); }); - deepEqual(actual, collection); + assert.deepEqual(func(largeArray), expected); }); - test('should work with `undefined` values', 1, function() { - var array = [undefined, 4, 1, undefined, 3, 2]; - deepEqual(_.sortBy(array, _.identity), [1, 2, 3, 4, undefined, undefined]); - }); + QUnit.test('`_.' + methodName + '` should work with large arrays of symbols', function(assert) { + assert.expect(1); - test('should use `_.identity` when no `callback` is provided', 1, function() { - var actual = _.sortBy([3, 2, 1]); - deepEqual(actual, [1, 2, 3]); + if (Symbol) { + var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, Symbol); + assert.deepEqual(func(largeArray), largeArray); + } + else { + skipAssert(assert); + } }); - test('should pass the correct `callback` arguments', 1, function() { - var args; + QUnit.test('`_.' + methodName + '` should work with large arrays of well-known symbols', function(assert) { + assert.expect(1); - _.sortBy(objects, function() { - args || (args = slice.call(arguments)); - }); + // See http://www.ecma-international.org/ecma-262/6.0/#sec-well-known-symbols. + if (Symbol) { + var expected = [ + Symbol.hasInstance, Symbol.isConcatSpreadable, Symbol.iterator, + Symbol.match, Symbol.replace, Symbol.search, Symbol.species, + Symbol.split, Symbol.toPrimitive, Symbol.toStringTag, Symbol.unscopables + ]; - deepEqual(args, [objects[0], 0, objects]); - }); + var largeArray = [], + count = Math.ceil(LARGE_ARRAY_SIZE / expected.length); - test('should support the `thisArg` argument', 1, function() { - var actual = _.sortBy([1, 2, 3], function(num) { - return this.sin(num); - }, Math); + expected = lodashStable.map(expected, function(symbol) { + return symbol || {}; + }); - deepEqual(actual, [3, 1, 2]); - }); + lodashStable.each(expected, function(value) { + lodashStable.times(count, function() { + largeArray.push(value); + }); + }); - test('should work with an array for `callback`', 1, function() { - var actual = _.sortBy(objects, ['a', 'b']); - deepEqual(actual, [objects[2], objects[0], objects[3], objects[1]]); + assert.deepEqual(func(largeArray), expected); + } + else { + skipAssert(assert); + } }); - test('should coerce arrays returned from a `callback`', 1, function() { - var actual = _.sortBy(objects, function(object) { - var result = [object.a, object.b]; - result.toString = function() { return String(this[0]); }; - return result; + QUnit.test('`_.' + methodName + '` should distinguish between numbers and numeric strings', function(assert) { + assert.expect(1); + + var largeArray = [], + expected = ['2', 2, Object('2'), Object(2)], + count = Math.ceil(LARGE_ARRAY_SIZE / expected.length); + + lodashStable.each(expected, function(value) { + lodashStable.times(count, function() { + largeArray.push(value); + }); }); - deepEqual(actual, [objects[0], objects[2], objects[1], objects[3]]); + assert.deepEqual(func(largeArray), expected); }); + }); - test('should work with a string for `callback`', 1, function() { - var actual = _.pluck(_.sortBy(objects, 'b'), 'b'); - deepEqual(actual, [1, 2, 3, 4]); - }); + /*--------------------------------------------------------------------------*/ - test('should work with an object for `collection`', 1, function() { - var actual = _.sortBy({ 'a': 1, 'b': 2, 'c': 3 }, function(num) { - return Math.sin(num); - }); + QUnit.module('lodash.uniq'); + + (function() { + QUnit.test('should perform an unsorted uniq when used as an iteratee for methods like `_.map`', function(assert) { + assert.expect(1); - deepEqual(actual, [3, 1, 2]); + var array = [[2, 1, 2], [1, 2, 1]], + actual = lodashStable.map(array, lodashStable.uniq); + + assert.deepEqual(actual, [[2, 1], [1, 2]]); }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.sortedIndex'); + QUnit.module('uniqBy methods'); - (function() { - var array = [20, 30, 50], - objects = [{ 'x': 20 }, { 'x': 30 }, { 'x': 50 }]; + lodashStable.each(['uniqBy', 'sortedUniqBy'], function(methodName) { + var func = _[methodName], + isSorted = methodName == 'sortedUniqBy', + objects = [{ 'a': 2 }, { 'a': 3 }, { 'a': 1 }, { 'a': 2 }, { 'a': 3 }, { 'a': 1 }]; - test('should return the insert index of a given value', 2, function() { - equal(_.sortedIndex(array, 40), 2); - equal(_.sortedIndex(array, 30), 1); + if (isSorted) { + objects = _.sortBy(objects, 'a'); + } + QUnit.test('`_.' + methodName + '` should work with an `iteratee`', function(assert) { + assert.expect(1); + + var expected = isSorted ? [{ 'a': 1 }, { 'a': 2 }, { 'a': 3 }] : objects.slice(0, 3); + + var actual = func(objects, function(object) { + return object.a; + }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('should work with large arrays', function(assert) { + assert.expect(2); + + var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, function() { + return [1, 2]; + }); + + var actual = func(largeArray, String); + assert.strictEqual(actual[0], largeArray[0]); + assert.deepEqual(actual, [[1, 2]]); }); - test('should pass the correct `callback` arguments', 1, function() { + QUnit.test('`_.' + methodName + '` should provide correct `iteratee` arguments', function(assert) { + assert.expect(1); + var args; - _.sortedIndex(array, 40, function() { + func(objects, function() { args || (args = slice.call(arguments)); }); - deepEqual(args, [40]); + assert.deepEqual(args, [objects[0]]); }); - test('should support the `thisArg` argument', 1, function() { - var actual = _.sortedIndex(array, 40, function(num) { - return this[num]; - }, { '20': 20, '30': 30, '40': 40 }); + QUnit.test('`_.' + methodName + '` should work with `_.property` shorthands', function(assert) { + assert.expect(2); - strictEqual(actual, 2); - }); + var expected = isSorted ? [{ 'a': 1 }, { 'a': 2 }, { 'a': 3 }] : objects.slice(0, 3), + actual = func(objects, 'a'); + + assert.deepEqual(actual, expected); + + var arrays = [[2], [3], [1], [2], [3], [1]]; + if (isSorted) { + arrays = lodashStable.sortBy(arrays, 0); + } + expected = isSorted ? [[1], [2], [3]] : arrays.slice(0, 3); + actual = func(arrays, 0); - test('should work with a string for `callback`', 1, function() { - var actual = _.sortedIndex(objects, { 'x': 40 }, 'x'); - equal(actual, 2); + assert.deepEqual(actual, expected); }); - test('supports arrays with lengths larger than `Math.pow(2, 31) - 1`', 1, function() { - var length = Math.pow(2, 32) - 1, - index = length - 1, - array = Array(length), - steps = 0; + lodashStable.each({ + 'an array': [0, 'a'], + 'an object': { '0': 'a' }, + 'a number': 0, + 'a string': '0' + }, + function(iteratee, key) { + QUnit.test('`_.' + methodName + '` should work with ' + key + ' for `iteratee`', function(assert) { + assert.expect(1); - if (array.length == length) { - array[index] = index; - _.sortedIndex(array, index, function() { steps++; }); - equal(steps, 33); - } - else { - skipTest(); - } + var actual = func([['a'], ['a'], ['b']], iteratee); + assert.deepEqual(actual, [['a'], ['b']]); + }); }); - }()); + }); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.support'); + QUnit.module('lodash.uniqWith'); (function() { - test('should contain properties with boolean values', 1, function() { - ok(_.every(_.values(_.support), _.isBoolean)); + QUnit.test('should work with a `comparator`', function(assert) { + assert.expect(1); + + var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }], + actual = _.uniqWith(objects, lodashStable.isEqual); + + assert.deepEqual(actual, [objects[0], objects[1]]); }); - test('should not contain minified properties (test production builds)', 1, function() { - var props = [ - 'argsClass', - 'argsObject', - 'enumErrorProps', - 'enumPrototypes', - 'fastBind', - 'funcDecomp', - 'funcNames', - 'nodeClass', - 'nonEnumArgs', - 'nonEnumShadows', - 'ownLast', - 'spliceObjects', - 'unindexedChars' - ]; + QUnit.test('should preserve the sign of `0`', function(assert) { + assert.expect(1); + + var largeArray = lodashStable.times(LARGE_ARRAY_SIZE, function(index) { + return isEven(index) ? -0 : 0; + }); + + var arrays = [[-0, 0], largeArray], + expected = lodashStable.map(arrays, lodashStable.constant(['-0'])); - ok(!_.size(_.difference(_.keys(_.support), props))); + var actual = lodashStable.map(arrays, function(array) { + return lodashStable.map(_.uniqWith(array, lodashStable.eq), lodashStable.toString); + }); + + assert.deepEqual(actual, expected); }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.tap'); + QUnit.module('lodash.uniqueId'); (function() { - test('should intercept and return the given value', 2, function() { - if (!isNpm) { - var intercepted; + QUnit.test('should generate unique ids', function(assert) { + assert.expect(1); - var actual = _.tap('a', function(value) { - intercepted = value; - }); + var actual = lodashStable.times(1000, function(assert) { + return _.uniqueId(); + }); - equal(actual, 'a'); - equal(intercepted, 'a'); - } - else { - skipTest(2); - } + assert.strictEqual(lodashStable.uniq(actual).length, actual.length); }); - test('should return intercept unwrapped values and return wrapped values when chaining', 2, function() { - if (!isNpm) { - var intercepted, - array = [1, 2, 3, 4]; + QUnit.test('should return a string value when not providing a `prefix`', function(assert) { + assert.expect(1); - var actual = _(array).tap(function(value) { - intercepted = value; - value.pop(); - }); + assert.strictEqual(typeof _.uniqueId(), 'string'); + }); - ok(actual instanceof _); - strictEqual(intercepted, array); - } - else { - skipTest(2); - } + QUnit.test('should coerce the prefix argument to a string', function(assert) { + assert.expect(1); + + var actual = [_.uniqueId(3), _.uniqueId(2), _.uniqueId(1)]; + assert.ok(/3\d+,2\d+,1\d+/.test(actual)); }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.template'); + QUnit.module('lodash.unset'); (function() { - test('should use a `with` statement by default', 1, function() { - var compiled = _.template('<%= index %><%= collection[index] %><% _.each(collection, function(value, index) { %><%= index %><% }); %>'), - actual = compiled({ 'index': 1, 'collection': ['a', 'b', 'c'] }); + QUnit.test('should unset property values', function(assert) { + assert.expect(4); - equal(actual, '1b012'); + lodashStable.each(['a', ['a']], function(path) { + var object = { 'a': 1, 'c': 2 }; + assert.strictEqual(_.unset(object, path), true); + assert.deepEqual(object, { 'c': 2 }); + }); }); - test('should interpolate data object properties', 1, function() { - var compiled = _.template('<%= a %>BC'); - equal(compiled({ 'a': 'A' }), 'ABC'); - }); + QUnit.test('should preserve the sign of `0`', function(assert) { + assert.expect(1); - test('should work correctly with `this` references', 2, function() { - var compiled = _.template('a<%= this.String("b") %>c'); - equal(compiled(), 'abc'); + var props = [-0, Object(-0), 0, Object(0)], + expected = lodashStable.map(props, lodashStable.constant([true, false])); - var object = { 'b': 'B' }; - object.compiled = _.template('A<%= this.b %>C', null, { 'variable': 'obj' }); - equal(object.compiled(), 'ABC'); - }); + var actual = lodashStable.map(props, function(key) { + var object = { '-0': 'a', '0': 'b' }; + return [_.unset(object, key), lodashStable.toString(key) in object]; + }); - test('should work with backslashes', 1, function() { - var compiled = _.template('<%= a %> \\b'); - equal(compiled({ 'a': 'A' }), 'A \\b'); + assert.deepEqual(actual, expected); }); - test('should support escaped values in "interpolation" delimiters', 1, function() { - var compiled = _.template('<%= a ? "a=\\"A\\"" : "" %>'); - equal(compiled({ 'a': true }), 'a="A"'); - }); + QUnit.test('should unset symbol keyed property values', function(assert) { + assert.expect(2); - test('should evaluate JavaScript in "evaluate" delimiters', 1, function() { - var compiled = _.template( - '

<%= collection[key] %>

' - ); + if (Symbol) { + var object = {}; + object[symbol] = 1; - var actual = compiled({ 'collection': { 'a': 'A', 'b': 'B' } }); - equal(actual, '

'); + assert.strictEqual(_.unset(object, symbol), true); + assert.notOk(symbol in object); + } + else { + skipAssert(assert, 2); + } }); - test('should work with escaped characters in string literals', 2, function() { - var compiled = _.template('<% print("\'\\n\\r\\t\\u2028\\u2029\\\\") %>'); - equal(compiled(), "'\n\r\t\u2028\u2029\\"); + QUnit.test('should unset deep property values', function(assert) { + assert.expect(4); - compiled = _.template('\'\n\r\t<%= a %>\u2028\u2029\\"'); - equal(compiled({ 'a': 'A' }), '\'\n\r\tA\u2028\u2029\\"'); + lodashStable.each(['a.b', ['a', 'b']], function(path) { + var object = { 'a': { 'b': null } }; + assert.strictEqual(_.unset(object, path), true); + assert.deepEqual(object, { 'a': {} }); + }); }); - test('should work with no delimiters', 1, function() { - var expected = 'abc'; - equal(_.template(expected, {}), expected); - }); + QUnit.test('should handle complex paths', function(assert) { + assert.expect(4); - test('should work with statements containing quotes', 1, function() { - var compiled = _.template("<%\ - if (a == 'A' || a == \"a\") {\ - %>'a',\"A\"<%\ - } %>" - ); + var paths = [ + 'a[-1.23]["[\\"b\\"]"].c[\'[\\\'d\\\']\'][\ne\n][f].g', + ['a', '-1.23', '["b"]', 'c', "['d']", '\ne\n', 'f', 'g'] + ]; - equal(compiled({ 'a': 'A' }), "'a',\"A\""); + lodashStable.each(paths, function(path) { + var object = { 'a': { '-1.23': { '["b"]': { 'c': { "['d']": { '\ne\n': { 'f': { 'g': 8 } } } } } } } }; + assert.strictEqual(_.unset(object, path), true); + assert.notOk('g' in object.a[-1.23]['["b"]'].c["['d']"]['\ne\n'].f); + }); }); - test('should escape values in "escape" delimiters', 1, function() { - var escaped = '

&<>"'\/

', - unescaped = '&<>"\'\/'; + QUnit.test('should return `true` for nonexistent paths', function(assert) { + assert.expect(5); - var compiled = _.template('

<%- value %>

'); - equal(compiled({ 'value': unescaped }), escaped); - }); + var object = { 'a': { 'b': { 'c': null } } }; - test('should work with templates containing newlines and comments', 1, function() { - var compiled = _.template('<%\n\ - // comment\n\ - if (value) { value += 3; }\n\ - %>

<%= value %>

' - ); + lodashStable.each(['z', 'a.z', 'a.b.z', 'a.b.c.z'], function(path) { + assert.strictEqual(_.unset(object, path), true); + }); - equal(compiled({ 'value': 3 }), '

'); + assert.deepEqual(object, { 'a': { 'b': { 'c': null } } }); }); - test('should work with custom `_.templateSettings` delimiters', 1, function() { - var settings = _.clone(_.templateSettings); + QUnit.test('should not error when `object` is nullish', function(assert) { + assert.expect(1); - _.assign(_.templateSettings, { - 'escape': /\{\{-([\s\S]+?)\}\}/g, - 'evaluate': /\{\{([\s\S]+?)\}\}/g, - 'interpolate': /\{\{=([\s\S]+?)\}\}/g - }); + var values = [null, undefined], + expected = [[true, true], [true, true]]; - var compiled = _.template('

{{= index }}: {{- value }}

'), - expected = '

0: a & A
1: b & B

'; + var actual = lodashStable.map(values, function(value) { + try { + return [_.unset(value, 'a.b'), _.unset(value, ['a', 'b'])]; + } catch (e) { + return e.message; + } + }); - equal(compiled({ 'collection': ['a & A', 'b & B'] }), expected); - _.assign(_.templateSettings, settings); + assert.deepEqual(actual, expected); }); - test('should work with `_.templateSettings` delimiters containing special characters', 1, function() { - var settings = _.clone(_.templateSettings); - - _.assign(_.templateSettings, { - 'escape': /<\?-([\s\S]+?)\?>/g, - 'evaluate': /<\?([\s\S]+?)\?>/g, - 'interpolate': /<\?=([\s\S]+?)\?>/g - }); + QUnit.test('should follow `path` over non-plain objects', function(assert) { + assert.expect(8); - var compiled = _.template('

'), - expected = '

0: a & A
1: b & B

'; + var object = { 'a': '' }, + paths = ['constructor.prototype.a', ['constructor', 'prototype', 'a']]; - equal(compiled({ 'collection': ['a & A', 'b & B'] }), expected); - _.assign(_.templateSettings, settings); - }); + lodashStable.each(paths, function(path) { + numberProto.a = 1; - test('supports recursive calls', 1, function() { - var compiled = _.template('<%= a %><% a = _.template(c, obj) %><%= a %>'), - data = { 'a': 'A', 'b': 'B', 'c': '<%= b %>' }; + var actual = _.unset(0, path); + assert.strictEqual(actual, true); + assert.notOk('a' in numberProto); - equal(compiled(data), 'AB'); - }); + delete numberProto.a; + }); - test('should not modify `_.templateSettings` when `options` are provided', 2, function() { - equal('a' in _.templateSettings, false); + lodashStable.each(['a.replace.b', ['a', 'replace', 'b']], function(path) { + stringProto.replace.b = 1; - _.template('', {}, { 'a': 1 }); - equal('a' in _.templateSettings, false); + var actual = _.unset(object, path); + assert.strictEqual(actual, true); + assert.notOk('a' in stringProto.replace); - delete _.templateSettings.a; + delete stringProto.replace.b; + }); }); - test('should not augment the `options` object', 1, function() { - var options = {}; - _.template('', {}, options); - deepEqual(options, {}); - }); + QUnit.test('should return `false` for non-configurable properties', function(assert) { + assert.expect(1); - test('should provide the template source when a SyntaxError occurs', 1, function() { - try { - _.template('<% if x %>'); - } catch(e) { - var source = e.source; + var object = {}; + + if (!isStrict) { + defineProperty(object, 'a', { + 'configurable': false, + 'enumerable': true, + 'writable': true, + 'value': 1, + }); + assert.strictEqual(_.unset(object, 'a'), false); + } + else { + skipAssert(assert); } - ok(/__p/.test(source)); }); + }()); - test('should work with complex "interpolate" delimiters', 22, function() { - _.forEach({ - '<%= a + b %>': '3', - '<%= b - a %>': '1', - '<%= a = b %>': '2', - '<%= !a %>': 'false', - '<%= ~a %>': '-2', - '<%= a * b %>': '2', - '<%= a / b %>': '0.5', - '<%= a % b %>': '1', - '<%= a >> b %>': '0', - '<%= a << b %>': '4', - '<%= a & b %>': '0', - '<%= a ^ b %>': '3', - '<%= a | b %>': '3', - '<%= {}.toString.call(0) %>': '[object Number]', - '<%= a.toFixed(2) %>': '1.00', - '<%= obj["a"] %>': '1', - '<%= delete a %>': 'true', - '<%= "a" in obj %>': 'true', - '<%= obj instanceof Object %>': 'true', - '<%= new Boolean %>': 'false', - '<%= typeof a %>': 'number', - '<%= void a %>': '' - }, - function(value, key) { - var compiled = _.template(key), - data = { 'a': 1, 'b': 2 }; + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.unzipWith'); - equal(compiled(data), value, key); - }); - }); + (function() { + QUnit.test('should unzip arrays combining regrouped elements with `iteratee`', function(assert) { + assert.expect(1); - test('should allow referencing variables declared in "evaluate" delimiters from other delimiters', 1, function() { - var compiled = _.template('<% var b = a; %><%= b.value %>'), - data = { 'a': { 'value': 1 } }; + var array = [[1, 4], [2, 5], [3, 6]]; + + var actual = _.unzipWith(array, function(a, b, c) { + return a + b + c; + }); - strictEqual(compiled(data), '1'); + assert.deepEqual(actual, [6, 15]); }); - test('should work when passing `options.variable`', 1, function() { - var compiled = _.template( - '<% _.forEach( data.a, function( value ) { %>' + - '<%= value.valueOf() %>' + - '<% }) %>', null, { 'variable': 'data' } - ); + QUnit.test('should provide correct `iteratee` arguments', function(assert) { + assert.expect(1); - try { - var data = { 'a': [1, 2, 3] }; - strictEqual(compiled(data), '123'); - } catch(e) { - ok(false); - } - }); + var args; - test('should not error with IE conditional comments enabled (test with development build)', 1, function() { - var compiled = _.template(''), - pass = true; + _.unzipWith([[1, 3, 5], [2, 4, 6]], function() { + args || (args = slice.call(arguments)); + }); - /*@cc_on @*/ - try { - compiled(); - } catch(e) { - pass = false; - } - ok(pass); + assert.deepEqual(args, [1, 2]); }); - test('should tokenize delimiters', 1, function() { - var compiled = _.template(''), - data = { 'type': 1 }; + QUnit.test('should perform a basic unzip when `iteratee` is nullish', function(assert) { + assert.expect(1); - equal(compiled(data), ''); - }); + var array = [[1, 3], [2, 4]], + values = [, null, undefined], + expected = lodashStable.map(values, lodashStable.constant(_.unzip(array))); - test('should work with "interpolate" delimiters containing ternary operators', 1, function() { - var compiled = _.template('<%= value ? value : "b" %>'), - data = { 'value': 'a' }; + var actual = lodashStable.map(values, function(value, index) { + return index ? _.unzipWith(array, value) : _.unzipWith(array); + }); - equal(compiled(data), 'a'); + assert.deepEqual(actual, expected); }); + }()); - test('should work with "interpolate" delimiters containing global values', 1, function() { - var compiled = _.template('<%= typeof Math.abs %>'); + /*--------------------------------------------------------------------------*/ - try { - var actual = compiled(); - } catch(e) { } + QUnit.module('lodash.updateWith'); - equal(actual, 'function'); - }); + (function() { + QUnit.test('should work with a `customizer` callback', function(assert) { + assert.expect(1); - test('should evaluate delimiters once', 1, function() { - var actual = [], - compiled = _.template('<%= func("a") %><%- func("b") %><% func("c") %>'); + var actual = _.updateWith({ '0': {} }, '[0][1][2]', stubThree, function(value) { + return lodashStable.isObject(value) ? undefined : {}; + }); - compiled({ 'func': function(value) { actual.push(value); } }); - deepEqual(actual, ['a', 'b', 'c']); + assert.deepEqual(actual, { '0': { '1': { '2': 3 } } }); }); - test('should parse delimiters with newlines', 1, function() { - var expected = '<<\nprint("

" + (value ? "yes" : "no") + "

")\n>>', - compiled = _.template(expected, null, { 'evaluate': /<<(.+?)>>/g }), - data = { 'value': true }; + QUnit.test('should work with a `customizer` that returns `undefined`', function(assert) { + assert.expect(1); - equal(compiled(data), expected); + var actual = _.updateWith({}, 'a[0].b.c', stubFour, noop); + assert.deepEqual(actual, { 'a': [{ 'b': { 'c': 4 } }] }); }); + }()); - test('should parse ES6 template delimiters', 2, function() { - var data = { 'value': 2 }; - strictEqual(_.template('1${value}3', data), '123'); - equal(_.template('${"{" + value + "\\}"}', data), '{2}'); - }); + /*--------------------------------------------------------------------------*/ - test('supports the "imports" option', 1, function() { - var options = { 'imports': { 'a': 1 } }, - compiled = _.template('<%= a %>', null, options); + QUnit.module('update methods'); - strictEqual(compiled({}), '1'); - }); + lodashStable.each(['update', 'updateWith'], function(methodName) { + var func = _[methodName], + oldValue = 1; - test('should coerce `text` argument to a string', 1, function() { - var data = { 'a': 1 }, - object = { 'toString': function() { return '<%= a %>'; } }; + QUnit.test('`_.' + methodName + '` should invoke `updater` with the value on `path` of `object`', function(assert) { + assert.expect(4); - strictEqual(_.template(object, data), '1'); - }); + var object = { 'a': [{ 'b': { 'c': oldValue } }] }, + expected = oldValue + 1; - test('should handle \\u2028 & \\u2029 characters', 1, function() { - var compiled = _.template('\u2028<%= "\\u2028\\u2029" %>\u2029'); - strictEqual(compiled(), '\u2028\u2028\u2029\u2029'); + lodashStable.each(['a[0].b.c', ['a', '0', 'b', 'c']], function(path) { + func(object, path, function(n) { + assert.strictEqual(n, oldValue); + return ++n; + }); + + assert.strictEqual(object.a[0].b.c, expected); + object.a[0].b.c = oldValue; + }); }); + }); - test('should resolve `null` and `undefined` values to empty strings', 4, function() { - var compiled = _.template('<%= a %><%- a %>'); - strictEqual(compiled({ 'a': null }), ''); - strictEqual(compiled({ 'a': undefined }), ''); + /*--------------------------------------------------------------------------*/ - compiled = _.template('<%= a.b %><%- a.b %>'); - strictEqual(compiled({ 'a': {} }), ''); - strictEqual(compiled({ 'a': {} }), ''); - }); + QUnit.module('lodash.upperCase'); - test('should support single line comments in "evaluate" delimiters (test production builds)', 1, function() { - var compiled = _.template('<% // comment %><% if (value) { %>yap<% } else { %>nope<% } %>'); - equal(compiled({ 'value': true }), 'yap'); - }); + (function() { + QUnit.test('should uppercase as space-separated words', function(assert) { + assert.expect(3); - test('should match delimiters before escaping text', 1, function() { - var compiled = _.template('<<\n a \n>>', null, { 'evaluate': /<<(.*?)>>/g }); - equal(compiled(), '<<\n a \n>>'); + assert.strictEqual(_.upperCase('--foo-bar--'), 'FOO BAR'); + assert.strictEqual(_.upperCase('fooBar'), 'FOO BAR'); + assert.strictEqual(_.upperCase('__foo_bar__'), 'FOO BAR'); }); + }()); - test('should not error when passed non-object `data` and `options` values', 2, function() { - var pass = true; + /*--------------------------------------------------------------------------*/ - try { - _.template('', 1); - } catch(e) { - pass = false; - } - ok(pass); + QUnit.module('lodash.upperFirst'); - pass = true; + (function() { + QUnit.test('should uppercase only the first character', function(assert) { + assert.expect(3); - try { - _.template('', 1, 1); - } catch(e) { - pass = false; - } - ok(pass); + assert.strictEqual(_.upperFirst('fred'), 'Fred'); + assert.strictEqual(_.upperFirst('Fred'), 'Fred'); + assert.strictEqual(_.upperFirst('FRED'), 'FRED'); }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.throttle'); + QUnit.module('values methods'); - (function() { - asyncTest('should throttle a function', 2, function() { - if (!(isRhino && isModularize)) { - var count = 0; - var throttled = _.throttle(function() { count++; }, 32); + lodashStable.each(['values', 'valuesIn'], function(methodName) { + var func = _[methodName], + isValues = methodName == 'values'; - throttled(); - throttled(); - throttled(); + QUnit.test('`_.' + methodName + '` should get string keyed values of `object`', function(assert) { + assert.expect(1); - var lastCount = count; - ok(count > 0); + var object = { 'a': 1, 'b': 2 }, + actual = func(object).sort(); - setTimeout(function() { - ok(count > lastCount); - QUnit.start(); - }, 64); - } - else { - skipTest(2); - QUnit.start(); - } + assert.deepEqual(actual, [1, 2]); }); - asyncTest('subsequent calls should return the result of the first call', 5, function() { - if (!(isRhino && isModularize)) { - var throttled = _.throttle(function(value) { return value; }, 32), - result = [throttled('x'), throttled('y')]; - - deepEqual(result, ['x', 'x']); + QUnit.test('`_.' + methodName + '` should work with an object that has a `length` property', function(assert) { + assert.expect(1); - setTimeout(function() { - var result = [throttled('a'), throttled('b')]; + var object = { '0': 'a', '1': 'b', 'length': 2 }, + actual = func(object).sort(); - notEqual(result[0], 'x'); - notStrictEqual(result[0], undefined); + assert.deepEqual(actual, [2, 'a', 'b']); + }); - notEqual(result[1], 'b'); - notStrictEqual(result[1], undefined); + QUnit.test('`_.' + methodName + '` should ' + (isValues ? 'not ' : '') + 'include inherited string keyed property values', function(assert) { + assert.expect(1); - QUnit.start(); - }, 64); - } - else { - skipTest(5); - QUnit.start(); + function Foo() { + this.a = 1; } - }); + Foo.prototype.b = 2; - asyncTest('should clear timeout when `func` is called', 1, function() { - if (!isModularize) { - var callCount = 0, - dateCount = 0; + var expected = isValues ? [1] : [1, 2], + actual = func(new Foo).sort(); - var getTime = function() { - return ++dateCount < 3 ? +new Date : Infinity; - }; + assert.deepEqual(actual, expected); + }); - var lodash = _.runInContext(_.assign({}, root, { - 'Date': function() { - return { 'getTime': getTime, 'valueOf': getTime }; - } - })); + QUnit.test('`_.' + methodName + '` should work with `arguments` objects', function(assert) { + assert.expect(1); - var throttled = lodash.throttle(function() { - callCount++; - }, 32); + var values = [args, strictArgs], + expected = lodashStable.map(values, lodashStable.constant([1, 2, 3])); - throttled(); - throttled(); - throttled(); + var actual = lodashStable.map(values, function(value) { + return func(value).sort(); + }); - setTimeout(function() { - equal(callCount, 2); - QUnit.start(); - }, 64); - } - else { - skipTest(); - QUnit.start(); - } + assert.deepEqual(actual, expected); }); + }); - asyncTest('supports recursive calls', 3, function() { - if (!(isRhino && isModularize)) { - var args, - count = 0, - object = {}; + /*--------------------------------------------------------------------------*/ - var throttled = _.throttle(function(value) { - count++; - args = [this]; - push.apply(args, arguments); - if (count < 10) { - throttled.call(this, value); - } - }, 32); + QUnit.module('lodash.without'); - throttled.call(object, 'a'); - equal(count, 1); + (function() { + QUnit.test('should return the difference of values', function(assert) { + assert.expect(1); - setTimeout(function() { - ok(count < 3); - deepEqual(args, [object, 'a']); - QUnit.start(); - }, 32); - } - else { - skipTest(3); - QUnit.start(); - } + var actual = _.without([2, 1, 2, 3], 1, 2); + assert.deepEqual(actual, [3]); }); - asyncTest('should not trigger a trailing call when invoked once', 2, function() { - if (!(isRhino && isModularize)) { - var count = 0, - throttled = _.throttle(function() { count++; }, 32); + QUnit.test('should use strict equality to determine the values to reject', function(assert) { + assert.expect(2); - throttled(); - equal(count, 1); + var object1 = { 'a': 1 }, + object2 = { 'b': 2 }, + array = [object1, object2]; - setTimeout(function() { - equal(count, 1); - QUnit.start(); - }, 64); - } - else { - skipTest(2); - QUnit.start(); - } + assert.deepEqual(_.without(array, { 'a': 1 }), array); + assert.deepEqual(_.without(array, object1), [object2]); }); - _.times(2, function(index) { - test('should trigger a call when invoked repeatedly' + (index ? ' and `leading` is `false`' : ''), 1, function() { - if (!(isRhino && isModularize)) { - var count = 0, - limit = 500, - options = index ? { 'leading': false } : {}; + QUnit.test('should remove all occurrences of each value from an array', function(assert) { + assert.expect(1); - var throttled = _.throttle(function() { - count++; - }, 32, options); + var array = [1, 2, 3, 1, 2, 3]; + assert.deepEqual(_.without(array, 1, 2), [3, 3]); + }); + }()); - var start = +new Date; - while ((new Date - start) < limit) { - throttled(); - } - ok(count > 1); - } - else { - skipTest(1); - } + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash.words'); + + (function() { + QUnit.test('should match words containing Latin Unicode letters', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(burredLetters, function(letter) { + return [letter]; }); + + var actual = lodashStable.map(burredLetters, function(letter) { + return _.words(letter); + }); + + assert.deepEqual(actual, expected); }); - asyncTest('should apply default options correctly', 3, function() { - if (!(isRhino && isModularize)) { - var count = 0; + QUnit.test('should support a `pattern`', function(assert) { + assert.expect(2); - var throttled = _.throttle(function(value) { - count++; - return value; - }, 32, {}); + assert.deepEqual(_.words('abcd', /ab|cd/g), ['ab', 'cd']); + assert.deepEqual(_.words('abcd', 'ab|cd'), ['ab']); + }); - equal(throttled('x'), 'x'); - equal(throttled('y'), 'x'); + QUnit.test('should work with compound words', function(assert) { + assert.expect(12); - setTimeout(function() { - strictEqual(count, 2); - QUnit.start(); - }, 256); - } - else { - skipTest(3); - QUnit.start(); - } + assert.deepEqual(_.words('12ft'), ['12', 'ft']); + assert.deepEqual(_.words('aeiouAreVowels'), ['aeiou', 'Are', 'Vowels']); + assert.deepEqual(_.words('enable 6h format'), ['enable', '6', 'h', 'format']); + assert.deepEqual(_.words('enable 24H format'), ['enable', '24', 'H', 'format']); + assert.deepEqual(_.words('isISO8601'), ['is', 'ISO', '8601']); + assert.deepEqual(_.words('LETTERSAeiouAreVowels'), ['LETTERS', 'Aeiou', 'Are', 'Vowels']); + assert.deepEqual(_.words('tooLegit2Quit'), ['too', 'Legit', '2', 'Quit']); + assert.deepEqual(_.words('walk500Miles'), ['walk', '500', 'Miles']); + assert.deepEqual(_.words('xhr2Request'), ['xhr', '2', 'Request']); + assert.deepEqual(_.words('XMLHttp'), ['XML', 'Http']); + assert.deepEqual(_.words('XmlHTTP'), ['Xml', 'HTTP']); + assert.deepEqual(_.words('XmlHttp'), ['Xml', 'Http']); + }); + + QUnit.test('should work with compound words containing diacritical marks', function(assert) { + assert.expect(3); + + assert.deepEqual(_.words('LETTERSÆiouAreVowels'), ['LETTERS', 'Æiou', 'Are', 'Vowels']); + assert.deepEqual(_.words('æiouAreVowels'), ['æiou', 'Are', 'Vowels']); + assert.deepEqual(_.words('æiou2Consonants'), ['æiou', '2', 'Consonants']); + }); + + QUnit.test('should not treat contractions as separate words', function(assert) { + assert.expect(4); + + var postfixes = ['d', 'll', 'm', 're', 's', 't', 've']; + + lodashStable.each(["'", '\u2019'], function(apos) { + lodashStable.times(2, function(index) { + var actual = lodashStable.map(postfixes, function(postfix) { + var string = 'a b' + apos + postfix + ' c'; + return _.words(string[index ? 'toUpperCase' : 'toLowerCase']()); + }); + + var expected = lodashStable.map(postfixes, function(postfix) { + var words = ['a', 'b' + apos + postfix, 'c']; + return lodashStable.map(words, function(word) { + return word[index ? 'toUpperCase' : 'toLowerCase'](); + }); + }); + + assert.deepEqual(actual, expected); + }); + }); }); - test('should work with `leading` option', 4, function() { - if (!(isRhino && isModularize)) { - _.forEach([true, { 'leading': true }], function(options) { - var withLeading = _.throttle(_.identity, 32, options); - equal(withLeading('x'), 'x'); + QUnit.test('should not treat ordinal numbers as separate words', function(assert) { + assert.expect(2); + + var ordinals = ['1st', '2nd', '3rd', '4th']; + + lodashStable.times(2, function(index) { + var expected = lodashStable.map(ordinals, function(ordinal) { + return [ordinal[index ? 'toUpperCase' : 'toLowerCase']()]; }); - _.forEach([false, { 'leading': false }], function(options) { - var withoutLeading = _.throttle(_.identity, 32, options); - strictEqual(withoutLeading('x'), undefined); + var actual = lodashStable.map(expected, function(words) { + return _.words(words[0]); }); - } - else { - skipTest(4); - } + + assert.deepEqual(actual, expected); + }); }); - asyncTest('should work with `trailing` option', 6, function() { - if (!(isRhino && isModularize)) { - var withCount = 0, - withoutCount = 0; + QUnit.test('should not treat mathematical operators as words', function(assert) { + assert.expect(1); - var withTrailing = _.throttle(function(value) { - withCount++; - return value; - }, 64, { 'trailing': true }); + var operators = ['\xac', '\xb1', '\xd7', '\xf7'], + expected = lodashStable.map(operators, stubArray), + actual = lodashStable.map(operators, _.words); - var withoutTrailing = _.throttle(function(value) { - withoutCount++; - return value; - }, 64, { 'trailing': false }); + assert.deepEqual(actual, expected); + }); - equal(withTrailing('x'), 'x'); - equal(withTrailing('y'), 'x'); + QUnit.test('should not treat punctuation as words', function(assert) { + assert.expect(1); - equal(withoutTrailing('x'), 'x'); - equal(withoutTrailing('y'), 'x'); + var marks = [ + '\u2012', '\u2013', '\u2014', '\u2015', + '\u2024', '\u2025', '\u2026', + '\u205d', '\u205e' + ]; - setTimeout(function() { - equal(withCount, 2); - strictEqual(withoutCount, 1); - QUnit.start(); - }, 256); - } - else { - skipTest(6); - QUnit.start(); - } + var expected = lodashStable.map(marks, stubArray), + actual = lodashStable.map(marks, _.words); + + assert.deepEqual(actual, expected); }); - asyncTest('should not update `lastCalled`, at the end of the timeout, when `trailing` is `false`', 1, function() { - if (!(isRhino && isModularize)) { - var count = 0; + QUnit.test('should work as an iteratee for methods like `_.map`', function(assert) { + assert.expect(1); - var throttled = _.throttle(function() { - count++; - }, 64, { 'trailing': false }); + var strings = lodashStable.map(['a', 'b', 'c'], Object), + actual = lodashStable.map(strings, _.words); - throttled(); - throttled(); + assert.deepEqual(actual, [['a'], ['b'], ['c']]); + }); - setTimeout(function() { - throttled(); - throttled(); - }, 96); + QUnit.test('should prevent ReDoS', function(assert) { + assert.expect(2); - setTimeout(function() { - ok(count > 1); - QUnit.start(); - }, 192); - } - else { - skipTest(); - QUnit.start(); - } + var largeWordLen = 50000, + largeWord = _.repeat('A', largeWordLen), + maxMs = 1000, + startTime = lodashStable.now(); + + assert.deepEqual(_.words(largeWord + 'ÆiouAreVowels'), [largeWord, 'Æiou', 'Are', 'Vowels']); + + var endTime = lodashStable.now(), + timeSpent = endTime - startTime; + + assert.ok(timeSpent < maxMs, 'operation took ' + timeSpent + 'ms'); }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.debounce and lodash.throttle'); + QUnit.module('lodash.wrap'); - _.forEach(['debounce', 'throttle'], function(methodName) { - var func = _[methodName]; + (function() { + QUnit.test('should create a wrapped function', function(assert) { + assert.expect(1); - test('_.' + methodName + ' should not error when passed non-object `options` values', 1, function() { - var pass = true; + var p = _.wrap(lodashStable.escape, function(func, text) { + return '

' + func(text) + '

'; + }); - try { - func(noop, 32, 1); - } catch(e) { - pass = false; - } - ok(pass); + assert.strictEqual(p('fred, barney, & pebbles'), '

fred, barney, & pebbles

'); }); - asyncTest('_.' + methodName + ' should call `func` with the correct `this` binding', 1, function() { - if (!(isRhino && isModularize)) { - var actual = []; + QUnit.test('should provide correct `wrapper` arguments', function(assert) { + assert.expect(1); - var object = { - 'func': func(function() { actual.push(this); }, 32) - }; + var args; - object.func(); - if (methodName == 'throttle') { - object.func(); - } - setTimeout(function() { - deepEqual(actual, methodName == 'throttle' ? [object, object] : [object]); - QUnit.start(); - }, 64); - } - else { - skipTest(1); - QUnit.start(); - } + var wrapped = _.wrap(noop, function() { + args || (args = slice.call(arguments)); + }); + + wrapped(1, 2, 3); + assert.deepEqual(args, [noop, 1, 2, 3]); }); - }); - /*--------------------------------------------------------------------------*/ + QUnit.test('should use `_.identity` when `wrapper` is nullish', function(assert) { + assert.expect(1); - QUnit.module('lodash.toArray'); + var values = [, null, undefined], + expected = lodashStable.map(values, stubA); - (function() { - var args = arguments, - array = [1, 2, 3]; + var actual = lodashStable.map(values, function(value, index) { + var wrapped = index ? _.wrap('a', value) : _.wrap('a'); + return wrapped('b', 'c'); + }); - test('should return a dense array', 3, function() { - var sparse = Array(3); - sparse[1] = 2; + assert.deepEqual(actual, expected); + }); - var actual = _.toArray(sparse); + QUnit.test('should use `this` binding of function', function(assert) { + assert.expect(1); - ok(0 in actual); - ok(2 in actual); - deepEqual(actual, sparse); - }); + var p = _.wrap(lodashStable.escape, function(func) { + return '

' + func(this.text) + '

'; + }); - test('should treat array-like objects like arrays', 2, function() { - var object = { '0': 'a', '1': 'b', '2': 'c', 'length': 3 }; - deepEqual(_.toArray(object), ['a', 'b', 'c']); - deepEqual(_.toArray(args), array); + var object = { 'p': p, 'text': 'fred, barney, & pebbles' }; + assert.strictEqual(object.p(), '

fred, barney, & pebbles

'); }); + }()); - test('should return a shallow clone of arrays', 2, function() { - var actual = _.toArray(array); - notStrictEqual(actual, array); - deepEqual(_.toArray(array), array); - }); + /*--------------------------------------------------------------------------*/ + + QUnit.module('xor methods'); + + lodashStable.each(['xor', 'xorBy', 'xorWith'], function(methodName) { + var func = _[methodName]; - test('should return the values of objects', 1, function() { - var object = { 'a': 1, 'b': 2, 'c': 3 }; - deepEqual(_.toArray(object), array); + QUnit.test('`_.' + methodName + '` should return the symmetric difference of two arrays', function(assert) { + assert.expect(1); + + var actual = func([2, 1], [2, 3]); + assert.deepEqual(actual, [1, 3]); }); - test('should work with a string for `collection` (test in Opera < 10.52)', 2, function() { - deepEqual(_.toArray('abc'), ['a', 'b', 'c']); - deepEqual(_.toArray(Object('abc')), ['a', 'b', 'c']); + QUnit.test('`_.' + methodName + '` should return the symmetric difference of multiple arrays', function(assert) { + assert.expect(2); + + var actual = func([2, 1], [2, 3], [3, 4]); + assert.deepEqual(actual, [1, 4]); + + actual = func([1, 2], [2, 1], [1, 2]); + assert.deepEqual(actual, []); }); - test('should work with a node list for `collection` (test in IE < 9)', 1, function() { - if (document) { - try { - var nodeList = document.getElementsByTagName('body'), - actual = _.toArray(nodeList); - } catch(e) { } - deepEqual(actual, [body]); - } else { - skipTest(); - } + QUnit.test('`_.' + methodName + '` should return an empty array when comparing the same array', function(assert) { + assert.expect(1); + + var array = [1], + actual = func(array, array, array); + + assert.deepEqual(actual, []); }); - }(1, 2, 3)); - /*--------------------------------------------------------------------------*/ + QUnit.test('`_.' + methodName + '` should return an array of unique values', function(assert) { + assert.expect(2); - QUnit.module('lodash.times'); + var actual = func([1, 1, 2, 5], [2, 2, 3, 5], [3, 4, 5, 5]); + assert.deepEqual(actual, [1, 4]); - (function() { - test('should pass the correct `callback` arguments', 1, function() { - var args; + actual = func([1, 1]); + assert.deepEqual(actual, [1]); + }); - _.times(1, function() { - args || (args = slice.call(arguments)); - }); + QUnit.test('`_.' + methodName + '` should return a new array when a single array is given', function(assert) { + assert.expect(1); - deepEqual(args, [0]); + var array = [1]; + assert.notStrictEqual(func(array), array); }); - test('should support the `thisArg` argument', 1, function() { - var expect = [1, 2, 3]; - - var actual = _.times(3, function(num) { - return this[num]; - }, expect); + QUnit.test('`_.' + methodName + '` should ignore individual secondary arguments', function(assert) { + assert.expect(1); - deepEqual(actual, expect); + var array = [0]; + assert.deepEqual(func(array, 3, null, { '0': 1 }), array); }); - test('should use `_.identity` when no `callback` is provided', 1, function() { - var actual = _.times(3); - deepEqual(actual, [0, 1, 2]); - }); + QUnit.test('`_.' + methodName + '` should ignore values that are not arrays or `arguments` objects', function(assert) { + assert.expect(3); - test('should return an array of the results of each `callback` execution', 1, function() { - deepEqual(_.times(3, function(n) { return n * 2; }), [0, 2, 4]); + var array = [1, 2]; + assert.deepEqual(func(array, 3, { '0': 1 }, null), array); + assert.deepEqual(func(null, array, null, [2, 3]), [1, 3]); + assert.deepEqual(func(array, null, args, null), [3]); }); - test('should return an empty array for falsey and negative `n` arguments', 1, function() { - var values = falsey.concat(-1, -Infinity), - expected = _.map(values, function() { return []; }); - - var actual = _.map(values, function(value, index) { - return index ? _.times(value) : _.times(); - }); + QUnit.test('`_.' + methodName + '` should return a wrapped value when chaining', function(assert) { + assert.expect(1); - deepEqual(actual, expected); + if (!isNpm) { + var wrapped = _([1, 2, 3])[methodName]([5, 2, 1, 4]); + assert.ok(wrapped instanceof _); + } + else { + skipAssert(assert); + } }); - test('should return a wrapped value when chaining', 2, function() { + QUnit.test('`_.' + methodName + '` should work when in a lazy sequence before `head` or `last`', function(assert) { + assert.expect(1); + if (!isNpm) { - var actual = _(3).times(); - ok(actual instanceof _); - deepEqual(actual.value(), [0, 1, 2]); + var array = lodashStable.range(LARGE_ARRAY_SIZE + 1), + wrapped = _(array).slice(1)[methodName]([LARGE_ARRAY_SIZE, LARGE_ARRAY_SIZE + 1]); + + var actual = lodashStable.map(['head', 'last'], function(methodName) { + return wrapped[methodName](); + }); + + assert.deepEqual(actual, [1, LARGE_ARRAY_SIZE + 1]); } else { - skipTest(2); + skipAssert(assert); } }); - }()); + }); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.transform'); + QUnit.module('lodash.xorBy'); (function() { - test('should produce an that is an instance of the given object\'s constructor', 2, function() { - function Foo() { - this.a = 1; - this.b = 2; - this.c = 3; - } + QUnit.test('should accept an `iteratee`', function(assert) { + assert.expect(2); - var actual = _.transform(new Foo, function(result, value, key) { - result[key] = value * value; - }); + var actual = _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor); + assert.deepEqual(actual, [1.2, 3.4]); - ok(actual instanceof Foo); - deepEqual(_.clone(actual), { 'a': 1, 'b': 4, 'c': 9 }); + actual = _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); + assert.deepEqual(actual, [{ 'x': 2 }]); }); - test('should treat sparse arrays as dense', 1, function() { - var actual = _.transform(Array(1), function(result, value, index) { - result[index] = String(value); - }); + QUnit.test('should provide correct `iteratee` arguments', function(assert) { + assert.expect(1); - deepEqual(actual, ['undefined']); - }); + var args; - test('should work without a `callback` argument', 1, function() { - function Foo() {} - ok(_.transform(new Foo) instanceof Foo); + _.xorBy([2.1, 1.2], [2.3, 3.4], function() { + args || (args = slice.call(arguments)); + }); + + assert.deepEqual(args, [2.3]); }); + }()); - _.forEach({ - 'array': [1, 2, 3], - 'object': { 'a': 1, 'b': 2, 'c': 3 } - }, - function(object, key) { - test('should pass the correct `callback` arguments when transforming an ' + key, 2, function() { - var args; + /*--------------------------------------------------------------------------*/ - _.transform(object, function() { - args || (args = slice.call(arguments)); - }); + QUnit.module('lodash.xorWith'); - var first = args[0]; - if (key == 'array') { - ok(first != object && _.isArray(first)); - deepEqual(args, [first, 1, 0, object]); - } else { - ok(first != object && _.isPlainObject(first)); - deepEqual(args, [first, 1, 'a', object]); - } - }); + (function() { + QUnit.test('should work with a `comparator`', function(assert) { + assert.expect(1); - test('should support the `thisArg` argument when transforming an ' + key, 2, function() { - var actual = _.transform(object, function(result, value, key) { - result[key] = this[key]; - }, null, object); + var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }], + others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }], + actual = _.xorWith(objects, others, lodashStable.isEqual); - notStrictEqual(actual, object); - deepEqual(actual, object); - }); + assert.deepEqual(actual, [objects[1], others[0]]); }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.unescape'); + QUnit.module('zipObject methods'); - (function() { - var escaped = '&<>"'\/', - unescaped = '&<>"\'\/'; + lodashStable.each(['zipObject', 'zipObjectDeep'], function(methodName) { + var func = _[methodName], + object = { 'barney': 36, 'fred': 40 }, + isDeep = methodName == 'zipObjectDeep'; + + QUnit.test('`_.' + methodName + '` should zip together key/value arrays into an object', function(assert) { + assert.expect(1); - test('should unescape entities in the correct order', 1, function() { - equal(_.unescape('<'), '<'); + var actual = func(['barney', 'fred'], [36, 40]); + assert.deepEqual(actual, object); }); - test('should unescape the proper entities', 1, function() { - equal(_.unescape(escaped), unescaped); + QUnit.test('`_.' + methodName + '` should ignore extra `values`', function(assert) { + assert.expect(1); + + assert.deepEqual(func(['a'], [1, 2]), { 'a': 1 }); }); - test('should unescape the same characters escaped by `_.escape`', 1, function() { - equal(_.unescape(_.escape(unescaped)), unescaped); + QUnit.test('`_.' + methodName + '` should assign `undefined` values for extra `keys`', function(assert) { + assert.expect(1); + + assert.deepEqual(func(['a', 'b'], [1]), { 'a': 1, 'b': undefined }); }); - test('should return an empty string when provided `null` or `undefined`', 2, function() { - equal(_.unescape(null), ''); - equal(_.unescape(undefined), ''); + QUnit.test('`_.' + methodName + '` should ' + (isDeep ? '' : 'not ') + 'support deep paths', function(assert) { + assert.expect(2); + + lodashStable.each(['a.b.c', ['a', 'b', 'c']], function(path, index) { + var expected = isDeep ? ({ 'a': { 'b': { 'c': 1 } } }) : (index ? { 'a,b,c': 1 } : { 'a.b.c': 1 }); + assert.deepEqual(func([path], [1]), expected); + }); }); - }()); - /*--------------------------------------------------------------------------*/ + QUnit.test('`_.' + methodName + '` should work in a lazy sequence', function(assert) { + assert.expect(1); - QUnit.module('lodash.union'); + if (!isNpm) { + var values = lodashStable.range(LARGE_ARRAY_SIZE), + props = lodashStable.map(values, function(value) { return 'key' + value; }), + actual = _(props)[methodName](values).map(square).filter(isEven).take().value(); - (function() { - test('should return the union of the given arrays', 1, function() { - var actual = _.union([1, 2, 3], [5, 2, 1, 4], [2, 1]); - deepEqual(actual, [1, 2, 3, 5, 4]); + assert.deepEqual(actual, _.take(_.filter(_.map(func(props, values), square), isEven))); + } + else { + skipAssert(assert); + } }); + }); - test('should not flatten nested arrays', 1, function() { - var actual = _.union([1, 2, 3], [1, [5]], [2, [4]]); - deepEqual(actual, [1, 2, 3, [5], [4]]); + // zipObjectDeep prototype pollution + ['__proto__', 'constructor', 'prototype'].forEach(function (keyToTest) { + QUnit.test('zipObjectDeep is not setting ' + keyToTest + ' on global', function (assert) { + assert.expect(1); + + _.zipObjectDeep([keyToTest + '.a'], ['newValue']); + // Can't access plain `a` as it's not defined and test fails + assert.notEqual(root['a'], 'newValue'); }); - test('should produce correct results when provided a falsey `array` argument', 1, function() { - var expected = [1, 2, 3], - actual = _.union(null, expected); + QUnit.test('zipObjectDeep is not overwriting ' + keyToTest + ' on vars', function (assert) { + assert.expect(3); - deepEqual(actual, expected); + const b = 'oldValue' + _.zipObjectDeep([keyToTest + '.b'], ['newValue']); + assert.equal(b, 'oldValue'); + assert.notEqual(root['b'], 'newValue'); + + // ensure nothing was created + assert.notOk(root['b']); }); - test('should ignore individual secondary values', 1, function() { - var array = [1]; - deepEqual(_.union(array, 1, 2, 3), array); + QUnit.test('zipObjectDeep is not overwriting global.' + keyToTest, function (assert) { + assert.expect(2); + + _.zipObjectDeep([root + '.' + keyToTest + '.c'], ['newValue']); + assert.notEqual(root['c'], 'newValue'); + + // ensure nothing was created + assert.notOk(root['c']); }); - }()); + }); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.uniq'); + QUnit.module('lodash.zipWith'); (function() { - var objects = [{ 'a': 2 }, { 'a': 3 }, { 'a': 1 }, { 'a': 2 }, { 'a': 3 }, { 'a': 1 }]; + QUnit.test('should zip arrays combining grouped elements with `iteratee`', function(assert) { + assert.expect(2); - test('should return unique values of an unsorted array', 1, function() { - var array = [2, 3, 1, 2, 3, 1]; - deepEqual(_.uniq(array), [2, 3, 1]); - }); + var array1 = [1, 2, 3], + array2 = [4, 5, 6], + array3 = [7, 8, 9]; - test('should return unique values of a sorted array', 1, function() { - var array = [1, 1, 2, 2, 3]; - deepEqual(_.uniq(array), [1, 2, 3]); - }); + var actual = _.zipWith(array1, array2, array3, function(a, b, c) { + return a + b + c; + }); - test('should work with large arrays', 1, function() { - var object = {}; + assert.deepEqual(actual, [12, 15, 18]); - var largeArray = _.times(largeArraySize, function(index) { - switch (index % 3) { - case 0: return 0; - case 1: return 'a'; - case 2: return object; - } + var actual = _.zipWith(array1, [], function(a, b) { + return a + (b || 0); }); - deepEqual(_.uniq(largeArray), [0, 'a', object]); + assert.deepEqual(actual, [1, 2, 3]); }); - test('should work with a `callback`', 1, function() { - var actual = _.uniq(objects, false, function(object) { - return object.a; + QUnit.test('should provide correct `iteratee` arguments', function(assert) { + assert.expect(1); + + var args; + + _.zipWith([1, 2], [3, 4], [5, 6], function() { + args || (args = slice.call(arguments)); }); - deepEqual(actual, objects.slice(0, 3)); + assert.deepEqual(args, [1, 3, 5]); }); - test('should work with a `callback` without specifying `isSorted`', 1, function() { - var actual = _.uniq(objects, function(object) { - return object.a; + QUnit.test('should perform a basic zip when `iteratee` is nullish', function(assert) { + assert.expect(1); + + var array1 = [1, 2], + array2 = [3, 4], + values = [, null, undefined], + expected = lodashStable.map(values, lodashStable.constant(_.zip(array1, array2))); + + var actual = lodashStable.map(values, function(value, index) { + return index ? _.zipWith(array1, array2, value) : _.zipWith(array1, array2); }); - deepEqual(actual, objects.slice(0, 3)); + assert.deepEqual(actual, expected); }); + }()); - test('should support the `thisArg` argument', 1, function() { - var actual = _.uniq([1, 2, 1.5, 3, 2.5], function(num) { - return this.floor(num); - }, Math); + /*--------------------------------------------------------------------------*/ - deepEqual(actual, [1, 2, 3]); - }); + QUnit.module('lodash.unzip and lodash.zip'); - test('should perform an unsorted uniq operation when used as `callback` for `_.map`', 1, function() { - var array = [[2, 1, 2], [1, 2, 1]], - actual = _.map(array, _.uniq); + lodashStable.each(['unzip', 'zip'], function(methodName, index) { + var func = _[methodName]; + func = lodashStable.bind(index ? func.apply : func.call, func, null); - deepEqual(actual, [[2, 1], [1, 2]]); - }); + var object = { + 'an empty array': [ + [], + [] + ], + '0-tuples': [ + [[], []], + [] + ], + '2-tuples': [ + [['barney', 'fred'], [36, 40]], + [['barney', 36], ['fred', 40]] + ], + '3-tuples': [ + [['barney', 'fred'], [36, 40], [false, true]], + [['barney', 36, false], ['fred', 40, true]] + ] + }; - test('should work with large arrays of boolean, `null`, and `undefined` values', 1, function() { - var array = [], - expected = [true, false, null, undefined], - count = Math.ceil(largeArraySize / expected.length); + lodashStable.forOwn(object, function(pair, key) { + QUnit.test('`_.' + methodName + '` should work with ' + key, function(assert) { + assert.expect(2); - _.times(count, function() { - push.apply(array, expected); + var actual = func(pair[0]); + assert.deepEqual(actual, pair[1]); + assert.deepEqual(func(actual), actual.length ? pair[0] : []); }); - deepEqual(_.uniq(array), expected); }); - test('should distinguish between numbers and numeric strings', 1, function() { - var array = [], - expected = ['2', 2, Object('2'), Object(2)], - count = Math.ceil(largeArraySize / expected.length); + QUnit.test('`_.' + methodName + '` should work with tuples of different lengths', function(assert) { + assert.expect(4); - _.times(count, function() { - push.apply(array, expected); - }); + var pair = [ + [['barney', 36], ['fred', 40, false]], + [['barney', 'fred'], [36, 40], [undefined, false]] + ]; - deepEqual(_.uniq(array), expected); + var actual = func(pair[0]); + assert.ok('0' in actual[2]); + assert.deepEqual(actual, pair[1]); + + actual = func(actual); + assert.ok('2' in actual[0]); + assert.deepEqual(actual, [['barney', 36, undefined], ['fred', 40, false]]); }); - _.forEach({ - 'an object': ['a'], - 'a number': 0, - 'a string': '0' - }, - function(callback, key) { - test('should work with ' + key + ' for `callback`', 1, function() { - var actual = _.uniq([['a'], ['b'], ['a']], callback); - deepEqual(actual, [['a'], ['b']]); + QUnit.test('`_.' + methodName + '` should treat falsey values as empty arrays', function(assert) { + assert.expect(1); + + var expected = lodashStable.map(falsey, stubArray); + + var actual = lodashStable.map(falsey, function(value) { + return func([value, value, value]); }); + + assert.deepEqual(actual, expected); + }); + + QUnit.test('`_.' + methodName + '` should ignore values that are not arrays or `arguments` objects', function(assert) { + assert.expect(1); + + var array = [[1, 2], [3, 4], null, undefined, { '0': 1 }]; + assert.deepEqual(func(array), [[1, 3], [2, 4]]); }); - test('should be aliased', 1, function() { - strictEqual(_.unique, _.uniq); + QUnit.test('`_.' + methodName + '` should support consuming its return value', function(assert) { + assert.expect(1); + + var expected = [['barney', 'fred'], [36, 40]]; + assert.deepEqual(func(func(func(func(expected)))), expected); }); - }()); + }); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.uniqueId'); + QUnit.module('lodash(...).commit'); (function() { - test('should generate unique ids', 1, function() { - var actual = []; - _.times(1000, function() { - actual.push(_.uniqueId()); - }); + QUnit.test('should execute the chained sequence and returns the wrapped result', function(assert) { + assert.expect(4); - equal(_.uniq(actual).length, actual.length); - }); + if (!isNpm) { + var array = [1], + wrapped = _(array).push(2).push(3); + + assert.deepEqual(array, [1]); - test('should return a string value when not passing a prefix argument', 1, function() { - equal(typeof _.uniqueId(), 'string'); + var otherWrapper = wrapped.commit(); + assert.ok(otherWrapper instanceof _); + assert.deepEqual(otherWrapper.value(), [1, 2, 3]); + assert.deepEqual(wrapped.value(), [1, 2, 3, 2, 3]); + } + else { + skipAssert(assert, 4); + } }); - test('should coerce the prefix argument to a string', 1, function() { - var actual = [_.uniqueId(3), _.uniqueId(2), _.uniqueId(1)]; - ok(/3\d+,2\d+,1\d+/.test(actual)); + QUnit.test('should track the `__chain__` value of a wrapper', function(assert) { + assert.expect(2); + + if (!isNpm) { + var wrapped = _([1]).chain().commit().head(); + assert.ok(wrapped instanceof _); + assert.strictEqual(wrapped.value(), 1); + } + else { + skipAssert(assert, 2); + } }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.values'); + QUnit.module('lodash(...).next'); - (function() { - test('should get the values of an object', 1, function() { - var object = { 'a': 1, 'b': 2 }; - deepEqual(_.values(object), [1, 2]); - }); + lodashStable.each([false, true], function(implicit) { + function chain(value) { + return implicit ? _(value) : _.chain(value); + } - test('should work with an object that has a `length` property', 1, function() { - var object = { '0': 'a', '1': 'b', 'length': 2 }; - deepEqual(_.values(object), ['a', 'b', 2]); + var chainType = 'in an ' + (implicit ? 'implicit' : 'explict') + ' chain'; + + QUnit.test('should follow the iterator protocol ' + chainType, function(assert) { + assert.expect(3); + + if (!isNpm) { + var wrapped = chain([1, 2]); + + assert.deepEqual(wrapped.next(), { 'done': false, 'value': 1 }); + assert.deepEqual(wrapped.next(), { 'done': false, 'value': 2 }); + assert.deepEqual(wrapped.next(), { 'done': true, 'value': undefined }); + } + else { + skipAssert(assert, 3); + } }); - }()); - QUnit.module('lodash.where'); + QUnit.test('should act as an iterable ' + chainType, function(assert) { + assert.expect(2); - (function() { - var array = [ - { 'a': 1 }, - { 'a': 1 }, - { 'a': 1, 'b': 2 }, - { 'a': 2, 'b': 2 }, - { 'a': 3 } - ]; + if (!isNpm && Symbol && Symbol.iterator) { + var array = [1, 2], + wrapped = chain(array); - test('should filter by properties', 6, function() { - deepEqual(_.where(array, { 'a': 1 }), [{ 'a': 1 }, { 'a': 1 }, { 'a': 1, 'b': 2 }]); - deepEqual(_.where(array, { 'a': 2 }), [{ 'a': 2, 'b': 2 }]); - deepEqual(_.where(array, { 'a': 3 }), [{ 'a': 3 }]); - deepEqual(_.where(array, { 'b': 1 }), []); - deepEqual(_.where(array, { 'b': 2 }), [{ 'a': 1, 'b': 2 }, { 'a': 2, 'b': 2 }]); - deepEqual(_.where(array, { 'a': 1, 'b': 2 }), [{ 'a': 1, 'b': 2 }]); + assert.strictEqual(wrapped[Symbol.iterator](), wrapped); + assert.deepEqual(lodashStable.toArray(wrapped), array); + } + else { + skipAssert(assert, 2); + } }); - test('should not filter by inherited properties', 1, function() { - function Foo() {} - Foo.prototype = { 'a': 2 }; + QUnit.test('should use `_.toArray` to generate the iterable result ' + chainType, function(assert) { + assert.expect(3); + + if (!isNpm && Array.from) { + var hearts = '\ud83d\udc95', + values = [[1], { 'a': 1 }, hearts]; - var properties = new Foo; - properties.b = 2; - deepEqual(_.where(array, properties), [{ 'a': 1, 'b': 2 }, { 'a': 2, 'b': 2 }]); + lodashStable.each(values, function(value) { + var wrapped = chain(value); + assert.deepEqual(Array.from(wrapped), _.toArray(value)); + }); + } + else { + skipAssert(assert, 3); + } }); - test('should filter by problem JScript properties (test in IE < 9)', 1, function() { - var collection = [shadowedObject]; - deepEqual(_.where(collection, shadowedObject), [shadowedObject]); + QUnit.test('should reset the iterator correctly ' + chainType, function(assert) { + assert.expect(4); + + if (!isNpm && Symbol && Symbol.iterator) { + var array = [1, 2], + wrapped = chain(array); + + assert.deepEqual(lodashStable.toArray(wrapped), array); + assert.deepEqual(lodashStable.toArray(wrapped), [], 'produces an empty array for exhausted iterator'); + + var other = wrapped.filter(); + assert.deepEqual(lodashStable.toArray(other), array, 'reset for new chain segments'); + assert.deepEqual(lodashStable.toArray(wrapped), [], 'iterator is still exhausted'); + } + else { + skipAssert(assert, 4); + } }); - test('should work with an object for `collection`', 1, function() { - var collection = { - 'x': { 'a': 1 }, - 'y': { 'a': 3 }, - 'z': { 'a': 1, 'b': 2 } - }; + QUnit.test('should work in a lazy sequence ' + chainType, function(assert) { + assert.expect(3); + + if (!isNpm && Symbol && Symbol.iterator) { + var array = lodashStable.range(LARGE_ARRAY_SIZE), + predicate = function(value) { values.push(value); return isEven(value); }, + values = [], + wrapped = chain(array); - deepEqual(_.where(collection, { 'a': 1 }), [{ 'a': 1 }, { 'a': 1, 'b': 2 }]); + assert.deepEqual(lodashStable.toArray(wrapped), array); + + wrapped = wrapped.filter(predicate); + assert.deepEqual(lodashStable.toArray(wrapped), _.filter(array, isEven), 'reset for new lazy chain segments'); + assert.deepEqual(values, array, 'memoizes iterator values'); + } + else { + skipAssert(assert, 3); + } }); + }); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash(...).plant'); + + (function() { + QUnit.test('should clone the chained sequence planting `value` as the wrapped value', function(assert) { + assert.expect(2); - test('should return an empty array when provided an empty `properties` object', 1, function() { - deepEqual(_.where(array, {}), []); + if (!isNpm) { + var array1 = [5, null, 3, null, 1], + array2 = [10, null, 8, null, 6], + wrapped1 = _(array1).thru(_.compact).map(square).takeRight(2).sort(), + wrapped2 = wrapped1.plant(array2); + + assert.deepEqual(wrapped2.value(), [36, 64]); + assert.deepEqual(wrapped1.value(), [1, 9]); + } + else { + skipAssert(assert, 2); + } }); - test('should deep compare `properties` values', 1, function() { - var collection = [{ 'a': { 'b': { 'c': 1, 'd': 2 }, 'e': 3 }, 'f': 4 }], - expected = _.cloneDeep(collection); + QUnit.test('should clone `chainAll` settings', function(assert) { + assert.expect(1); + + if (!isNpm) { + var array1 = [2, 4], + array2 = [6, 8], + wrapped1 = _(array1).chain().map(square), + wrapped2 = wrapped1.plant(array2); - deepEqual(_.where(collection, { 'a': { 'b': { 'c': 1 } } }), expected); + assert.deepEqual(wrapped2.head().value(), 36); + } + else { + skipAssert(assert); + } }); - test('should search of arrays for values', 2, function() { - var collection = [{ 'a': [1, 2] }], - expected = _.cloneDeep(collection); + QUnit.test('should reset iterator data on cloned sequences', function(assert) { + assert.expect(3); + + if (!isNpm && Symbol && Symbol.iterator) { + var array1 = [2, 4], + array2 = [6, 8], + wrapped1 = _(array1).map(square); + + assert.deepEqual(lodashStable.toArray(wrapped1), [4, 16]); + assert.deepEqual(lodashStable.toArray(wrapped1), []); - deepEqual(_.where(collection, { 'a': [] }), []); - deepEqual(_.where(collection, { 'a': [2] }), expected); + var wrapped2 = wrapped1.plant(array2); + assert.deepEqual(lodashStable.toArray(wrapped2), [36, 64]); + } + else { + skipAssert(assert, 3); + } }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.without'); + QUnit.module('lodash(...).pop'); (function() { - test('should use strict equality to determine the values to reject', 2, function() { - var object1 = { 'a': 1 }, - object2 = { 'b': 2 }, - array = [object1, object2]; + QUnit.test('should remove elements from the end of `array`', function(assert) { + assert.expect(5); + + if (!isNpm) { + var array = [1, 2], + wrapped = _(array); + + assert.strictEqual(wrapped.pop(), 2); + assert.deepEqual(wrapped.value(), [1]); + assert.strictEqual(wrapped.pop(), 1); - deepEqual(_.without(array, { 'a': 1 }), array); - deepEqual(_.without(array, object1), [object2]); + var actual = wrapped.value(); + assert.strictEqual(actual, array); + assert.deepEqual(actual, []); + } + else { + skipAssert(assert, 5); + } }); - test('should remove all occurrences of each value from an array', 1, function() { - var array = [1, 2, 3, 1, 2, 3]; - deepEqual(_.without(array, 1, 2), [3, 3]); + QUnit.test('should accept falsey arguments', function(assert) { + assert.expect(1); + + if (!isNpm) { + var expected = lodashStable.map(falsey, stubTrue); + + var actual = lodashStable.map(falsey, function(value, index) { + try { + var result = index ? _(value).pop() : _().pop(); + return result === undefined; + } catch (e) {} + }); + + assert.deepEqual(actual, expected); + } + else { + skipAssert(assert); + } }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.wrap'); + QUnit.module('lodash(...).push'); (function() { - test('should create a wrapped function', 1, function() { - var p = _.wrap(_.escape, function(func, text) { - return '

' + func(text) + '

'; - }); + QUnit.test('should append elements to `array`', function(assert) { + assert.expect(2); - equal(p('Fred, Wilma, & Pebbles'), '

Fred, Wilma, & Pebbles

'); - }); + if (!isNpm) { + var array = [1], + wrapped = _(array).push(2, 3), + actual = wrapped.value(); - test('should pass the correct `wrapper` arguments', 1, function() { - var args; + assert.strictEqual(actual, array); + assert.deepEqual(actual, [1, 2, 3]); + } + else { + skipAssert(assert, 2); + } + }); - var wrapped = _.wrap(noop, function() { - args || (args = slice.call(arguments)); - }); + QUnit.test('should accept falsey arguments', function(assert) { + assert.expect(1); - wrapped(1, 2, 3); - deepEqual(args, [noop, 1, 2, 3]); - }); + if (!isNpm) { + var expected = lodashStable.map(falsey, stubTrue); - test('should not set a `this` binding', 1, function() { - var p = _.wrap(_.escape, function(func) { - return '

' + func(this.text) + '

'; - }); + var actual = lodashStable.map(falsey, function(value, index) { + try { + var result = index ? _(value).push(1).value() : _().push(1).value(); + return lodashStable.eq(result, value); + } catch (e) {} + }); - var object = { 'p': p, 'text': 'Fred, Wilma, & Pebbles' }; - equal(object.p(), '

Fred, Wilma, & Pebbles

'); + assert.deepEqual(actual, expected); + } + else { + skipAssert(assert); + } }); }()); - /*--------------------------------------------------------------------------*/ + /*--------------------------------------------------------------------------*/ + + QUnit.module('lodash(...).shift'); + + (function() { + QUnit.test('should remove elements from the front of `array`', function(assert) { + assert.expect(5); + + if (!isNpm) { + var array = [1, 2], + wrapped = _(array); - QUnit.module('lodash.xor'); + assert.strictEqual(wrapped.shift(), 1); + assert.deepEqual(wrapped.value(), [2]); + assert.strictEqual(wrapped.shift(), 2); - (function() { - test('should return the symmetric difference of the given arrays', 1, function() { - var actual = _.xor([1, 2, 5], [2, 3, 5], [3, 4, 5]); - deepEqual(actual, [1, 4, 5]); + var actual = wrapped.value(); + assert.strictEqual(actual, array); + assert.deepEqual(actual, []); + } + else { + skipAssert(assert, 5); + } }); - test('should return an array of unique values', 1, function() { - var actual = _.xor([1, 1, 2, 5], [2, 2, 3, 5], [3, 4, 5, 5]); - deepEqual(actual, [1, 4, 5]); - }); + QUnit.test('should accept falsey arguments', function(assert) { + assert.expect(1); - test('should return a wrapped value when chaining', 2, function() { if (!isNpm) { - var actual = _([1, 2, 3]).xor([5, 2, 1, 4]); - ok(actual instanceof _); - deepEqual(actual.value(), [3, 5, 4]); + var expected = lodashStable.map(falsey, stubTrue); + + var actual = lodashStable.map(falsey, function(value, index) { + try { + var result = index ? _(value).shift() : _().shift(); + return result === undefined; + } catch (e) {} + }); + + assert.deepEqual(actual, expected); } else { - skipTest(2); + skipAssert(assert); } }); - - test('should ignore individual secondary values', 1, function() { - var array = [1, null, 3]; - deepEqual(_.xor(array, 3, null), array); - }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.zip'); + QUnit.module('lodash(...).sort'); (function() { - var object = { - 'an empty array': [ - [], - [] - ], - '0-tuples': [ - [[], []], - [] - ], - '2-tuples': [ - [['barney', 'fred'], [36, 40]], - [['barney', 36], ['fred', 40]] - ], - '3-tuples': [ - [['barney', 'fred'], [36, 40], [true, false]], - [['barney', 36, true], ['fred', 40, false]] - ] - }; + QUnit.test('should return the wrapped sorted `array`', function(assert) { + assert.expect(2); - _.forOwn(object, function(pair, key) { - test('should work with ' + key, 2, function() { - var actual = _.zip.apply(_, pair[0]); - deepEqual(actual, pair[1]); - deepEqual(_.zip.apply(_, actual), actual.length ? pair[0] : []); - }); - }); + if (!isNpm) { + var array = [3, 1, 2], + wrapped = _(array).sort(), + actual = wrapped.value(); - test('should work with tuples of different lengths', 4, function() { - var pair = [ - [['barney', 36], ['fred', 40, false]], - [['barney', 'fred'], [36, 40], [undefined, false]] - ]; + assert.strictEqual(actual, array); + assert.deepEqual(actual, [1, 2, 3]); + } + else { + skipAssert(assert, 2); + } + }); - var actual = _.zip(pair[0]); - ok(0 in actual[2]); - deepEqual(actual, pair[1]); + QUnit.test('should accept falsey arguments', function(assert) { + assert.expect(1); - actual = _.zip.apply(_, actual); - ok(2 in actual[0]); - deepEqual(actual, [['barney', 36, undefined], ['fred', 40, false]]); - }); + if (!isNpm) { + var expected = lodashStable.map(falsey, stubTrue); - test('should support consuming it\'s return value', 1, function() { - var expected = [['barney', 'fred'], [36, 40]]; - deepEqual(_.zip(_.zip(_.zip(_.zip(expected)))), expected); - }); + var actual = lodashStable.map(falsey, function(value, index) { + try { + var result = index ? _(value).sort().value() : _().sort().value(); + return lodashStable.eq(result, value); + } catch (e) {} + }); - test('should be aliased', 1, function() { - strictEqual(_.unzip, _.zip); + assert.deepEqual(actual, expected); + } + else { + skipAssert(assert); + } }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash.zipObject'); + QUnit.module('lodash(...).splice'); (function() { - var object = { 'barney': 36, 'fred': 40 }, - array = [['barney', 36], ['fred', 40]]; - - test('should skip falsey elements in a given two dimensional array', 1, function() { - var actual = _.zipObject(array.concat(falsey)); - deepEqual(actual, object); - }); + QUnit.test('should support removing and inserting elements', function(assert) { + assert.expect(5); - test('should zip together key/value arrays into an object', 1, function() { - var actual = _.zipObject(['barney', 'fred'], [36, 40]); - deepEqual(actual, object); - }); + if (!isNpm) { + var array = [1, 2], + wrapped = _(array); - test('should accept a two dimensional array', 1, function() { - var actual = _.zipObject(array); - deepEqual(actual, object); - }); + assert.deepEqual(wrapped.splice(1, 1, 3).value(), [2]); + assert.deepEqual(wrapped.value(), [1, 3]); + assert.deepEqual(wrapped.splice(0, 2).value(), [1, 3]); - test('should not assume `keys` is two dimensional if `values` is not provided', 1, function() { - var actual = _.zipObject(['barney', 'fred']); - deepEqual(actual, { 'barney': undefined, 'fred': undefined }); + var actual = wrapped.value(); + assert.strictEqual(actual, array); + assert.deepEqual(actual, []); + } + else { + skipAssert(assert, 5); + } }); - test('should accept a falsey `array` argument', 1, function() { - var expected = _.map(falsey, function() { return {}; }); - - var actual = _.map(falsey, function(value, index) { - try { - return index ? _.zipObject(value) : _.zipObject(); - } catch(e) { } - }); + QUnit.test('should accept falsey arguments', function(assert) { + assert.expect(1); - deepEqual(actual, expected); - }); + if (!isNpm) { + var expected = lodashStable.map(falsey, stubTrue); - test('should support consuming the return value of `_.pairs`', 1, function() { - deepEqual(_.zipObject(_.pairs(object)), object); - }); + var actual = lodashStable.map(falsey, function(value, index) { + try { + var result = index ? _(value).splice(0, 1).value() : _().splice(0, 1).value(); + return lodashStable.isEqual(result, []); + } catch (e) {} + }); - test('should be aliased', 1, function() { - strictEqual(_.object, _.zipObject); + assert.deepEqual(actual, expected); + } + else { + skipAssert(assert); + } }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash(...).shift'); + QUnit.module('lodash(...).unshift'); (function() { - test('should remove the value at index `0` when length is `0` (test in IE 8 compatibility mode)', 2, function() { + QUnit.test('should prepend elements to `array`', function(assert) { + assert.expect(2); + if (!isNpm) { - var wrapped = _({ '0': 1, 'length': 1 }); - wrapped.shift(); + var array = [3], + wrapped = _(array).unshift(1, 2), + actual = wrapped.value(); - deepEqual(wrapped.keys().value(), ['length']); - equal(wrapped.first(), undefined); + assert.strictEqual(actual, array); + assert.deepEqual(actual, [1, 2, 3]); } else { - skipTest(2); + skipAssert(assert, 2); } }); - }()); - - /*--------------------------------------------------------------------------*/ - QUnit.module('lodash(...).splice'); + QUnit.test('should accept falsey arguments', function(assert) { + assert.expect(1); - (function() { - test('should remove the value at index `0` when length is `0` (test in IE < 9, and in compatibility mode for IE9)', 2, function() { if (!isNpm) { - var wrapped = _({ '0': 1, 'length': 1 }); - wrapped.splice(0, 1); + var expected = lodashStable.map(falsey, stubTrue); + + var actual = lodashStable.map(falsey, function(value, index) { + try { + var result = index ? _(value).unshift(1).value() : _().unshift(1).value(); + return lodashStable.eq(result, value); + } catch (e) {} + }); - deepEqual(wrapped.keys().value(), ['length']); - equal(wrapped.first(), undefined); + assert.deepEqual(actual, expected); } else { - skipTest(2); + skipAssert(assert); } }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash(...).toString'); + QUnit.module('lodash(...).value'); (function() { - test('should return the `toString` result of the wrapped value', 1, function() { + QUnit.test('should execute the chained sequence and extract the unwrapped value', function(assert) { + assert.expect(4); + if (!isNpm) { - var wrapped = _([1, 2, 3]); - equal(String(wrapped), '1,2,3'); + var array = [1], + wrapped = _(array).push(2).push(3); + + assert.deepEqual(array, [1]); + assert.deepEqual(wrapped.value(), [1, 2, 3]); + assert.deepEqual(wrapped.value(), [1, 2, 3, 2, 3]); + assert.deepEqual(array, [1, 2, 3, 2, 3]); } else { - skipTest(); + skipAssert(assert, 4); } }); - }()); - /*--------------------------------------------------------------------------*/ - - QUnit.module('lodash(...).valueOf'); + QUnit.test('should return the `valueOf` result of the wrapped value', function(assert) { + assert.expect(1); - (function() { - test('should return the `valueOf` result of the wrapped value', 1, function() { if (!isNpm) { var wrapped = _(123); - equal(Number(wrapped), 123); + assert.strictEqual(Number(wrapped), 123); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should stringify the wrapped value when used by `JSON.stringify`', function(assert) { + assert.expect(1); + + if (!isNpm && JSON) { + var wrapped = _([1, 2, 3]); + assert.strictEqual(JSON.stringify(wrapped), '[1,2,3]'); + } + else { + skipAssert(assert); + } + }); + + QUnit.test('should be aliased', function(assert) { + assert.expect(2); + + if (!isNpm) { + var expected = _.prototype.value; + assert.strictEqual(_.prototype.toJSON, expected); + assert.strictEqual(_.prototype.valueOf, expected); } else { - skipTest(); + skipAssert(assert, 2); } }); }()); /*--------------------------------------------------------------------------*/ - QUnit.module('lodash(...) methods that return existing wrapped values'); + QUnit.module('lodash(...) methods that return the wrapped modified array'); (function() { - var array = [1, 2, 3], - wrapped = _(array); - var funcs = [ 'push', 'reverse', @@ -8287,13 +26536,20 @@ 'unshift' ]; - _.forEach(funcs, function(methodName) { - test('`_(...).' + methodName + '` should return the existing wrapped value', 1, function() { + lodashStable.each(funcs, function(methodName) { + QUnit.test('`_(...).' + methodName + '` should return a new wrapper', function(assert) { + assert.expect(2); + if (!isNpm) { - strictEqual(wrapped[methodName](), wrapped); + var array = [1, 2, 3], + wrapped = _(array), + actual = wrapped[methodName](); + + assert.ok(actual instanceof _); + assert.notStrictEqual(actual, wrapped); } else { - skipTest(); + skipAssert(assert, 2); } }); }); @@ -8304,22 +26560,50 @@ QUnit.module('lodash(...) methods that return new wrapped values'); (function() { - var array = [1, 2, 3], - wrapped = _(array); - var funcs = [ + 'castArray', 'concat', + 'difference', + 'differenceBy', + 'differenceWith', + 'intersection', + 'intersectionBy', + 'intersectionWith', + 'pull', + 'pullAll', + 'pullAt', + 'sampleSize', + 'shuffle', 'slice', - 'splice' + 'splice', + 'split', + 'toArray', + 'union', + 'unionBy', + 'unionWith', + 'uniq', + 'uniqBy', + 'uniqWith', + 'words', + 'xor', + 'xorBy', + 'xorWith' ]; - _.forEach(funcs, function(methodName) { - test('`_(...).' + methodName + '` should return a new wrapped value', 1, function() { + lodashStable.each(funcs, function(methodName) { + QUnit.test('`_(...).' + methodName + '` should return a new wrapped value', function(assert) { + assert.expect(2); + if (!isNpm) { - ok(wrapped[methodName]() instanceof _); + var value = methodName == 'split' ? 'abc' : [1, 2, 3], + wrapped = _(value), + actual = wrapped[methodName](); + + assert.ok(actual instanceof _); + assert.notStrictEqual(actual, wrapped); } else { - skipTest(); + skipAssert(assert, 2); } }); }); @@ -8330,125 +26614,124 @@ QUnit.module('lodash(...) methods that return unwrapped values'); (function() { - var array = [1, 2, 3], - wrapped = _(array); - var funcs = [ + 'add', + 'camelCase', + 'capitalize', + 'ceil', 'clone', - 'contains', + 'deburr', + 'defaultTo', + 'divide', + 'endsWith', + 'escape', + 'escapeRegExp', 'every', 'find', - 'first', + 'floor', 'has', + 'hasIn', + 'head', + 'includes', 'isArguments', 'isArray', + 'isArrayBuffer', + 'isArrayLike', 'isBoolean', + 'isBuffer', 'isDate', 'isElement', 'isEmpty', 'isEqual', + 'isError', 'isFinite', 'isFunction', + 'isInteger', + 'isMap', 'isNaN', + 'isNative', + 'isNil', 'isNull', 'isNumber', 'isObject', + 'isObjectLike', 'isPlainObject', 'isRegExp', + 'isSafeInteger', + 'isSet', 'isString', 'isUndefined', + 'isWeakMap', + 'isWeakSet', 'join', + 'kebabCase', 'last', + 'lowerCase', + 'lowerFirst', + 'max', + 'maxBy', + 'min', + 'minBy', + 'multiply', + 'nth', + 'pad', + 'padEnd', + 'padStart', + 'parseInt', 'pop', - 'shift', + 'random', 'reduce', 'reduceRight', - 'some' - ]; - - _.forEach(funcs, function(methodName) { - test('`_(...).' + methodName + '` should return an unwrapped value', 1, function() { - if (!isNpm) { - var actual = methodName == 'reduceRight' - ? wrapped[methodName](_.identity) - : wrapped[methodName](); - - equal(actual instanceof _, false); - } - else { - skipTest(); - } - }); - }); - }()); - - /*--------------------------------------------------------------------------*/ - - QUnit.module('lodash(...) methods capable of returning wrapped and unwrapped values'); - - (function() { - var array = [1, 2, 3], - wrapped = _(array); - - var funcs = [ - 'first', - 'last', - 'sample' + 'repeat', + 'replace', + 'round', + 'sample', + 'shift', + 'size', + 'snakeCase', + 'some', + 'startCase', + 'startsWith', + 'subtract', + 'sum', + 'toFinite', + 'toInteger', + 'toLower', + 'toNumber', + 'toSafeInteger', + 'toString', + 'toUpper', + 'trim', + 'trimEnd', + 'trimStart', + 'truncate', + 'unescape', + 'upperCase', + 'upperFirst' ]; - _.forEach(funcs, function(methodName) { - test('`_(...).' + methodName + '` called without an `n` argument should return an unwrapped value', 1, function() { - if (!isNpm) { - equal(typeof wrapped[methodName](), 'number'); - } - else { - skipTest(); - } - }); + lodashStable.each(funcs, function(methodName) { + QUnit.test('`_(...).' + methodName + '` should return an unwrapped value when implicitly chaining', function(assert) { + assert.expect(1); - test('`_(...).' + methodName + '` called with an `n` argument should return a wrapped value', 1, function() { if (!isNpm) { - ok(wrapped[methodName](1) instanceof _); + var actual = _()[methodName](); + assert.notOk(actual instanceof _); } else { - skipTest(); + skipAssert(assert); } }); - test('`_.' + methodName + '` should return `undefined` when querying falsey arguments without an `n` argument', 1, function() { - if (!isNpm) { - var actual = [], - expected = _.map(falsey, function() { return undefined; }), - func = _[methodName]; - - _.forEach(falsey, function(value, index) { - try { - actual.push(index ? func(value) : func()); - } catch(e) { } - }); - - deepEqual(actual, expected); - } - else { - skipTest(); - } - }); + QUnit.test('`_(...).' + methodName + '` should return a wrapped value when explicitly chaining', function(assert) { + assert.expect(1); - test('`_.' + methodName + '` should return an empty array when querying falsey arguments with an `n` argument', 1, function() { if (!isNpm) { - var expected = _.map(falsey, function() { return []; }), - func = _[methodName]; - - var actual = _.map(falsey, function(value, index) { - try { - return func(value, 2); - } catch(e) { } - }); - - deepEqual(actual, expected); + var actual = _().chain()[methodName](); + assert.ok(actual instanceof _); } else { - skipTest(); + skipAssert(assert); } }); }); @@ -8458,255 +26741,325 @@ QUnit.module('"Arrays" category methods'); - (function() { - var args = arguments, + (function() { + var args = toArgs([1, null, [3], null, 5]), + sortedArgs = toArgs([1, [3], 5, null, null]), array = [1, 2, 3, 4, 5, 6]; - test('should work with `arguments` objects', 23, function() { + QUnit.test('should work with `arguments` objects', function(assert) { + assert.expect(30); + function message(methodName) { return '`_.' + methodName + '` should work with `arguments` objects'; } - deepEqual(_.at(args, 0, 4), [1, 5], message('at')); - deepEqual(_.at(array, args), [2, undefined, 4, undefined, 6], '_.at should work with `arguments` objects as secondary arguments'); - - deepEqual(_.difference(args, [null]), [1, [3], 5], message('difference')); - deepEqual(_.difference(array, args), [2, 3, 4, 6], '_.difference should work with `arguments` objects as secondary arguments'); - - deepEqual(_.union(args, [null, 6]), [1, null, [3], 5, 6], message('union')); - deepEqual(_.union(array, args), array.concat([null, [3]]), '_.union should work with `arguments` objects as secondary arguments'); - - deepEqual(_.compact(args), [1, [3], 5], message('compact')); - deepEqual(_.findIndex(args, _.identity), 0, message('findIndex')); - deepEqual(_.findLastIndex(args, _.identity), 4, message('findLastIndex')); - deepEqual(_.first(args), 1, message('first')); - deepEqual(_.flatten(args), [1, null, 3, null, 5], message('flatten')); - deepEqual(_.indexOf(args, 5), 4, message('indexOf')); - deepEqual(_.initial(args, 4), [1], message('initial')); - deepEqual(_.intersection(args, [1]), [1], message('intersection')); - deepEqual(_.last(args), 5, message('last')); - deepEqual(_.lastIndexOf(args, 1), 0, message('lastIndexOf')); - deepEqual(_.rest(args, 4), [5], message('rest')); - deepEqual(_.sortedIndex(args, 6), 5, message('sortedIndex')); - deepEqual(_.uniq(args), [1, null, [3], 5], message('uniq')); - deepEqual(_.without(args, null), [1, [3], 5], message('without')); - deepEqual(_.zip(args, args), [[1, 1], [null, null], [[3], [3]], [null, null], [5, 5]], message('zip')); + assert.deepEqual(_.difference(args, [null]), [1, [3], 5], message('difference')); + assert.deepEqual(_.difference(array, args), [2, 3, 4, 6], '_.difference should work with `arguments` objects as secondary arguments'); + + assert.deepEqual(_.union(args, [null, 6]), [1, null, [3], 5, 6], message('union')); + assert.deepEqual(_.union(array, args), array.concat([null, [3]]), '_.union should work with `arguments` objects as secondary arguments'); + + assert.deepEqual(_.compact(args), [1, [3], 5], message('compact')); + assert.deepEqual(_.drop(args, 3), [null, 5], message('drop')); + assert.deepEqual(_.dropRight(args, 3), [1, null], message('dropRight')); + assert.deepEqual(_.dropRightWhile(args,identity), [1, null, [3], null], message('dropRightWhile')); + assert.deepEqual(_.dropWhile(args,identity), [null, [3], null, 5], message('dropWhile')); + assert.deepEqual(_.findIndex(args, identity), 0, message('findIndex')); + assert.deepEqual(_.findLastIndex(args, identity), 4, message('findLastIndex')); + assert.deepEqual(_.flatten(args), [1, null, 3, null, 5], message('flatten')); + assert.deepEqual(_.head(args), 1, message('head')); + assert.deepEqual(_.indexOf(args, 5), 4, message('indexOf')); + assert.deepEqual(_.initial(args), [1, null, [3], null], message('initial')); + assert.deepEqual(_.intersection(args, [1]), [1], message('intersection')); + assert.deepEqual(_.last(args), 5, message('last')); + assert.deepEqual(_.lastIndexOf(args, 1), 0, message('lastIndexOf')); + assert.deepEqual(_.sortedIndex(sortedArgs, 6), 3, message('sortedIndex')); + assert.deepEqual(_.sortedIndexOf(sortedArgs, 5), 2, message('sortedIndexOf')); + assert.deepEqual(_.sortedLastIndex(sortedArgs, 5), 3, message('sortedLastIndex')); + assert.deepEqual(_.sortedLastIndexOf(sortedArgs, 1), 0, message('sortedLastIndexOf')); + assert.deepEqual(_.tail(args, 4), [null, [3], null, 5], message('tail')); + assert.deepEqual(_.take(args, 2), [1, null], message('take')); + assert.deepEqual(_.takeRight(args, 1), [5], message('takeRight')); + assert.deepEqual(_.takeRightWhile(args, identity), [5], message('takeRightWhile')); + assert.deepEqual(_.takeWhile(args, identity), [1], message('takeWhile')); + assert.deepEqual(_.uniq(args), [1, null, [3], 5], message('uniq')); + assert.deepEqual(_.without(args, null), [1, [3], 5], message('without')); + assert.deepEqual(_.zip(args, args), [[1, 1], [null, null], [[3], [3]], [null, null], [5, 5]], message('zip')); + }); + + QUnit.test('should accept falsey primary arguments', function(assert) { + assert.expect(4); - if (_.support.argsClass && _.support.argsObject && !_.support.nonEnumArgs) { - _.pull(args, null); - deepEqual([args[0], args[1], args[2]], [1, [3], 5], message('pull')); - - _.remove(args, function(value) { return typeof value == 'number'; }); - ok(args.length == 1 && _.isEqual(args[0], [3]), message('remove')); - } - else { - skipTest(2) - } - }); - - test('should accept falsey primary arguments', 3, function() { function message(methodName) { return '`_.' + methodName + '` should accept falsey primary arguments'; } - deepEqual(_.difference(null, array), [], message('difference')); - deepEqual(_.intersection(null, array), [], message('intersection')); - deepEqual(_.union(null, array), array, message('union')); + assert.deepEqual(_.difference(null, array), [], message('difference')); + assert.deepEqual(_.intersection(null, array), [], message('intersection')); + assert.deepEqual(_.union(null, array), array, message('union')); + assert.deepEqual(_.xor(null, array), array, message('xor')); }); - test('should accept falsey secondary arguments', 3, function() { + QUnit.test('should accept falsey secondary arguments', function(assert) { + assert.expect(3); + function message(methodName) { return '`_.' + methodName + '` should accept falsey secondary arguments'; } - deepEqual(_.difference(array, null), array, message('difference')); - deepEqual(_.intersection(array, null), [], message('intersection')); - deepEqual(_.union(array, null), array, message('union')); + assert.deepEqual(_.difference(array, null), array, message('difference')); + assert.deepEqual(_.intersection(array, null), [], message('intersection')); + assert.deepEqual(_.union(array, null), array, message('union')); + }); + }()); + + /*--------------------------------------------------------------------------*/ + + QUnit.module('"Strings" category methods'); + + (function() { + var stringMethods = [ + 'camelCase', + 'capitalize', + 'escape', + 'kebabCase', + 'lowerCase', + 'lowerFirst', + 'pad', + 'padEnd', + 'padStart', + 'repeat', + 'snakeCase', + 'toLower', + 'toUpper', + 'trim', + 'trimEnd', + 'trimStart', + 'truncate', + 'unescape', + 'upperCase', + 'upperFirst' + ]; + + lodashStable.each(stringMethods, function(methodName) { + var func = _[methodName]; + + QUnit.test('`_.' + methodName + '` should return an empty string for empty values', function(assert) { + assert.expect(1); + + var values = [, null, undefined, ''], + expected = lodashStable.map(values, stubString); + + var actual = lodashStable.map(values, function(value, index) { + return index ? func(value) : func(); + }); + + assert.deepEqual(actual, expected); + }); }); - }(1, null, [3], null, 5)); + }()); /*--------------------------------------------------------------------------*/ QUnit.module('lodash methods'); (function() { - var allMethods = _.reject(_.functions(_), function(methodName) { - return /^_/.test(methodName); + var allMethods = lodashStable.reject(_.functions(_).sort(), function(methodName) { + return lodashStable.startsWith(methodName, '_'); }); + var checkFuncs = [ + 'after', + 'ary', + 'before', + 'bind', + 'curry', + 'curryRight', + 'debounce', + 'defer', + 'delay', + 'flip', + 'flow', + 'flowRight', + 'memoize', + 'negate', + 'once', + 'partial', + 'partialRight', + 'rearg', + 'rest', + 'spread', + 'throttle', + 'unary' + ]; + + var noBinding = [ + 'flip', + 'memoize', + 'negate', + 'once', + 'overArgs', + 'partial', + 'partialRight', + 'rearg', + 'rest', + 'spread' + ]; + + var rejectFalsey = [ + 'tap', + 'thru' + ].concat(checkFuncs); + var returnArrays = [ 'at', + 'chunk', 'compact', 'difference', + 'drop', 'filter', 'flatten', 'functions', 'initial', 'intersection', - 'invoke', + 'invokeMap', 'keys', 'map', - 'pairs', - 'pluck', + 'orderBy', + 'pull', + 'pullAll', + 'pullAt', 'range', + 'rangeRight', 'reject', - 'rest', + 'remove', 'shuffle', 'sortBy', + 'tail', + 'take', 'times', 'toArray', + 'toPairs', + 'toPairsIn', 'union', 'uniq', 'values', - 'where', 'without', 'xor', 'zip' ]; - var rejectFalsey = [ - 'after', - 'bind', - 'compose', - 'curry', - 'debounce', - 'defer', - 'delay', - 'memoize', - 'once', - 'partial', - 'partialRight', - 'tap', - 'throttle', - 'wrap' - ]; - - var acceptFalsey = _.difference(allMethods, rejectFalsey); + var acceptFalsey = lodashStable.difference(allMethods, rejectFalsey); - test('should accept falsey arguments', 155, function() { - var isExported = '_' in root, - oldDash = root._; + QUnit.test('should accept falsey arguments', function(assert) { + assert.expect(316); + var arrays = lodashStable.map(falsey, stubArray); - _.forEach(acceptFalsey, function(methodName) { - var expected = _.map(falsey, function() { return []; }), - func = _[methodName], - pass = true; + lodashStable.each(acceptFalsey, function(methodName) { + var expected = arrays, + func = _[methodName]; - var actual = _.map(falsey, function(value, index) { - try { - return index ? func(value) : func(); - } catch(e) { - pass = false; - } + var actual = lodashStable.map(falsey, function(value, index) { + return index ? func(value) : func(); }); if (methodName == 'noConflict') { - if (isExported) { - root._ = oldDash; - } else { - delete root._; - } + root._ = oldDash; } - if (_.indexOf(returnArrays, methodName) > -1) { - deepEqual(actual, expected, '_.' + methodName + ' returns an array'); + else if (methodName == 'pull' || methodName == 'pullAll') { + expected = falsey; } - ok(pass, '`_.' + methodName + '` accepts falsey arguments'); + if (lodashStable.includes(returnArrays, methodName) && methodName != 'sample') { + assert.deepEqual(actual, expected, '_.' + methodName + ' returns an array'); + } + assert.ok(true, '`_.' + methodName + '` accepts falsey arguments'); }); - // skip tests for missing methods of modularized builds - _.forEach(['noConflict', 'runInContext', 'tap'], function(methodName) { + // Skip tests for missing methods of modularized builds. + lodashStable.each(['chain', 'noConflict', 'runInContext'], function(methodName) { if (!_[methodName]) { - skipTest(); + skipAssert(assert); + } + }); + }); + + QUnit.test('should return an array', function(assert) { + assert.expect(70); + + var array = [1, 2, 3]; + + lodashStable.each(returnArrays, function(methodName) { + var actual, + func = _[methodName]; + + switch (methodName) { + case 'invokeMap': + actual = func(array, 'toFixed'); + break; + case 'sample': + actual = func(array, 1); + break; + default: + actual = func(array); } + assert.ok(lodashStable.isArray(actual), '_.' + methodName + ' returns an array'); + + var isPull = methodName == 'pull' || methodName == 'pullAll'; + assert.strictEqual(actual === array, isPull, '_.' + methodName + ' should ' + (isPull ? '' : 'not ') + 'return the given array'); }); }); - test('should reject falsey arguments', 14, function() { - _.forEach(rejectFalsey, function(methodName) { - var expected = _.map(falsey, function() { return true; }), + QUnit.test('should throw an error for falsey arguments', function(assert) { + assert.expect(24); + + lodashStable.each(rejectFalsey, function(methodName) { + var expected = lodashStable.map(falsey, stubTrue), func = _[methodName]; - var actual = _.map(falsey, function(value, index) { - var pass = !index && methodName == 'compose'; + var actual = lodashStable.map(falsey, function(value, index) { + var pass = !index && /^(?:backflow|compose|cond|flow(Right)?|over(?:Every|Some)?)$/.test(methodName); + try { index ? func(value) : func(); - } catch(e) { - pass = !pass; + } catch (e) { + pass = !pass && (e instanceof TypeError) && + (!lodashStable.includes(checkFuncs, methodName) || (e.message == FUNC_ERROR_TEXT)); } return pass; }); - deepEqual(actual, expected, '`_.' + methodName + '` rejects falsey arguments'); + assert.deepEqual(actual, expected, '`_.' + methodName + '` rejects falsey arguments'); }); }); - test('should handle `null` `thisArg` arguments', 30, function() { - var thisArg, - callback = function() { thisArg = this; }, - expected = (function() { return this; }).call(null); + QUnit.test('should use `this` binding of function', function(assert) { + assert.expect(30); - var funcs = [ - 'countBy', - 'every', - 'filter', - 'find', - 'findIndex', - 'findKey', - 'findLast', - 'findLastIndex', - 'findLastKey', - 'forEach', - 'forEachRight', - 'forIn', - 'forInRight', - 'forOwn', - 'forOwnRight', - 'groupBy', - 'map', - 'max', - 'min', - 'omit', - 'pick', - 'reduce', - 'reduceRight', - 'reject', - 'remove', - 'some', - 'sortBy', - 'sortedIndex', - 'times', - 'uniq' - ]; - - _.forEach(funcs, function(methodName) { - var array = ['a'], + lodashStable.each(noBinding, function(methodName) { + var fn = function() { return this.a; }, func = _[methodName], - message = '`_.' + methodName + '` handles `null` `thisArg` arguments'; + isNegate = methodName == 'negate', + object = { 'a': 1 }, + expected = isNegate ? false : 1; - thisArg = undefined; + var wrapper = func(_.bind(fn, object)); + assert.strictEqual(wrapper(), expected, '`_.' + methodName + '` can consume a bound function'); - if (/^reduce/.test(methodName)) { - func(array, callback, 0, null); - } else if (methodName == 'sortedIndex') { - func(array, 'a', callback, null); - } else if (methodName == 'times') { - func(1, callback, null); - } else { - func(array, callback, null); - } + wrapper = _.bind(func(fn), object); + assert.strictEqual(wrapper(), expected, '`_.' + methodName + '` can be bound'); - if (expected === null) { - strictEqual(thisArg, null, message); - } else { - equal(thisArg, expected, message); - } + object.wrapper = func(fn); + assert.strictEqual(object.wrapper(), expected, '`_.' + methodName + '` uses the `this` of its parent object'); }); }); - test('should not contain minified method names (test production builds)', 1, function() { - ok(_.every(_.functions(_), function(methodName) { - return methodName.length > 2 || methodName == 'at'; + QUnit.test('should not contain minified method names (test production builds)', function(assert) { + assert.expect(1); + + var shortNames = ['_', 'at', 'eq', 'gt', 'lt']; + assert.ok(lodashStable.every(_.functions(_), function(methodName) { + return methodName.length > 2 || lodashStable.includes(shortNames, methodName); })); }); }()); @@ -8714,9 +27067,11 @@ /*--------------------------------------------------------------------------*/ QUnit.config.asyncRetries = 10; + QUnit.config.hidepassed = true; if (!document) { QUnit.config.noglobals = true; + QUnit.load(); QUnit.start(); } -}(typeof global == 'object' && global || this)); +}.call(this)); diff --git a/test/underscore.html b/test/underscore.html index 8ae160616f..23f6e61cf7 100644 --- a/test/underscore.html +++ b/test/underscore.html @@ -1,205 +1,466 @@ - - - Underscore Test Suite - - - - -

- - - - - - + + + + + + + - - - + // Only excuse in Sauce Labs. + if (!ui.isSauceLabs) { + delete QUnit.config.excused.Functions['throttle does not trigger trailing call when trailing is set to false']; + delete QUnit.config.excused.Utility.now; + } + // Load prerequisite scripts. + document.write(ui.urlParams.loader == 'none' + ? ' + + + diff --git a/vendor/backbone/LICENSE b/vendor/backbone/LICENSE index dda0a5809d..02c89b2608 100644 --- a/vendor/backbone/LICENSE +++ b/vendor/backbone/LICENSE @@ -1,4 +1,4 @@ -Copyright (c) 2010-2013 Jeremy Ashkenas, DocumentCloud +Copyright (c) 2010-2016 Jeremy Ashkenas, DocumentCloud Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation diff --git a/vendor/backbone/backbone.js b/vendor/backbone/backbone.js index f7783c2c19..02722ac811 100644 --- a/vendor/backbone/backbone.js +++ b/vendor/backbone/backbone.js @@ -1,49 +1,54 @@ -// Backbone.js 1.1.0 +// Backbone.js 1.3.3 -// (c) 2010-2011 Jeremy Ashkenas, DocumentCloud Inc. -// (c) 2011-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors +// (c) 2010-2016 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors // Backbone may be freely distributed under the MIT license. // For all details and documentation: // http://backbonejs.org -(function(){ +(function(factory) { + + // Establish the root object, `window` (`self`) in the browser, or `global` on the server. + // We use `self` instead of `window` for `WebWorker` support. + var root = (typeof self == 'object' && self.self === self && self) || + (typeof global == 'object' && global.global === global && global); + + // Set up Backbone appropriately for the environment. Start with AMD. + if (typeof define === 'function' && define.amd) { + define(['underscore', 'jquery', 'exports'], function(_, $, exports) { + // Export global even in AMD case in case this script is loaded with + // others that may still expect a global Backbone. + root.Backbone = factory(root, exports, _, $); + }); + + // Next for Node.js or CommonJS. jQuery may not be needed as a module. + } else if (typeof exports !== 'undefined') { + var _ = require('underscore'), $; + try { $ = require('jquery'); } catch (e) {} + factory(root, exports, _, $); + + // Finally, as a browser global. + } else { + root.Backbone = factory(root, {}, root._, (root.jQuery || root.Zepto || root.ender || root.$)); + } + +})(function(root, Backbone, _, $) { // Initial Setup // ------------- - // Save a reference to the global object (`window` in the browser, `exports` - // on the server). - var root = this; - // Save the previous value of the `Backbone` variable, so that it can be // restored later on, if `noConflict` is used. var previousBackbone = root.Backbone; - // Create local references to array methods we'll want to use later. - var array = []; - var push = array.push; - var slice = array.slice; - var splice = array.splice; - - // The top-level namespace. All public Backbone classes and modules will - // be attached to this. Exported for both the browser and the server. - var Backbone; - if (typeof exports !== 'undefined') { - Backbone = exports; - } else { - Backbone = root.Backbone = {}; - } + // Create a local reference to a common array method we'll want to use later. + var slice = Array.prototype.slice; // Current version of the library. Keep in sync with `package.json`. - Backbone.VERSION = '1.1.0'; - - // Require Underscore, if we're on the server, and it's not already present. - var _ = root._; - if (!_ && (typeof require !== 'undefined')) _ = require('underscore'); + Backbone.VERSION = '1.3.3'; // For Backbone's purposes, jQuery, Zepto, Ender, or My Library (kidding) owns // the `$` variable. - Backbone.$ = root.jQuery || root.Zepto || root.ender || root.$; + Backbone.$ = $; // Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable // to its previous owner. Returns a reference to this Backbone object. @@ -58,17 +63,65 @@ Backbone.emulateHTTP = false; // Turn on `emulateJSON` to support legacy servers that can't deal with direct - // `application/json` requests ... will encode the body as + // `application/json` requests ... this will encode the body as // `application/x-www-form-urlencoded` instead and will send the model in a // form param named `model`. Backbone.emulateJSON = false; + // Proxy Backbone class methods to Underscore functions, wrapping the model's + // `attributes` object or collection's `models` array behind the scenes. + // + // collection.filter(function(model) { return model.get('age') > 10 }); + // collection.each(this.addView); + // + // `Function#apply` can be slow so we use the method's arg count, if we know it. + var addMethod = function(length, method, attribute) { + switch (length) { + case 1: return function() { + return _[method](this[attribute]); + }; + case 2: return function(value) { + return _[method](this[attribute], value); + }; + case 3: return function(iteratee, context) { + return _[method](this[attribute], cb(iteratee, this), context); + }; + case 4: return function(iteratee, defaultVal, context) { + return _[method](this[attribute], cb(iteratee, this), defaultVal, context); + }; + default: return function() { + var args = slice.call(arguments); + args.unshift(this[attribute]); + return _[method].apply(_, args); + }; + } + }; + var addUnderscoreMethods = function(Class, methods, attribute) { + _.each(methods, function(length, method) { + if (_[method]) Class.prototype[method] = addMethod(length, method, attribute); + }); + }; + + // Support `collection.sortBy('attr')` and `collection.findWhere({id: 1})`. + var cb = function(iteratee, instance) { + if (_.isFunction(iteratee)) return iteratee; + if (_.isObject(iteratee) && !instance._isModel(iteratee)) return modelMatcher(iteratee); + if (_.isString(iteratee)) return function(model) { return model.get(iteratee); }; + return iteratee; + }; + var modelMatcher = function(attrs) { + var matcher = _.matches(attrs); + return function(model) { + return matcher(model.attributes); + }; + }; + // Backbone.Events // --------------- // A module that can be mixed in to *any object* in order to provide it with - // custom events. You may bind with `on` or remove with `off` callback - // functions to an event; `trigger`-ing an event fires all callbacks in + // a custom event channel. You may bind a callback to an event with `on` or + // remove with `off`; `trigger`-ing an event fires all callbacks in // succession. // // var object = {}; @@ -76,123 +129,234 @@ // object.on('expand', function(){ alert('expanded'); }); // object.trigger('expand'); // - var Events = Backbone.Events = { - - // Bind an event to a `callback` function. Passing `"all"` will bind - // the callback to all events fired. - on: function(name, callback, context) { - if (!eventsApi(this, 'on', name, [callback, context]) || !callback) return this; - this._events || (this._events = {}); - var events = this._events[name] || (this._events[name] = []); - events.push({callback: callback, context: context, ctx: context || this}); - return this; - }, + var Events = Backbone.Events = {}; - // Bind an event to only be triggered a single time. After the first time - // the callback is invoked, it will be removed. - once: function(name, callback, context) { - if (!eventsApi(this, 'once', name, [callback, context]) || !callback) return this; - var self = this; - var once = _.once(function() { - self.off(name, once); - callback.apply(this, arguments); - }); - once._callback = callback; - return this.on(name, once, context); - }, - - // Remove one or many callbacks. If `context` is null, removes all - // callbacks with that function. If `callback` is null, removes all - // callbacks for the event. If `name` is null, removes all bound - // callbacks for all events. - off: function(name, callback, context) { - var retain, ev, events, names, i, l, j, k; - if (!this._events || !eventsApi(this, 'off', name, [callback, context])) return this; - if (!name && !callback && !context) { - this._events = {}; - return this; + // Regular expression used to split event strings. + var eventSplitter = /\s+/; + + // Iterates over the standard `event, callback` (as well as the fancy multiple + // space-separated events `"change blur", callback` and jQuery-style event + // maps `{event: callback}`). + var eventsApi = function(iteratee, events, name, callback, opts) { + var i = 0, names; + if (name && typeof name === 'object') { + // Handle event maps. + if (callback !== void 0 && 'context' in opts && opts.context === void 0) opts.context = callback; + for (names = _.keys(name); i < names.length ; i++) { + events = eventsApi(iteratee, events, names[i], name[names[i]], opts); } - names = name ? [name] : _.keys(this._events); - for (i = 0, l = names.length; i < l; i++) { - name = names[i]; - if (events = this._events[name]) { - this._events[name] = retain = []; - if (callback || context) { - for (j = 0, k = events.length; j < k; j++) { - ev = events[j]; - if ((callback && callback !== ev.callback && callback !== ev.callback._callback) || - (context && context !== ev.context)) { - retain.push(ev); - } - } - } - if (!retain.length) delete this._events[name]; - } + } else if (name && eventSplitter.test(name)) { + // Handle space-separated event names by delegating them individually. + for (names = name.split(eventSplitter); i < names.length; i++) { + events = iteratee(events, names[i], callback, opts); } + } else { + // Finally, standard events. + events = iteratee(events, name, callback, opts); + } + return events; + }; - return this; - }, + // Bind an event to a `callback` function. Passing `"all"` will bind + // the callback to all events fired. + Events.on = function(name, callback, context) { + return internalOn(this, name, callback, context); + }; - // Trigger one or many events, firing all bound callbacks. Callbacks are - // passed the same arguments as `trigger` is, apart from the event name - // (unless you're listening on `"all"`, which will cause your callback to - // receive the true name of the event as the first argument). - trigger: function(name) { - if (!this._events) return this; - var args = slice.call(arguments, 1); - if (!eventsApi(this, 'trigger', name, args)) return this; - var events = this._events[name]; - var allEvents = this._events.all; - if (events) triggerEvents(events, args); - if (allEvents) triggerEvents(allEvents, arguments); - return this; - }, + // Guard the `listening` argument from the public API. + var internalOn = function(obj, name, callback, context, listening) { + obj._events = eventsApi(onApi, obj._events || {}, name, callback, { + context: context, + ctx: obj, + listening: listening + }); - // Tell this object to stop listening to either specific events ... or - // to every object it's currently listening to. - stopListening: function(obj, name, callback) { - var listeningTo = this._listeningTo; - if (!listeningTo) return this; - var remove = !name && !callback; - if (!callback && typeof name === 'object') callback = this; - if (obj) (listeningTo = {})[obj._listenId] = obj; - for (var id in listeningTo) { - obj = listeningTo[id]; - obj.off(name, callback, this); - if (remove || _.isEmpty(obj._events)) delete this._listeningTo[id]; - } - return this; + if (listening) { + var listeners = obj._listeners || (obj._listeners = {}); + listeners[listening.id] = listening; } + return obj; }; - // Regular expression used to split event strings. - var eventSplitter = /\s+/; + // Inversion-of-control versions of `on`. Tell *this* object to listen to + // an event in another object... keeping track of what it's listening to + // for easier unbinding later. + Events.listenTo = function(obj, name, callback) { + if (!obj) return this; + var id = obj._listenId || (obj._listenId = _.uniqueId('l')); + var listeningTo = this._listeningTo || (this._listeningTo = {}); + var listening = listeningTo[id]; + + // This object is not listening to any other events on `obj` yet. + // Setup the necessary references to track the listening callbacks. + if (!listening) { + var thisId = this._listenId || (this._listenId = _.uniqueId('l')); + listening = listeningTo[id] = {obj: obj, objId: id, id: thisId, listeningTo: listeningTo, count: 0}; + } + + // Bind callbacks on obj, and keep track of them on listening. + internalOn(obj, name, callback, this, listening); + return this; + }; + + // The reducing API that adds a callback to the `events` object. + var onApi = function(events, name, callback, options) { + if (callback) { + var handlers = events[name] || (events[name] = []); + var context = options.context, ctx = options.ctx, listening = options.listening; + if (listening) listening.count++; - // Implement fancy features of the Events API such as multiple event - // names `"change blur"` and jQuery-style event maps `{change: action}` - // in terms of the existing API. - var eventsApi = function(obj, action, name, rest) { - if (!name) return true; + handlers.push({callback: callback, context: context, ctx: context || ctx, listening: listening}); + } + return events; + }; + + // Remove one or many callbacks. If `context` is null, removes all + // callbacks with that function. If `callback` is null, removes all + // callbacks for the event. If `name` is null, removes all bound + // callbacks for all events. + Events.off = function(name, callback, context) { + if (!this._events) return this; + this._events = eventsApi(offApi, this._events, name, callback, { + context: context, + listeners: this._listeners + }); + return this; + }; + + // Tell this object to stop listening to either specific events ... or + // to every object it's currently listening to. + Events.stopListening = function(obj, name, callback) { + var listeningTo = this._listeningTo; + if (!listeningTo) return this; + + var ids = obj ? [obj._listenId] : _.keys(listeningTo); + + for (var i = 0; i < ids.length; i++) { + var listening = listeningTo[ids[i]]; + + // If listening doesn't exist, this object is not currently + // listening to obj. Break out early. + if (!listening) break; + + listening.obj.off(name, callback, this); + } - // Handle event maps. - if (typeof name === 'object') { - for (var key in name) { - obj[action].apply(obj, [key, name[key]].concat(rest)); + return this; + }; + + // The reducing API that removes a callback from the `events` object. + var offApi = function(events, name, callback, options) { + if (!events) return; + + var i = 0, listening; + var context = options.context, listeners = options.listeners; + + // Delete all events listeners and "drop" events. + if (!name && !callback && !context) { + var ids = _.keys(listeners); + for (; i < ids.length; i++) { + listening = listeners[ids[i]]; + delete listeners[listening.id]; + delete listening.listeningTo[listening.objId]; } - return false; + return; } - // Handle space separated event names. - if (eventSplitter.test(name)) { - var names = name.split(eventSplitter); - for (var i = 0, l = names.length; i < l; i++) { - obj[action].apply(obj, [names[i]].concat(rest)); + var names = name ? [name] : _.keys(events); + for (; i < names.length; i++) { + name = names[i]; + var handlers = events[name]; + + // Bail out if there are no events stored. + if (!handlers) break; + + // Replace events if there are any remaining. Otherwise, clean up. + var remaining = []; + for (var j = 0; j < handlers.length; j++) { + var handler = handlers[j]; + if ( + callback && callback !== handler.callback && + callback !== handler.callback._callback || + context && context !== handler.context + ) { + remaining.push(handler); + } else { + listening = handler.listening; + if (listening && --listening.count === 0) { + delete listeners[listening.id]; + delete listening.listeningTo[listening.objId]; + } + } } - return false; + + // Update tail event if the list has any events. Otherwise, clean up. + if (remaining.length) { + events[name] = remaining; + } else { + delete events[name]; + } + } + return events; + }; + + // Bind an event to only be triggered a single time. After the first time + // the callback is invoked, its listener will be removed. If multiple events + // are passed in using the space-separated syntax, the handler will fire + // once for each event, not once for a combination of all events. + Events.once = function(name, callback, context) { + // Map the event into a `{event: once}` object. + var events = eventsApi(onceMap, {}, name, callback, _.bind(this.off, this)); + if (typeof name === 'string' && context == null) callback = void 0; + return this.on(events, callback, context); + }; + + // Inversion-of-control versions of `once`. + Events.listenToOnce = function(obj, name, callback) { + // Map the event into a `{event: once}` object. + var events = eventsApi(onceMap, {}, name, callback, _.bind(this.stopListening, this, obj)); + return this.listenTo(obj, events); + }; + + // Reduces the event callbacks into a map of `{event: onceWrapper}`. + // `offer` unbinds the `onceWrapper` after it has been called. + var onceMap = function(map, name, callback, offer) { + if (callback) { + var once = map[name] = _.once(function() { + offer(name, once); + callback.apply(this, arguments); + }); + once._callback = callback; } + return map; + }; + + // Trigger one or many events, firing all bound callbacks. Callbacks are + // passed the same arguments as `trigger` is, apart from the event name + // (unless you're listening on `"all"`, which will cause your callback to + // receive the true name of the event as the first argument). + Events.trigger = function(name) { + if (!this._events) return this; + + var length = Math.max(0, arguments.length - 1); + var args = Array(length); + for (var i = 0; i < length; i++) args[i] = arguments[i + 1]; - return true; + eventsApi(triggerApi, this._events, name, void 0, args); + return this; + }; + + // Handles triggering the appropriate event callbacks. + var triggerApi = function(objEvents, name, callback, args) { + if (objEvents) { + var events = objEvents[name]; + var allEvents = objEvents.all; + if (events && allEvents) allEvents = allEvents.slice(); + if (events) triggerEvents(events, args); + if (allEvents) triggerEvents(allEvents, [name].concat(args)); + } + return objEvents; }; // A difficult-to-believe, but optimized internal dispatch function for @@ -205,26 +369,10 @@ case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1); return; case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2); return; case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2, a3); return; - default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args); + default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args); return; } }; - var listenMethods = {listenTo: 'on', listenToOnce: 'once'}; - - // Inversion-of-control versions of `on` and `once`. Tell *this* object to - // listen to an event in another object ... keeping track of what it's - // listening to. - _.each(listenMethods, function(implementation, method) { - Events[method] = function(obj, name, callback) { - var listeningTo = this._listeningTo || (this._listeningTo = {}); - var id = obj._listenId || (obj._listenId = _.uniqueId('l')); - listeningTo[id] = obj; - if (!callback && typeof name === 'object') callback = this; - obj[implementation](name, callback, this); - return this; - }; - }); - // Aliases for backwards compatibility. Events.bind = Events.on; Events.unbind = Events.off; @@ -246,11 +394,13 @@ var Model = Backbone.Model = function(attributes, options) { var attrs = attributes || {}; options || (options = {}); - this.cid = _.uniqueId('c'); + this.preinitialize.apply(this, arguments); + this.cid = _.uniqueId(this.cidPrefix); this.attributes = {}; if (options.collection) this.collection = options.collection; if (options.parse) attrs = this.parse(attrs, options) || {}; - attrs = _.defaults({}, attrs, _.result(this, 'defaults')); + var defaults = _.result(this, 'defaults'); + attrs = _.defaults(_.extend({}, defaults, attrs), defaults); this.set(attrs, options); this.changed = {}; this.initialize.apply(this, arguments); @@ -269,6 +419,14 @@ // CouchDB users may want to set this to `"_id"`. idAttribute: 'id', + // The prefix is used to create the client id which is used to identify models locally. + // You may want to override this if you're experiencing name clashes with model ids. + cidPrefix: 'c', + + // preinitialize is an empty function by default. You can override it with a function + // or object. preinitialize will run before any instantiation logic is run in the Model. + preinitialize: function(){}, + // Initialize is an empty function by default. Override it with your own // initialization logic. initialize: function(){}, @@ -300,14 +458,19 @@ return this.get(attr) != null; }, + // Special-cased proxy to underscore's `_.matches` method. + matches: function(attrs) { + return !!_.iteratee(attrs, this)(this.attributes); + }, + // Set a hash of model attributes on the object, firing `"change"`. This is // the core primitive operation of a model, updating the data and notifying // anyone who needs to know about the change in state. The heart of the beast. set: function(key, val, options) { - var attr, attrs, unset, changes, silent, changing, prev, current; if (key == null) return this; // Handle both `"key", value` and `{key: value}` -style arguments. + var attrs; if (typeof key === 'object') { attrs = key; options = val; @@ -321,37 +484,40 @@ if (!this._validate(attrs, options)) return false; // Extract attributes and options. - unset = options.unset; - silent = options.silent; - changes = []; - changing = this._changing; - this._changing = true; + var unset = options.unset; + var silent = options.silent; + var changes = []; + var changing = this._changing; + this._changing = true; if (!changing) { this._previousAttributes = _.clone(this.attributes); this.changed = {}; } - current = this.attributes, prev = this._previousAttributes; - // Check for changes of `id`. - if (this.idAttribute in attrs) this.id = attrs[this.idAttribute]; + var current = this.attributes; + var changed = this.changed; + var prev = this._previousAttributes; // For each `set` attribute, update or delete the current value. - for (attr in attrs) { + for (var attr in attrs) { val = attrs[attr]; if (!_.isEqual(current[attr], val)) changes.push(attr); if (!_.isEqual(prev[attr], val)) { - this.changed[attr] = val; + changed[attr] = val; } else { - delete this.changed[attr]; + delete changed[attr]; } unset ? delete current[attr] : current[attr] = val; } + // Update the `id`. + if (this.idAttribute in attrs) this.id = this.get(this.idAttribute); + // Trigger all relevant attribute changes. if (!silent) { - if (changes.length) this._pending = true; - for (var i = 0, l = changes.length; i < l; i++) { + if (changes.length) this._pending = options; + for (var i = 0; i < changes.length; i++) { this.trigger('change:' + changes[i], this, current[changes[i]], options); } } @@ -361,6 +527,7 @@ if (changing) return this; if (!silent) { while (this._pending) { + options = this._pending; this._pending = false; this.trigger('change', this, options); } @@ -398,13 +565,16 @@ // determining if there *would be* a change. changedAttributes: function(diff) { if (!diff) return this.hasChanged() ? _.clone(this.changed) : false; - var val, changed = false; var old = this._changing ? this._previousAttributes : this.attributes; + var changed = {}; + var hasChanged; for (var attr in diff) { - if (_.isEqual(old[attr], (val = diff[attr]))) continue; - (changed || (changed = {}))[attr] = val; + var val = diff[attr]; + if (_.isEqual(old[attr], val)) continue; + changed[attr] = val; + hasChanged = true; } - return changed; + return hasChanged ? changed : false; }, // Get the previous value of an attribute, recorded at the time the last @@ -420,17 +590,16 @@ return _.clone(this._previousAttributes); }, - // Fetch the model from the server. If the server's representation of the - // model differs from its current attributes, they will be overridden, - // triggering a `"change"` event. + // Fetch the model from the server, merging the response with the model's + // local attributes. Any changed attributes will trigger a "change" event. fetch: function(options) { - options = options ? _.clone(options) : {}; - if (options.parse === void 0) options.parse = true; + options = _.extend({parse: true}, options); var model = this; var success = options.success; options.success = function(resp) { - if (!model.set(model.parse(resp, options), options)) return false; - if (success) success(model, resp, options); + var serverAttrs = options.parse ? model.parse(resp, options) : resp; + if (!model.set(serverAttrs, options)) return false; + if (success) success.call(options.context, model, resp, options); model.trigger('sync', model, resp, options); }; wrapError(this, options); @@ -441,9 +610,8 @@ // If the server returns an attributes hash that differs, the model's // state will be `set` again. save: function(key, val, options) { - var attrs, method, xhr, attributes = this.attributes; - // Handle both `"key", value` and `{key: value}` -style arguments. + var attrs; if (key == null || typeof key === 'object') { attrs = key; options = val; @@ -451,46 +619,43 @@ (attrs = {})[key] = val; } - options = _.extend({validate: true}, options); + options = _.extend({validate: true, parse: true}, options); + var wait = options.wait; // If we're not waiting and attributes exist, save acts as // `set(attr).save(null, opts)` with validation. Otherwise, check if // the model will be valid when the attributes, if any, are set. - if (attrs && !options.wait) { + if (attrs && !wait) { if (!this.set(attrs, options)) return false; - } else { - if (!this._validate(attrs, options)) return false; - } - - // Set temporary attributes if `{wait: true}`. - if (attrs && options.wait) { - this.attributes = _.extend({}, attributes, attrs); + } else if (!this._validate(attrs, options)) { + return false; } // After a successful server-side save, the client is (optionally) // updated with the server-side state. - if (options.parse === void 0) options.parse = true; var model = this; var success = options.success; + var attributes = this.attributes; options.success = function(resp) { // Ensure attributes are restored during synchronous saves. model.attributes = attributes; - var serverAttrs = model.parse(resp, options); - if (options.wait) serverAttrs = _.extend(attrs || {}, serverAttrs); - if (_.isObject(serverAttrs) && !model.set(serverAttrs, options)) { - return false; - } - if (success) success(model, resp, options); + var serverAttrs = options.parse ? model.parse(resp, options) : resp; + if (wait) serverAttrs = _.extend({}, attrs, serverAttrs); + if (serverAttrs && !model.set(serverAttrs, options)) return false; + if (success) success.call(options.context, model, resp, options); model.trigger('sync', model, resp, options); }; wrapError(this, options); - method = this.isNew() ? 'create' : (options.patch ? 'patch' : 'update'); - if (method === 'patch') options.attrs = attrs; - xhr = this.sync(method, this, options); + // Set temporary attributes if `{wait: true}` to properly find new ids. + if (attrs && wait) this.attributes = _.extend({}, attributes, attrs); + + var method = this.isNew() ? 'create' : (options.patch ? 'patch' : 'update'); + if (method === 'patch' && !options.attrs) options.attrs = attrs; + var xhr = this.sync(method, this, options); // Restore attributes. - if (attrs && options.wait) this.attributes = attributes; + this.attributes = attributes; return xhr; }, @@ -502,25 +667,27 @@ options = options ? _.clone(options) : {}; var model = this; var success = options.success; + var wait = options.wait; var destroy = function() { + model.stopListening(); model.trigger('destroy', model, model.collection, options); }; options.success = function(resp) { - if (options.wait || model.isNew()) destroy(); - if (success) success(model, resp, options); + if (wait) destroy(); + if (success) success.call(options.context, model, resp, options); if (!model.isNew()) model.trigger('sync', model, resp, options); }; + var xhr = false; if (this.isNew()) { - options.success(); - return false; + _.defer(options.success); + } else { + wrapError(this, options); + xhr = this.sync('delete', this, options); } - wrapError(this, options); - - var xhr = this.sync('delete', this, options); - if (!options.wait) destroy(); + if (!wait) destroy(); return xhr; }, @@ -528,9 +695,13 @@ // using Backbone's restful methods, override this to change the endpoint // that will be called. url: function() { - var base = _.result(this, 'urlRoot') || _.result(this.collection, 'url') || urlError(); + var base = + _.result(this, 'urlRoot') || + _.result(this.collection, 'url') || + urlError(); if (this.isNew()) return base; - return base + (base.charAt(base.length - 1) === '/' ? '' : '/') + encodeURIComponent(this.id); + var id = this.get(this.idAttribute); + return base.replace(/[^\/]$/, '$&/') + encodeURIComponent(id); }, // **parse** converts a response into the hash of attributes to be `set` on @@ -546,12 +717,12 @@ // A model is new if it has never been saved to the server, and lacks an id. isNew: function() { - return this.id == null; + return !this.has(this.idAttribute); }, // Check if the model is currently in a valid state. isValid: function(options) { - return this._validate({}, _.extend(options || {}, { validate: true })); + return this._validate({}, _.extend({}, options, {validate: true})); }, // Run validation against the next complete set of model attributes, @@ -567,23 +738,19 @@ }); - // Underscore methods that we want to implement on the Model. - var modelMethods = ['keys', 'values', 'pairs', 'invert', 'pick', 'omit']; + // Underscore methods that we want to implement on the Model, mapped to the + // number of arguments they take. + var modelMethods = {keys: 1, values: 1, pairs: 1, invert: 1, pick: 0, + omit: 0, chain: 1, isEmpty: 1}; // Mix in each Underscore method as a proxy to `Model#attributes`. - _.each(modelMethods, function(method) { - Model.prototype[method] = function() { - var args = slice.call(arguments); - args.unshift(this.attributes); - return _[method].apply(_, args); - }; - }); + addUnderscoreMethods(Model, modelMethods, 'attributes'); // Backbone.Collection // ------------------- // If models tend to represent a single row of data, a Backbone Collection is - // more analagous to a table full of data ... or a small slice or page of that + // more analogous to a table full of data ... or a small slice or page of that // table, or a collection of rows that belong together for a particular reason // -- all of the messages in this particular folder, all of the documents // belonging to this particular author, and so on. Collections maintain @@ -594,6 +761,7 @@ // its models in sort order, as they're added and removed. var Collection = Backbone.Collection = function(models, options) { options || (options = {}); + this.preinitialize.apply(this, arguments); if (options.model) this.model = options.model; if (options.comparator !== void 0) this.comparator = options.comparator; this._reset(); @@ -605,6 +773,17 @@ var setOptions = {add: true, remove: true, merge: true}; var addOptions = {add: true, remove: false}; + // Splices `insert` into `array` at index `at`. + var splice = function(array, insert, at) { + at = Math.min(Math.max(at, 0), array.length); + var tail = Array(array.length - at); + var length = insert.length; + var i; + for (i = 0; i < tail.length; i++) tail[i] = array[i + at]; + for (i = 0; i < length; i++) array[i + at] = insert[i]; + for (i = 0; i < tail.length; i++) array[i + length + at] = tail[i]; + }; + // Define the Collection's inheritable methods. _.extend(Collection.prototype, Events, { @@ -612,6 +791,11 @@ // This should be overridden in most cases. model: Model, + + // preinitialize is an empty function by default. You can override it with a function + // or object. preinitialize will run before any instantiation logic is run in the Collection. + preinitialize: function(){}, + // Initialize is an empty function by default. Override it with your own // initialization logic. initialize: function(){}, @@ -619,7 +803,7 @@ // The JSON representation of a Collection is an array of the // models' attributes. toJSON: function(options) { - return this.map(function(model){ return model.toJSON(options); }); + return this.map(function(model) { return model.toJSON(options); }); }, // Proxy `Backbone.sync` by default. @@ -627,32 +811,24 @@ return Backbone.sync.apply(this, arguments); }, - // Add a model, or list of models to the set. + // Add a model, or list of models to the set. `models` may be Backbone + // Models or raw JavaScript objects to be converted to Models, or any + // combination of the two. add: function(models, options) { return this.set(models, _.extend({merge: false}, options, addOptions)); }, // Remove a model, or a list of models from the set. remove: function(models, options) { + options = _.extend({}, options); var singular = !_.isArray(models); - models = singular ? [models] : _.clone(models); - options || (options = {}); - var i, l, index, model; - for (i = 0, l = models.length; i < l; i++) { - model = models[i] = this.get(models[i]); - if (!model) continue; - delete this._byId[model.id]; - delete this._byId[model.cid]; - index = this.indexOf(model); - this.models.splice(index, 1); - this.length--; - if (!options.silent) { - options.index = index; - model.trigger('remove', model, this, options); - } - this._removeReference(model); + models = singular ? [models] : models.slice(); + var removed = this._removeModels(models, options); + if (!options.silent && removed.length) { + options.changes = {added: [], merged: [], removed: removed}; + this.trigger('update', this, options); } - return singular ? models[0] : models; + return singular ? removed[0] : removed; }, // Update a collection by `set`-ing a new list of models, adding new ones, @@ -660,92 +836,116 @@ // already exist in the collection, as necessary. Similar to **Model#set**, // the core operation for updating the data contained by the collection. set: function(models, options) { - options = _.defaults({}, options, setOptions); - if (options.parse) models = this.parse(models, options); + if (models == null) return; + + options = _.extend({}, setOptions, options); + if (options.parse && !this._isModel(models)) { + models = this.parse(models, options) || []; + } + var singular = !_.isArray(models); - models = singular ? (models ? [models] : []) : _.clone(models); - var i, l, id, model, attrs, existing, sort; + models = singular ? [models] : models.slice(); + var at = options.at; - var targetModel = this.model; - var sortable = this.comparator && (at == null) && options.sort !== false; + if (at != null) at = +at; + if (at > this.length) at = this.length; + if (at < 0) at += this.length + 1; + + var set = []; + var toAdd = []; + var toMerge = []; + var toRemove = []; + var modelMap = {}; + + var add = options.add; + var merge = options.merge; + var remove = options.remove; + + var sort = false; + var sortable = this.comparator && at == null && options.sort !== false; var sortAttr = _.isString(this.comparator) ? this.comparator : null; - var toAdd = [], toRemove = [], modelMap = {}; - var add = options.add, merge = options.merge, remove = options.remove; - var order = !sortable && add && remove ? [] : false; // Turn bare objects into model references, and prevent invalid models // from being added. - for (i = 0, l = models.length; i < l; i++) { - attrs = models[i]; - if (attrs instanceof Model) { - id = model = attrs; - } else { - id = attrs[targetModel.prototype.idAttribute]; - } + var model, i; + for (i = 0; i < models.length; i++) { + model = models[i]; // If a duplicate is found, prevent it from being added and // optionally merge it into the existing model. - if (existing = this.get(id)) { - if (remove) modelMap[existing.cid] = true; - if (merge) { - attrs = attrs === model ? model.attributes : attrs; + var existing = this.get(model); + if (existing) { + if (merge && model !== existing) { + var attrs = this._isModel(model) ? model.attributes : model; if (options.parse) attrs = existing.parse(attrs, options); existing.set(attrs, options); - if (sortable && !sort && existing.hasChanged(sortAttr)) sort = true; + toMerge.push(existing); + if (sortable && !sort) sort = existing.hasChanged(sortAttr); + } + if (!modelMap[existing.cid]) { + modelMap[existing.cid] = true; + set.push(existing); } models[i] = existing; // If this is a new, valid model, push it to the `toAdd` list. } else if (add) { - model = models[i] = this._prepareModel(attrs, options); - if (!model) continue; - toAdd.push(model); - - // Listen to added models' events, and index models for lookup by - // `id` and by `cid`. - model.on('all', this._onModelEvent, this); - this._byId[model.cid] = model; - if (model.id != null) this._byId[model.id] = model; + model = models[i] = this._prepareModel(model, options); + if (model) { + toAdd.push(model); + this._addReference(model, options); + modelMap[model.cid] = true; + set.push(model); + } } - if (order) order.push(existing || model); } - // Remove nonexistent models if appropriate. + // Remove stale models. if (remove) { - for (i = 0, l = this.length; i < l; ++i) { - if (!modelMap[(model = this.models[i]).cid]) toRemove.push(model); + for (i = 0; i < this.length; i++) { + model = this.models[i]; + if (!modelMap[model.cid]) toRemove.push(model); } - if (toRemove.length) this.remove(toRemove, options); + if (toRemove.length) this._removeModels(toRemove, options); } // See if sorting is needed, update `length` and splice in new models. - if (toAdd.length || (order && order.length)) { + var orderChanged = false; + var replace = !sortable && add && remove; + if (set.length && replace) { + orderChanged = this.length !== set.length || _.some(this.models, function(m, index) { + return m !== set[index]; + }); + this.models.length = 0; + splice(this.models, set, 0); + this.length = this.models.length; + } else if (toAdd.length) { if (sortable) sort = true; - this.length += toAdd.length; - if (at != null) { - for (i = 0, l = toAdd.length; i < l; i++) { - this.models.splice(at + i, 0, toAdd[i]); - } - } else { - if (order) this.models.length = 0; - var orderedModels = order || toAdd; - for (i = 0, l = orderedModels.length; i < l; i++) { - this.models.push(orderedModels[i]); - } - } + splice(this.models, toAdd, at == null ? this.length : at); + this.length = this.models.length; } // Silently sort the collection if appropriate. if (sort) this.sort({silent: true}); - // Unless silenced, it's time to fire all appropriate add/sort events. + // Unless silenced, it's time to fire all appropriate add/sort/update events. if (!options.silent) { - for (i = 0, l = toAdd.length; i < l; i++) { - (model = toAdd[i]).trigger('add', model, this, options); + for (i = 0; i < toAdd.length; i++) { + if (at != null) options.index = at + i; + model = toAdd[i]; + model.trigger('add', model, this, options); + } + if (sort || orderChanged) this.trigger('sort', this, options); + if (toAdd.length || toRemove.length || toMerge.length) { + options.changes = { + added: toAdd, + removed: toRemove, + merged: toMerge + }; + this.trigger('update', this, options); } - if (sort || (order && order.length)) this.trigger('sort', this, options); } - + // Return the added (or merged) model (or models). return singular ? models[0] : models; }, @@ -755,9 +955,9 @@ // any granular `add` or `remove` events. Fires `reset` when finished. // Useful for bulk operations and optimizations. reset: function(models, options) { - options || (options = {}); - for (var i = 0, l = this.models.length; i < l; i++) { - this._removeReference(this.models[i]); + options = options ? _.clone(options) : {}; + for (var i = 0; i < this.models.length; i++) { + this._removeReference(this.models[i], options); } options.previousModels = this.models; this._reset(); @@ -774,8 +974,7 @@ // Remove a model from the end of the collection. pop: function(options) { var model = this.at(this.length - 1); - this.remove(model, options); - return model; + return this.remove(model, options); }, // Add a model to the beginning of the collection. @@ -786,8 +985,7 @@ // Remove a model from the beginning of the collection. shift: function(options) { var model = this.at(0); - this.remove(model, options); - return model; + return this.remove(model, options); }, // Slice out a sub-array of models from the collection. @@ -795,27 +993,30 @@ return slice.apply(this.models, arguments); }, - // Get a model from the set by id. + // Get a model from the set by id, cid, model object with id or cid + // properties, or an attributes object that is transformed through modelId. get: function(obj) { if (obj == null) return void 0; - return this._byId[obj.id] || this._byId[obj.cid] || this._byId[obj]; + return this._byId[obj] || + this._byId[this.modelId(obj.attributes || obj)] || + obj.cid && this._byId[obj.cid]; + }, + + // Returns `true` if the model is in the collection. + has: function(obj) { + return this.get(obj) != null; }, // Get the model at the given index. at: function(index) { + if (index < 0) index += this.length; return this.models[index]; }, // Return models with matching attributes. Useful for simple cases of // `filter`. where: function(attrs, first) { - if (_.isEmpty(attrs)) return first ? void 0 : []; - return this[first ? 'find' : 'filter'](function(model) { - for (var key in attrs) { - if (attrs[key] !== model.get(key)) return false; - } - return true; - }); + return this[first ? 'find' : 'filter'](attrs); }, // Return the first model with matching attributes. Useful for simple cases @@ -828,37 +1029,39 @@ // normal circumstances, as the set will maintain sort order as each item // is added. sort: function(options) { - if (!this.comparator) throw new Error('Cannot sort a set without a comparator'); + var comparator = this.comparator; + if (!comparator) throw new Error('Cannot sort a set without a comparator'); options || (options = {}); + var length = comparator.length; + if (_.isFunction(comparator)) comparator = _.bind(comparator, this); + // Run sort based on type of `comparator`. - if (_.isString(this.comparator) || this.comparator.length === 1) { - this.models = this.sortBy(this.comparator, this); + if (length === 1 || _.isString(comparator)) { + this.models = this.sortBy(comparator); } else { - this.models.sort(_.bind(this.comparator, this)); + this.models.sort(comparator); } - if (!options.silent) this.trigger('sort', this, options); return this; }, // Pluck an attribute from each model in the collection. pluck: function(attr) { - return _.invoke(this.models, 'get', attr); + return this.map(attr + ''); }, // Fetch the default set of models for this collection, resetting the // collection when they arrive. If `reset: true` is passed, the response // data will be passed through the `reset` method instead of `set`. fetch: function(options) { - options = options ? _.clone(options) : {}; - if (options.parse === void 0) options.parse = true; + options = _.extend({parse: true}, options); var success = options.success; var collection = this; options.success = function(resp) { var method = options.reset ? 'reset' : 'set'; collection[method](resp, options); - if (success) success(collection, resp, options); + if (success) success.call(options.context, collection, resp, options); collection.trigger('sync', collection, resp, options); }; wrapError(this, options); @@ -870,13 +1073,15 @@ // wait for the server to agree. create: function(model, options) { options = options ? _.clone(options) : {}; - if (!(model = this._prepareModel(model, options))) return false; - if (!options.wait) this.add(model, options); + var wait = options.wait; + model = this._prepareModel(model, options); + if (!model) return false; + if (!wait) this.add(model, options); var collection = this; var success = options.success; - options.success = function(model, resp, options) { - if (options.wait) collection.add(model, options); - if (success) success(model, resp, options); + options.success = function(m, resp, callbackOpts) { + if (wait) collection.add(m, callbackOpts); + if (success) success.call(callbackOpts.context, m, resp, callbackOpts); }; model.save(null, options); return model; @@ -890,7 +1095,15 @@ // Create a new collection with an identical list of models as this one. clone: function() { - return new this.constructor(this.models); + return new this.constructor(this.models, { + model: this.model, + comparator: this.comparator + }); + }, + + // Define how to uniquely identify models in the collection. + modelId: function(attrs) { + return attrs[this.model.prototype.idAttribute || 'id']; }, // Private method to reset all internal state. Called when the collection @@ -904,7 +1117,7 @@ // Prepare a hash of attributes (or other model) to be added to this // collection. _prepareModel: function(attrs, options) { - if (attrs instanceof Model) { + if (this._isModel(attrs)) { if (!attrs.collection) attrs.collection = this; return attrs; } @@ -916,8 +1129,53 @@ return false; }, + // Internal method called by both remove and set. + _removeModels: function(models, options) { + var removed = []; + for (var i = 0; i < models.length; i++) { + var model = this.get(models[i]); + if (!model) continue; + + var index = this.indexOf(model); + this.models.splice(index, 1); + this.length--; + + // Remove references before triggering 'remove' event to prevent an + // infinite loop. #3693 + delete this._byId[model.cid]; + var id = this.modelId(model.attributes); + if (id != null) delete this._byId[id]; + + if (!options.silent) { + options.index = index; + model.trigger('remove', model, this, options); + } + + removed.push(model); + this._removeReference(model, options); + } + return removed; + }, + + // Method for checking whether an object should be considered a model for + // the purposes of adding to the collection. + _isModel: function(model) { + return model instanceof Model; + }, + + // Internal method to create a model's ties to a collection. + _addReference: function(model, options) { + this._byId[model.cid] = model; + var id = this.modelId(model.attributes); + if (id != null) this._byId[id] = model; + model.on('all', this._onModelEvent, this); + }, + // Internal method to sever a model's ties to a collection. - _removeReference: function(model) { + _removeReference: function(model, options) { + delete this._byId[model.cid]; + var id = this.modelId(model.attributes); + if (id != null) delete this._byId[id]; if (this === model.collection) delete model.collection; model.off('all', this._onModelEvent, this); }, @@ -927,11 +1185,17 @@ // events simply proxy through. "add" and "remove" events that originate // in other collections are ignored. _onModelEvent: function(event, model, collection, options) { - if ((event === 'add' || event === 'remove') && collection !== this) return; - if (event === 'destroy') this.remove(model, options); - if (model && event === 'change:' + model.idAttribute) { - delete this._byId[model.previous(model.idAttribute)]; - if (model.id != null) this._byId[model.id] = model; + if (model) { + if ((event === 'add' || event === 'remove') && collection !== this) return; + if (event === 'destroy') this.remove(model, options); + if (event === 'change') { + var prevId = this.modelId(model.previousAttributes()); + var id = this.modelId(model.attributes); + if (prevId !== id) { + if (prevId != null) delete this._byId[prevId]; + if (id != null) this._byId[id] = model; + } + } } this.trigger.apply(this, arguments); } @@ -941,34 +1205,17 @@ // Underscore methods that we want to implement on the Collection. // 90% of the core usefulness of Backbone Collections is actually implemented // right here: - var methods = ['forEach', 'each', 'map', 'collect', 'reduce', 'foldl', - 'inject', 'reduceRight', 'foldr', 'find', 'detect', 'filter', 'select', - 'reject', 'every', 'all', 'some', 'any', 'include', 'contains', 'invoke', - 'max', 'min', 'toArray', 'size', 'first', 'head', 'take', 'initial', 'rest', - 'tail', 'drop', 'last', 'without', 'difference', 'indexOf', 'shuffle', - 'lastIndexOf', 'isEmpty', 'chain']; + var collectionMethods = {forEach: 3, each: 3, map: 3, collect: 3, reduce: 0, + foldl: 0, inject: 0, reduceRight: 0, foldr: 0, find: 3, detect: 3, filter: 3, + select: 3, reject: 3, every: 3, all: 3, some: 3, any: 3, include: 3, includes: 3, + contains: 3, invoke: 0, max: 3, min: 3, toArray: 1, size: 1, first: 3, + head: 3, take: 3, initial: 3, rest: 3, tail: 3, drop: 3, last: 3, + without: 0, difference: 0, indexOf: 3, shuffle: 1, lastIndexOf: 3, + isEmpty: 1, chain: 1, sample: 3, partition: 3, groupBy: 3, countBy: 3, + sortBy: 3, indexBy: 3, findIndex: 3, findLastIndex: 3}; // Mix in each Underscore method as a proxy to `Collection#models`. - _.each(methods, function(method) { - Collection.prototype[method] = function() { - var args = slice.call(arguments); - args.unshift(this.models); - return _[method].apply(_, args); - }; - }); - - // Underscore methods that take a property name as an argument. - var attributeMethods = ['groupBy', 'countBy', 'sortBy']; - - // Use attributes instead of properties. - _.each(attributeMethods, function(method) { - Collection.prototype[method] = function(value, context) { - var iterator = _.isFunction(value) ? value : function(model) { - return model.get(value); - }; - return _[method](this.models, iterator, context); - }; - }); + addUnderscoreMethods(Collection, collectionMethods, 'models'); // Backbone.View // ------------- @@ -985,17 +1232,16 @@ // if an existing element is not provided... var View = Backbone.View = function(options) { this.cid = _.uniqueId('view'); - options || (options = {}); + this.preinitialize.apply(this, arguments); _.extend(this, _.pick(options, viewOptions)); this._ensureElement(); this.initialize.apply(this, arguments); - this.delegateEvents(); }; // Cached regex to split keys for `delegate`. var delegateEventSplitter = /^(\S+)\s*(.*)$/; - // List of view options to be merged as properties. + // List of view options to be set as properties. var viewOptions = ['model', 'collection', 'el', 'id', 'attributes', 'className', 'tagName', 'events']; // Set up all inheritable **Backbone.View** properties and methods. @@ -1010,6 +1256,10 @@ return this.$el.find(selector); }, + // preinitialize is an empty function by default. You can override it with a function + // or object. preinitialize will run before any instantiation logic is run in the View + preinitialize: function(){}, + // Initialize is an empty function by default. Override it with your own // initialization logic. initialize: function(){}, @@ -1024,21 +1274,37 @@ // Remove this view by taking the element out of the DOM, and removing any // applicable Backbone.Events listeners. remove: function() { - this.$el.remove(); + this._removeElement(); this.stopListening(); return this; }, - // Change the view's element (`this.el` property), including event - // re-delegation. - setElement: function(element, delegate) { - if (this.$el) this.undelegateEvents(); - this.$el = element instanceof Backbone.$ ? element : Backbone.$(element); - this.el = this.$el[0]; - if (delegate !== false) this.delegateEvents(); + // Remove this view's element from the document and all event listeners + // attached to it. Exposed for subclasses using an alternative DOM + // manipulation API. + _removeElement: function() { + this.$el.remove(); + }, + + // Change the view's element (`this.el` property) and re-delegate the + // view's events on the new element. + setElement: function(element) { + this.undelegateEvents(); + this._setElement(element); + this.delegateEvents(); return this; }, + // Creates the `this.el` and `this.$el` references for this view using the + // given `el`. `el` can be a CSS selector or an HTML string, a jQuery + // context or an element. Subclasses can override this to utilize an + // alternative DOM manipulation API and are only required to set the + // `this.el` property. + _setElement: function(el) { + this.$el = el instanceof Backbone.$ ? el : Backbone.$(el); + this.el = this.$el[0]; + }, + // Set callbacks, where `this.events` is a hash of // // *{"event selector": "callback"}* @@ -1052,37 +1318,49 @@ // pairs. Callbacks will be bound to the view, with `this` set properly. // Uses event delegation for efficiency. // Omitting the selector binds the event to `this.el`. - // This only works for delegate-able events: not `focus`, `blur`, and - // not `change`, `submit`, and `reset` in Internet Explorer. delegateEvents: function(events) { - if (!(events || (events = _.result(this, 'events')))) return this; + events || (events = _.result(this, 'events')); + if (!events) return this; this.undelegateEvents(); for (var key in events) { var method = events[key]; - if (!_.isFunction(method)) method = this[events[key]]; + if (!_.isFunction(method)) method = this[method]; if (!method) continue; - var match = key.match(delegateEventSplitter); - var eventName = match[1], selector = match[2]; - method = _.bind(method, this); - eventName += '.delegateEvents' + this.cid; - if (selector === '') { - this.$el.on(eventName, method); - } else { - this.$el.on(eventName, selector, method); - } + this.delegate(match[1], match[2], _.bind(method, this)); } return this; }, - // Clears all callbacks previously bound to the view with `delegateEvents`. + // Add a single event listener to the view's element (or a child element + // using `selector`). This only works for delegate-able events: not `focus`, + // `blur`, and not `change`, `submit`, and `reset` in Internet Explorer. + delegate: function(eventName, selector, listener) { + this.$el.on(eventName + '.delegateEvents' + this.cid, selector, listener); + return this; + }, + + // Clears all callbacks previously bound to the view by `delegateEvents`. // You usually don't need to use this, but may wish to if you have multiple // Backbone views attached to the same DOM element. undelegateEvents: function() { - this.$el.off('.delegateEvents' + this.cid); + if (this.$el) this.$el.off('.delegateEvents' + this.cid); return this; }, + // A finer-grained `undelegateEvents` for removing a single delegated event. + // `selector` and `listener` are both optional. + undelegate: function(eventName, selector, listener) { + this.$el.off(eventName + '.delegateEvents' + this.cid, selector, listener); + return this; + }, + + // Produces a DOM element to be assigned to your view. Exposed for + // subclasses using an alternative DOM manipulation API. + _createElement: function(tagName) { + return document.createElement(tagName); + }, + // Ensure that the View has a DOM element to render into. // If `this.el` is a string, pass it through `$()`, take the first // matching element, and re-assign it to `el`. Otherwise, create @@ -1092,11 +1370,17 @@ var attrs = _.extend({}, _.result(this, 'attributes')); if (this.id) attrs.id = _.result(this, 'id'); if (this.className) attrs['class'] = _.result(this, 'className'); - var $el = Backbone.$('<' + _.result(this, 'tagName') + '>').attr(attrs); - this.setElement($el, false); + this.setElement(this._createElement(_.result(this, 'tagName'))); + this._setAttributes(attrs); } else { - this.setElement(_.result(this, 'el'), false); + this.setElement(_.result(this, 'el')); } + }, + + // Set attributes from a hash on this view's element. Exposed for + // subclasses using an alternative DOM manipulation API. + _setAttributes: function(attributes) { + this.$el.attr(attributes); } }); @@ -1165,14 +1449,13 @@ params.processData = false; } - // If we're sending a `PATCH` request, and we're in an old Internet Explorer - // that still has ActiveX enabled by default, override jQuery to use that - // for XHR instead. Remove this line when jQuery supports `PATCH` on IE8. - if (params.type === 'PATCH' && noXhrPatch) { - params.xhr = function() { - return new ActiveXObject("Microsoft.XMLHTTP"); - }; - } + // Pass along `textStatus` and `errorThrown` from jQuery. + var error = options.error; + options.error = function(xhr, textStatus, errorThrown) { + options.textStatus = textStatus; + options.errorThrown = errorThrown; + if (error) error.call(options.context, xhr, textStatus, errorThrown); + }; // Make the request, allowing the user to override any Ajax options. var xhr = options.xhr = Backbone.ajax(_.extend(params, options)); @@ -1180,15 +1463,13 @@ return xhr; }; - var noXhrPatch = typeof window !== 'undefined' && !!window.ActiveXObject && !(window.XMLHttpRequest && (new XMLHttpRequest).dispatchEvent); - // Map from CRUD to HTTP for our default `Backbone.sync` implementation. var methodMap = { 'create': 'POST', 'update': 'PUT', - 'patch': 'PATCH', + 'patch': 'PATCH', 'delete': 'DELETE', - 'read': 'GET' + 'read': 'GET' }; // Set the default implementation of `Backbone.ajax` to proxy through to `$`. @@ -1204,6 +1485,7 @@ // matched. Creating a new one sets its `routes` hash, if not set statically. var Router = Backbone.Router = function(options) { options || (options = {}); + this.preinitialize.apply(this, arguments); if (options.routes) this.routes = options.routes; this._bindRoutes(); this.initialize.apply(this, arguments); @@ -1219,6 +1501,10 @@ // Set up all inheritable **Backbone.Router** properties and methods. _.extend(Router.prototype, Events, { + // preinitialize is an empty function by default. You can override it with a function + // or object. preinitialize will run before any instantiation logic is run in the Router. + preinitialize: function(){}, + // Initialize is an empty function by default. Override it with your own // initialization logic. initialize: function(){}, @@ -1239,14 +1525,21 @@ var router = this; Backbone.history.route(route, function(fragment) { var args = router._extractParameters(route, fragment); - callback && callback.apply(router, args); - router.trigger.apply(router, ['route:' + name].concat(args)); - router.trigger('route', name, args); - Backbone.history.trigger('route', router, name, args); + if (router.execute(callback, args, name) !== false) { + router.trigger.apply(router, ['route:' + name].concat(args)); + router.trigger('route', name, args); + Backbone.history.trigger('route', router, name, args); + } }); return this; }, + // Execute a route handler with the provided parameters. This is an + // excellent place to do pre-route setup or post-route cleanup. + execute: function(callback, args, name) { + if (callback) callback.apply(this, args); + }, + // Simple proxy to `Backbone.history` to save a fragment into the history. navigate: function(fragment, options) { Backbone.history.navigate(fragment, options); @@ -1271,10 +1564,10 @@ route = route.replace(escapeRegExp, '\\$&') .replace(optionalParam, '(?:$1)?') .replace(namedParam, function(match, optional) { - return optional ? match : '([^\/]+)'; + return optional ? match : '([^/?]+)'; }) - .replace(splatParam, '(.*?)'); - return new RegExp('^' + route + '$'); + .replace(splatParam, '([^?]*?)'); + return new RegExp('^' + route + '(?:\\?([\\s\\S]*))?$'); }, // Given a route, and a URL fragment that it matches, return the array of @@ -1282,7 +1575,9 @@ // treated as `null` to normalize cross-browser behavior. _extractParameters: function(route, fragment) { var params = route.exec(fragment).slice(1); - return _.map(params, function(param) { + return _.map(params, function(param, i) { + // Don't decode the search params. + if (i === params.length - 1) return param || null; return param ? decodeURIComponent(param) : null; }); } @@ -1299,7 +1594,7 @@ // falls back to polling. var History = Backbone.History = function() { this.handlers = []; - _.bindAll(this, 'checkUrl'); + this.checkUrl = _.bind(this.checkUrl, this); // Ensure that `History` can be used outside of the browser. if (typeof window !== 'undefined') { @@ -1314,14 +1609,8 @@ // Cached regex for stripping leading and trailing slashes. var rootStripper = /^\/+|\/+$/g; - // Cached regex for detecting MSIE. - var isExplorer = /msie [\w.]+/; - - // Cached regex for removing a trailing slash. - var trailingSlash = /\/$/; - - // Cached regex for stripping urls of hash and query. - var pathStripper = /[?#].*$/; + // Cached regex for stripping urls of hash. + var pathStripper = /#.*$/; // Has the history handling already been started? History.started = false; @@ -1333,6 +1622,33 @@ // twenty times a second. interval: 50, + // Are we at the app root? + atRoot: function() { + var path = this.location.pathname.replace(/[^\/]$/, '$&/'); + return path === this.root && !this.getSearch(); + }, + + // Does the pathname match the root? + matchRoot: function() { + var path = this.decodeFragment(this.location.pathname); + var rootPath = path.slice(0, this.root.length - 1) + '/'; + return rootPath === this.root; + }, + + // Unicode characters in `location.pathname` are percent encoded so they're + // decoded for comparison. `%25` should not be decoded since it may be part + // of an encoded parameter. + decodeFragment: function(fragment) { + return decodeURI(fragment.replace(/%25/g, '%2525')); + }, + + // In IE6, the hash fragment and search params are incorrect if the + // fragment contains `?`. + getSearch: function() { + var match = this.location.href.replace(/#.*/, '').match(/\?.+/); + return match ? match[0] : ''; + }, + // Gets the true hash value. Cannot use location.hash directly due to bug // in Firefox where location.hash will always be decoded. getHash: function(window) { @@ -1340,14 +1656,19 @@ return match ? match[1] : ''; }, - // Get the cross-browser normalized URL fragment, either from the URL, - // the hash, or the override. - getFragment: function(fragment, forcePushState) { + // Get the pathname and search params, without the root. + getPath: function() { + var path = this.decodeFragment( + this.location.pathname + this.getSearch() + ).slice(this.root.length - 1); + return path.charAt(0) === '/' ? path.slice(1) : path; + }, + + // Get the cross-browser normalized URL fragment from the path or hash. + getFragment: function(fragment) { if (fragment == null) { - if (this._hasPushState || !this._wantsHashChange || forcePushState) { - fragment = this.location.pathname; - var root = this.root.replace(trailingSlash, ''); - if (!fragment.indexOf(root)) fragment = fragment.slice(root.length); + if (this._usePushState || !this._wantsHashChange) { + fragment = this.getPath(); } else { fragment = this.getHash(); } @@ -1358,7 +1679,7 @@ // Start the hash change handling, returning `true` if the current URL matches // an existing route, and `false` otherwise. start: function(options) { - if (History.started) throw new Error("Backbone.history has already been started"); + if (History.started) throw new Error('Backbone.history has already been started'); History.started = true; // Figure out the initial configuration. Do we need an iframe? @@ -1366,65 +1687,93 @@ this.options = _.extend({root: '/'}, this.options, options); this.root = this.options.root; this._wantsHashChange = this.options.hashChange !== false; + this._hasHashChange = 'onhashchange' in window && (document.documentMode === void 0 || document.documentMode > 7); + this._useHashChange = this._wantsHashChange && this._hasHashChange; this._wantsPushState = !!this.options.pushState; - this._hasPushState = !!(this.options.pushState && this.history && this.history.pushState); - var fragment = this.getFragment(); - var docMode = document.documentMode; - var oldIE = (isExplorer.exec(navigator.userAgent.toLowerCase()) && (!docMode || docMode <= 7)); + this._hasPushState = !!(this.history && this.history.pushState); + this._usePushState = this._wantsPushState && this._hasPushState; + this.fragment = this.getFragment(); // Normalize root to always include a leading and trailing slash. this.root = ('/' + this.root + '/').replace(rootStripper, '/'); - if (oldIE && this._wantsHashChange) { - this.iframe = Backbone.$('