diff --git a/.circleci/config.yml b/.circleci/config.yml index 8b963e22831195..67fa02e7123b54 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -99,9 +99,9 @@ references: paths: - '.git' - # npm cache + # yarn cache # - # npm caches the modules it installs in ~/.npm. + # yarn caches the modules it installs in ~/.cache/yarn. # We cache that cache to save time pulling modules from the network. # # @@ -110,29 +110,29 @@ references: # - https://github.com/Automattic/wp-calypso/pull/25487 # - https://github.com/Automattic/wp-calypso/pull/27180 # - # More about the CircleCI cache: https://circleci.com/docs/2.0/caching - restore-npm-cache: &restore-npm-cache - name: 'Restore npm cache' + # More about the CircleCI cache: https://circleci.com/docs/2.0/caching and https://circleci.com/docs/2.0/yarn/ + restore-yarn-cache: &restore-yarn-cache + name: 'Restore yarn cache' keys: - - v{{ .Environment.GLOBAL_CACHE_PREFIX }}-v3-npm-modules-{{ checksum ".nvmrc" }}-{{ checksum "package-lock.json" }} - - v{{ .Environment.GLOBAL_CACHE_PREFIX }}-v3-npm-modules-{{ checksum ".nvmrc" }} + - v{{ .Environment.GLOBAL_CACHE_PREFIX }}-yarn-modules-{{ checksum ".nvmrc" }}-{{ checksum "yarn.lock" }} + - v{{ .Environment.GLOBAL_CACHE_PREFIX }}-yarn-modules-{{ checksum ".nvmrc" }} - npm-install: &npm-install + yarn-install: &yarn-install environment: - PUPPETEER_SKIP_CHROMIUM_DOWNLOAD: "true" - name: Install npm dependencies - command: npm ci + PUPPETEER_SKIP_CHROMIUM_DOWNLOAD: 'true' + name: Install dependencies + command: yarn install --frozen-lockfile - save-npm-cache: &save-npm-cache - name: 'Save node_modules cache' - key: v{{ .Environment.GLOBAL_CACHE_PREFIX }}-v3-npm-modules-{{ checksum ".nvmrc" }}-{{ checksum "package-lock.json" }} + save-yarn-cache: &save-yarn-cache + name: 'Save yarn cache' + key: v{{ .Environment.GLOBAL_CACHE_PREFIX }}-yarn-modules-{{ checksum ".nvmrc" }}-{{ checksum "yarn.lock" }} paths: - - ~/.npm - npm-e2e-install: &npm-e2e-install - name: Install e2e npm dependencies + - ~/.cache/yarn + yarn-e2e-install: &yarn-e2e-install + name: Install e2e yarn dependencies command: | cd test/e2e && - CHROMEDRIVER_VERSION=$(<.chromedriver_version) npm ci + CHROMEDRIVER_VERSION=$(<.chromedriver_version) yarn install --frozen-lockfile # Babel cache # More about the CircleCI cache: https://circleci.com/docs/2.0/caching @@ -196,11 +196,11 @@ jobs: - run: *update-git-master - save_cache: *save-git-cache # npm dependencies - - restore_cache: *restore-npm-cache - - run: *npm-install - - run: *npm-e2e-install - - save_cache: *save-npm-cache - - run: npm run build-packages + - restore_cache: *restore-yarn-cache + - run: *yarn-install + - run: *yarn-e2e-install + - save_cache: *save-yarn-cache + - run: yarn run build-packages - persist_to_workspace: root: '~' paths: @@ -214,7 +214,7 @@ jobs: - run: name: TypeScript typecheck # Report but don't fail the build (`|| exit 0`) - command: npm run typecheck || exit 0 + command: yarn run typecheck || exit 0 typecheck-strict: <<: *defaults @@ -223,7 +223,7 @@ jobs: - prepare - run: name: TypeScript strict typecheck of individual subprojects - command: npm run tsc -- --project client/landing/gutenboarding + command: yarn run tsc --project client/landing/gutenboarding lint-and-translate: <<: *defaults @@ -233,7 +233,7 @@ jobs: - run: name: Lint Config Keys when: always - command: npm run lint:config-defaults + command: yarn run lint:config-defaults - run: name: Lint Client and Server when: always @@ -256,7 +256,7 @@ jobs: name: Build calypso-strings.pot when: always command: | - npm run translate + yarn run translate mv calypso-strings.pot "$CIRCLE_ARTIFACTS/translate" - run: name: Build New Strings .pot @@ -497,7 +497,7 @@ jobs: steps: - prepare - run: *set-e2e-variables - - run: npm run decryptconfig + - run: yarn run decryptconfig - run: ./scripts/randomize.sh specs - run: ./scripts/run-wrapper.sh - run: *move-e2e-artifacts @@ -561,7 +561,7 @@ jobs: }" << parameters.slack-webhook >> circleci-agent step halt fi - - run: npm run decryptconfig + - run: yarn run decryptconfig - run: name: Run Canary Tests command: | diff --git a/.eslintignore b/.eslintignore index 72f025371d3bb5..72639deb06ede8 100644 --- a/.eslintignore +++ b/.eslintignore @@ -1,4 +1,5 @@ .vscode +.yarn /assets/ /build/ /docs/ diff --git a/.github/workflows/full-site-editing-plugin.yml b/.github/workflows/full-site-editing-plugin.yml index c2b32d806e70a0..0b6cb53ad6766b 100644 --- a/.github/workflows/full-site-editing-plugin.yml +++ b/.github/workflows/full-site-editing-plugin.yml @@ -4,7 +4,7 @@ on: paths: - 'apps/full-site-editing/full-site-editing-plugin/**' -name: Build Full Site Editing plugin +name: build-fse-plugin jobs: build: @@ -17,7 +17,7 @@ jobs: - name: Checkout code uses: actions/checkout@master - name: Install dependencies - run: npm ci + run: yarn install --frozen-lockfile - name: Build FSE run: npx lerna run build --scope='@automattic/full-site-editing' --stream - name: Upload build artifact diff --git a/.github/workflows/icfy-stats.yml b/.github/workflows/icfy-stats.yml index e566cd32b40f65..2f4ea6205912f7 100644 --- a/.github/workflows/icfy-stats.yml +++ b/.github/workflows/icfy-stats.yml @@ -9,50 +9,50 @@ jobs: runs-on: ubuntu-latest steps: - - name: Set up Node - uses: actions/setup-node@v1 - with: - node-version: '>=12.15.0' - - name: Checkout code - uses: actions/checkout@v2 - - name: Fetch git history - run: git fetch --prune --unshallow - - name: Install dependencies - env: - PUPPETEER_SKIP_CHROMIUM_DOWNLOAD: true - run: npm ci - - name: Capture npm logs - uses: actions/upload-artifact@v1 - if: failure() - with: - name: npm-logs - path: /home/runner/.npm/_logs/ - - name: Build ICFY stats - env: - NODE_ENV: production - BROWSERSLIST_ENV: defaults - WORKERS: 2 - run: npm run analyze-icfy - - run: mkdir icfy-stats && mv client/{chart,stats}.json icfy-stats - - uses: actions/upload-artifact@v1 - with: - name: icfy - path: icfy-stats - - name: Upload build artifact - env: - ICFY_SECRET: ${{ secrets.ICFY_SECRET }} - run: | - ANCESTOR_SHA1=$(git merge-base HEAD origin/master) - CURRENT_BRANCH=$(git rev-parse --abbrev-ref HEAD) - curl -X POST --globoff \ - "http://api.iscalypsofastyet.com:5000/submit-stats?from=github&secret=$ICFY_SECRET" \ - -H 'Cache-Control: no-cache' \ - -H 'Content-Type: application/json' \ - -d '{ - "payload": { - "branch": "'"$CURRENT_BRANCH"'", - "build_num": '"$GITHUB_RUN_ID"', - "sha": "'"$GITHUB_SHA"'", - "ancestor": "'"$ANCESTOR_SHA1"'" - } - }' + - name: Set up Node + uses: actions/setup-node@v1 + with: + node-version: '^12.13.1' + - name: Checkout code + uses: actions/checkout@v2 + - name: Fetch git history + run: git fetch --prune --unshallow + - name: Install dependencies + env: + PUPPETEER_SKIP_CHROMIUM_DOWNLOAD: true + run: yarn install + - name: Capture yarn logs + uses: actions/upload-artifact@v1 + if: failure() + with: + name: yarn-logs + path: yarn-error.log + - name: Build ICFY stats + env: + NODE_ENV: production + BROWSERSLIST_ENV: defaults + WORKERS: 2 + run: yarn run analyze-icfy + - run: mkdir icfy-stats && mv client/{chart,stats}.json icfy-stats + - uses: actions/upload-artifact@v1 + with: + name: icfy + path: icfy-stats + - name: Upload build artifact + env: + ICFY_SECRET: ${{ secrets.ICFY_SECRET }} + run: | + ANCESTOR_SHA1=$(git merge-base HEAD origin/master) + CURRENT_BRANCH=$(git rev-parse --abbrev-ref HEAD) + curl -X POST --globoff \ + "http://api.iscalypsofastyet.com:5000/submit-stats?from=github&secret=$ICFY_SECRET" \ + -H 'Cache-Control: no-cache' \ + -H 'Content-Type: application/json' \ + -d '{ + "payload": { + "branch": "'"$CURRENT_BRANCH"'", + "build_num": '"$GITHUB_RUN_ID"', + "sha": "'"$GITHUB_SHA"'", + "ancestor": "'"$ANCESTOR_SHA1"'" + } + }' diff --git a/.gitignore b/.gitignore index d3ee9f5c44f190..4f21db7a6a6a15 100644 --- a/.gitignore +++ b/.gitignore @@ -28,6 +28,7 @@ spec-xunit-reporter-0.0.1.tgz *xunit_*.xml lerna-debug.log /vendor +yarn-error.log # added during build /config/secrets.json diff --git a/.yarn/releases/yarn-1.22.4.js b/.yarn/releases/yarn-1.22.4.js new file mode 100755 index 00000000000000..d9647dba0a16a8 --- /dev/null +++ b/.yarn/releases/yarn-1.22.4.js @@ -0,0 +1,187187 @@ +#!/usr/bin/env node +module.exports = /******/ ( function( modules ) { + // webpackBootstrap + /******/ // The module cache + /******/ var installedModules = {}; // The require function + /******/ + /******/ /******/ function __webpack_require__( moduleId ) { + /******/ + /******/ // Check if module is in cache + /******/ if ( installedModules[ moduleId ] ) { + /******/ return installedModules[ moduleId ].exports; + /******/ + } // Create a new module (and put it into the cache) + /******/ /******/ var module = ( installedModules[ moduleId ] = { + /******/ i: moduleId, + /******/ l: false, + /******/ exports: {}, + /******/ + } ); // Execute the module function + /******/ + /******/ /******/ modules[ moduleId ].call( + module.exports, + module, + module.exports, + __webpack_require__ + ); // Flag the module as loaded + /******/ + /******/ /******/ module.l = true; // Return the exports of the module + /******/ + /******/ /******/ return module.exports; + /******/ + } // expose the modules object (__webpack_modules__) + /******/ + /******/ + /******/ /******/ __webpack_require__.m = modules; // expose the module cache + /******/ + /******/ /******/ __webpack_require__.c = installedModules; // identity function for calling harmony imports with the correct context + /******/ + /******/ /******/ __webpack_require__.i = function( value ) { + return value; + }; // define getter function for harmony exports + /******/ + /******/ /******/ __webpack_require__.d = function( exports, name, getter ) { + /******/ if ( ! __webpack_require__.o( exports, name ) ) { + /******/ Object.defineProperty( exports, name, { + /******/ configurable: false, + /******/ enumerable: true, + /******/ get: getter, + /******/ + } ); + /******/ + } + /******/ + }; // getDefaultExport function for compatibility with non-harmony modules + /******/ + /******/ /******/ __webpack_require__.n = function( module ) { + /******/ var getter = + module && module.__esModule + ? /******/ function getDefault() { + return module[ 'default' ]; + } + : /******/ function getModuleExports() { + return module; + }; + /******/ __webpack_require__.d( getter, 'a', getter ); + /******/ return getter; + /******/ + }; // Object.prototype.hasOwnProperty.call + /******/ + /******/ /******/ __webpack_require__.o = function( object, property ) { + return Object.prototype.hasOwnProperty.call( object, property ); + }; // __webpack_public_path__ + /******/ + /******/ /******/ __webpack_require__.p = ''; // Load entry module and return exports + /******/ + /******/ /******/ return __webpack_require__( ( __webpack_require__.s = 549 ) ); + /******/ +} )( + /************************************************************************/ + /******/ [ + /* 0 */ + /***/ function( module, exports ) { + module.exports = require( 'path' ); + + /***/ + }, + /* 1 */ + /***/ function( module, __webpack_exports__, __webpack_require__ ) { + 'use strict'; + /* harmony export (immutable) */ __webpack_exports__[ 'a' ] = __extends; + /* unused harmony export __assign */ + /* unused harmony export __rest */ + /* unused harmony export __decorate */ + /* unused harmony export __param */ + /* unused harmony export __metadata */ + /* unused harmony export __awaiter */ + /* unused harmony export __generator */ + /* unused harmony export __exportStar */ + /* unused harmony export __values */ + /* unused harmony export __read */ + /* unused harmony export __spread */ + /* unused harmony export __await */ + /* unused harmony export __asyncGenerator */ + /* unused harmony export __asyncDelegator */ + /* unused harmony export __asyncValues */ + /* unused harmony export __makeTemplateObject */ + /* unused harmony export __importStar */ + /* unused harmony export __importDefault */ + /*! ***************************************************************************** +Copyright (c) Microsoft Corporation. All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); you may not use +this file except in compliance with the License. You may obtain a copy of the +License at http://www.apache.org/licenses/LICENSE-2.0 + +THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED +WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, +MERCHANTABLITY OR NON-INFRINGEMENT. + +See the Apache Version 2.0 License for specific language governing permissions +and limitations under the License. +***************************************************************************** */ + /* global Reflect, Promise */ + + var extendStatics = function( d, b ) { + extendStatics = + Object.setPrototypeOf || + ( { __proto__: [] } instanceof Array && + function( d, b ) { + d.__proto__ = b; + } ) || + function( d, b ) { + for ( var p in b ) if ( b.hasOwnProperty( p ) ) d[ p ] = b[ p ]; + }; + return extendStatics( d, b ); + }; + + function __extends( d, b ) { + extendStatics( d, b ); + function __() { + this.constructor = d; + } + d.prototype = + b === null ? Object.create( b ) : ( ( __.prototype = b.prototype ), new __() ); + } + + var __assign = function() { + __assign = + Object.assign || + function __assign( t ) { + for ( var s, i = 1, n = arguments.length; i < n; i++ ) { + s = arguments[ i ]; + for ( var p in s ) + if ( Object.prototype.hasOwnProperty.call( s, p ) ) t[ p ] = s[ p ]; + } + return t; + }; + return __assign.apply( this, arguments ); + }; + + function __rest( s, e ) { + var t = {}; + for ( var p in s ) + if ( Object.prototype.hasOwnProperty.call( s, p ) && e.indexOf( p ) < 0 ) t[ p ] = s[ p ]; + if ( s != null && typeof Object.getOwnPropertySymbols === 'function' ) + for ( var i = 0, p = Object.getOwnPropertySymbols( s ); i < p.length; i++ ) + if ( e.indexOf( p[ i ] ) < 0 ) t[ p[ i ] ] = s[ p[ i ] ]; + return t; + } + + function __decorate( decorators, target, key, desc ) { + var c = arguments.length, + r = + c < 3 + ? target + : desc === null + ? ( desc = Object.getOwnPropertyDescriptor( target, key ) ) + : desc, + d; + if ( typeof Reflect === 'object' && typeof Reflect.decorate === 'function' ) + r = Reflect.decorate( decorators, target, key, desc ); + else + for ( var i = decorators.length - 1; i >= 0; i-- ) + if ( ( d = decorators[ i ] ) ) + r = ( c < 3 ? d( r ) : c > 3 ? d( target, key, r ) : d( target, key ) ) || r; + return c > 3 && r && Object.defineProperty( target, key, r ), r; + } + + function __param( paramIndex, decorator ) { + return function( target, key ) { + decorator( target, key, paramIndex ); + }; + } + + function __metadata( metadataKey, metadataValue ) { + if ( typeof Reflect === 'object' && typeof Reflect.metadata === 'function' ) + return Reflect.metadata( metadataKey, metadataValue ); + } + + function __awaiter( thisArg, _arguments, P, generator ) { + return new ( P || ( P = Promise ) )( function( resolve, reject ) { + function fulfilled( value ) { + try { + step( generator.next( value ) ); + } catch ( e ) { + reject( e ); + } + } + function rejected( value ) { + try { + step( generator[ 'throw' ]( value ) ); + } catch ( e ) { + reject( e ); + } + } + function step( result ) { + result.done + ? resolve( result.value ) + : new P( function( resolve ) { + resolve( result.value ); + } ).then( fulfilled, rejected ); + } + step( ( generator = generator.apply( thisArg, _arguments || [] ) ).next() ); + } ); + } + + function __generator( thisArg, body ) { + var _ = { + label: 0, + sent: function() { + if ( t[ 0 ] & 1 ) throw t[ 1 ]; + return t[ 1 ]; + }, + trys: [], + ops: [], + }, + f, + y, + t, + g; + return ( + ( g = { next: verb( 0 ), throw: verb( 1 ), return: verb( 2 ) } ), + typeof Symbol === 'function' && + ( g[ Symbol.iterator ] = function() { + return this; + } ), + g + ); + function verb( n ) { + return function( v ) { + return step( [ n, v ] ); + }; + } + function step( op ) { + if ( f ) throw new TypeError( 'Generator is already executing.' ); + while ( _ ) + try { + if ( + ( ( f = 1 ), + y && + ( t = + op[ 0 ] & 2 + ? y[ 'return' ] + : op[ 0 ] + ? y[ 'throw' ] || ( ( t = y[ 'return' ] ) && t.call( y ), 0 ) + : y.next ) && + ! ( t = t.call( y, op[ 1 ] ) ).done ) + ) + return t; + if ( ( ( y = 0 ), t ) ) op = [ op[ 0 ] & 2, t.value ]; + switch ( op[ 0 ] ) { + case 0: + case 1: + t = op; + break; + case 4: + _.label++; + return { value: op[ 1 ], done: false }; + case 5: + _.label++; + y = op[ 1 ]; + op = [ 0 ]; + continue; + case 7: + op = _.ops.pop(); + _.trys.pop(); + continue; + default: + if ( + ! ( ( t = _.trys ), ( t = t.length > 0 && t[ t.length - 1 ] ) ) && + ( op[ 0 ] === 6 || op[ 0 ] === 2 ) + ) { + _ = 0; + continue; + } + if ( op[ 0 ] === 3 && ( ! t || ( op[ 1 ] > t[ 0 ] && op[ 1 ] < t[ 3 ] ) ) ) { + _.label = op[ 1 ]; + break; + } + if ( op[ 0 ] === 6 && _.label < t[ 1 ] ) { + _.label = t[ 1 ]; + t = op; + break; + } + if ( t && _.label < t[ 2 ] ) { + _.label = t[ 2 ]; + _.ops.push( op ); + break; + } + if ( t[ 2 ] ) _.ops.pop(); + _.trys.pop(); + continue; + } + op = body.call( thisArg, _ ); + } catch ( e ) { + op = [ 6, e ]; + y = 0; + } finally { + f = t = 0; + } + if ( op[ 0 ] & 5 ) throw op[ 1 ]; + return { value: op[ 0 ] ? op[ 1 ] : void 0, done: true }; + } + } + + function __exportStar( m, exports ) { + for ( var p in m ) if ( ! exports.hasOwnProperty( p ) ) exports[ p ] = m[ p ]; + } + + function __values( o ) { + var m = typeof Symbol === 'function' && o[ Symbol.iterator ], + i = 0; + if ( m ) return m.call( o ); + return { + next: function() { + if ( o && i >= o.length ) o = void 0; + return { value: o && o[ i++ ], done: ! o }; + }, + }; + } + + function __read( o, n ) { + var m = typeof Symbol === 'function' && o[ Symbol.iterator ]; + if ( ! m ) return o; + var i = m.call( o ), + r, + ar = [], + e; + try { + while ( ( n === void 0 || n-- > 0 ) && ! ( r = i.next() ).done ) ar.push( r.value ); + } catch ( error ) { + e = { error: error }; + } finally { + try { + if ( r && ! r.done && ( m = i[ 'return' ] ) ) m.call( i ); + } finally { + if ( e ) throw e.error; + } + } + return ar; + } + + function __spread() { + for ( var ar = [], i = 0; i < arguments.length; i++ ) + ar = ar.concat( __read( arguments[ i ] ) ); + return ar; + } + + function __await( v ) { + return this instanceof __await ? ( ( this.v = v ), this ) : new __await( v ); + } + + function __asyncGenerator( thisArg, _arguments, generator ) { + if ( ! Symbol.asyncIterator ) throw new TypeError( 'Symbol.asyncIterator is not defined.' ); + var g = generator.apply( thisArg, _arguments || [] ), + i, + q = []; + return ( + ( i = {} ), + verb( 'next' ), + verb( 'throw' ), + verb( 'return' ), + ( i[ Symbol.asyncIterator ] = function() { + return this; + } ), + i + ); + function verb( n ) { + if ( g[ n ] ) + i[ n ] = function( v ) { + return new Promise( function( a, b ) { + q.push( [ n, v, a, b ] ) > 1 || resume( n, v ); + } ); + }; + } + function resume( n, v ) { + try { + step( g[ n ]( v ) ); + } catch ( e ) { + settle( q[ 0 ][ 3 ], e ); + } + } + function step( r ) { + r.value instanceof __await + ? Promise.resolve( r.value.v ).then( fulfill, reject ) + : settle( q[ 0 ][ 2 ], r ); + } + function fulfill( value ) { + resume( 'next', value ); + } + function reject( value ) { + resume( 'throw', value ); + } + function settle( f, v ) { + if ( ( f( v ), q.shift(), q.length ) ) resume( q[ 0 ][ 0 ], q[ 0 ][ 1 ] ); + } + } + + function __asyncDelegator( o ) { + var i, p; + return ( + ( i = {} ), + verb( 'next' ), + verb( 'throw', function( e ) { + throw e; + } ), + verb( 'return' ), + ( i[ Symbol.iterator ] = function() { + return this; + } ), + i + ); + function verb( n, f ) { + i[ n ] = o[ n ] + ? function( v ) { + return ( p = ! p ) + ? { value: __await( o[ n ]( v ) ), done: n === 'return' } + : f + ? f( v ) + : v; + } + : f; + } + } + + function __asyncValues( o ) { + if ( ! Symbol.asyncIterator ) throw new TypeError( 'Symbol.asyncIterator is not defined.' ); + var m = o[ Symbol.asyncIterator ], + i; + return m + ? m.call( o ) + : ( ( o = typeof __values === 'function' ? __values( o ) : o[ Symbol.iterator ]() ), + ( i = {} ), + verb( 'next' ), + verb( 'throw' ), + verb( 'return' ), + ( i[ Symbol.asyncIterator ] = function() { + return this; + } ), + i ); + function verb( n ) { + i[ n ] = + o[ n ] && + function( v ) { + return new Promise( function( resolve, reject ) { + ( v = o[ n ]( v ) ), settle( resolve, reject, v.done, v.value ); + } ); + }; + } + function settle( resolve, reject, d, v ) { + Promise.resolve( v ).then( function( v ) { + resolve( { value: v, done: d } ); + }, reject ); + } + } + + function __makeTemplateObject( cooked, raw ) { + if ( Object.defineProperty ) { + Object.defineProperty( cooked, 'raw', { value: raw } ); + } else { + cooked.raw = raw; + } + return cooked; + } + + function __importStar( mod ) { + if ( mod && mod.__esModule ) return mod; + var result = {}; + if ( mod != null ) + for ( var k in mod ) if ( Object.hasOwnProperty.call( mod, k ) ) result[ k ] = mod[ k ]; + result.default = mod; + return result; + } + + function __importDefault( mod ) { + return mod && mod.__esModule ? mod : { default: mod }; + } + + /***/ + }, + /* 2 */ + /***/ function( module, exports, __webpack_require__ ) { + 'use strict'; + + exports.__esModule = true; + + var _promise = __webpack_require__( 227 ); + + var _promise2 = _interopRequireDefault( _promise ); + + function _interopRequireDefault( obj ) { + return obj && obj.__esModule ? obj : { default: obj }; + } + + exports.default = function( fn ) { + return function() { + var gen = fn.apply( this, arguments ); + return new _promise2.default( function( resolve, reject ) { + function step( key, arg ) { + try { + var info = gen[ key ]( arg ); + var value = info.value; + } catch ( error ) { + reject( error ); + return; + } + + if ( info.done ) { + resolve( value ); + } else { + return _promise2.default.resolve( value ).then( + function( value ) { + step( 'next', value ); + }, + function( err ) { + step( 'throw', err ); + } + ); + } + } + + return step( 'next' ); + } ); + }; + }; + + /***/ + }, + /* 3 */ + /***/ function( module, exports ) { + module.exports = require( 'util' ); + + /***/ + }, + /* 4 */ + /***/ function( module, exports, __webpack_require__ ) { + 'use strict'; + + Object.defineProperty( exports, '__esModule', { + value: true, + } ); + exports.getFirstSuitableFolder = exports.readFirstAvailableStream = exports.makeTempDir = exports.hardlinksWork = exports.writeFilePreservingEol = exports.getFileSizeOnDisk = exports.walk = exports.symlink = exports.find = exports.readJsonAndFile = exports.readJson = exports.readFileAny = exports.hardlinkBulk = exports.copyBulk = exports.unlink = exports.glob = exports.link = exports.chmod = exports.lstat = exports.exists = exports.mkdirp = exports.stat = exports.access = exports.rename = exports.readdir = exports.realpath = exports.readlink = exports.writeFile = exports.open = exports.readFileBuffer = exports.lockQueue = exports.constants = undefined; + + var _asyncToGenerator2; + + function _load_asyncToGenerator() { + return ( _asyncToGenerator2 = _interopRequireDefault( __webpack_require__( 2 ) ) ); + } + + let buildActionsForCopy = ( () => { + var _ref = ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*( + queue, + events, + possibleExtraneous, + reporter + ) { + // + let build = ( () => { + var _ref5 = ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( + function*( data ) { + const src = data.src, + dest = data.dest, + type = data.type; + + const onFresh = data.onFresh || noop; + const onDone = data.onDone || noop; + + // TODO https://github.com/yarnpkg/yarn/issues/3751 + // related to bundled dependencies handling + if ( files.has( dest.toLowerCase() ) ) { + reporter.verbose( + `The case-insensitive file ${ dest } shouldn't be copied twice in one bulk copy` + ); + } else { + files.add( dest.toLowerCase() ); + } + + if ( type === 'symlink' ) { + yield mkdirp( ( _path || _load_path() ).default.dirname( dest ) ); + onFresh(); + actions.symlink.push( { + dest, + linkname: src, + } ); + onDone(); + return; + } + + if ( + events.ignoreBasenames.indexOf( + ( _path || _load_path() ).default.basename( src ) + ) >= 0 + ) { + // ignored file + return; + } + + const srcStat = yield lstat( src ); + let srcFiles; + + if ( srcStat.isDirectory() ) { + srcFiles = yield readdir( src ); + } + + let destStat; + try { + // try accessing the destination + destStat = yield lstat( dest ); + } catch ( e ) { + // proceed if destination doesn't exist, otherwise error + if ( e.code !== 'ENOENT' ) { + throw e; + } + } + + // if destination exists + if ( destStat ) { + const bothSymlinks = srcStat.isSymbolicLink() && destStat.isSymbolicLink(); + const bothFolders = srcStat.isDirectory() && destStat.isDirectory(); + const bothFiles = srcStat.isFile() && destStat.isFile(); + + // EINVAL access errors sometimes happen which shouldn't because node shouldn't be giving + // us modes that aren't valid. investigate this, it's generally safe to proceed. + + /* if (srcStat.mode !== destStat.mode) { + try { + await access(dest, srcStat.mode); + } catch (err) {} + } */ + + if ( bothFiles && artifactFiles.has( dest ) ) { + // this file gets changed during build, likely by a custom install script. Don't bother checking it. + onDone(); + reporter.verbose( reporter.lang( 'verboseFileSkipArtifact', src ) ); + return; + } + + if ( + bothFiles && + srcStat.size === destStat.size && + ( 0, ( _fsNormalized || _load_fsNormalized() ).fileDatesEqual )( + srcStat.mtime, + destStat.mtime + ) + ) { + // we can safely assume this is the same file + onDone(); + reporter.verbose( + reporter.lang( 'verboseFileSkip', src, dest, srcStat.size, +srcStat.mtime ) + ); + return; + } + + if ( bothSymlinks ) { + const srcReallink = yield readlink( src ); + if ( srcReallink === ( yield readlink( dest ) ) ) { + // if both symlinks are the same then we can continue on + onDone(); + reporter.verbose( + reporter.lang( 'verboseFileSkipSymlink', src, dest, srcReallink ) + ); + return; + } + } + + if ( bothFolders ) { + // mark files that aren't in this folder as possibly extraneous + const destFiles = yield readdir( dest ); + invariant( srcFiles, 'src files not initialised' ); + + for ( + var _iterator4 = destFiles, + _isArray4 = Array.isArray( _iterator4 ), + _i4 = 0, + _iterator4 = _isArray4 ? _iterator4 : _iterator4[ Symbol.iterator ](); + ; + + ) { + var _ref6; + + if ( _isArray4 ) { + if ( _i4 >= _iterator4.length ) break; + _ref6 = _iterator4[ _i4++ ]; + } else { + _i4 = _iterator4.next(); + if ( _i4.done ) break; + _ref6 = _i4.value; + } + + const file = _ref6; + + if ( srcFiles.indexOf( file ) < 0 ) { + const loc = ( _path || _load_path() ).default.join( dest, file ); + possibleExtraneous.add( loc ); + + if ( ( yield lstat( loc ) ).isDirectory() ) { + for ( + var _iterator5 = yield readdir( loc ), + _isArray5 = Array.isArray( _iterator5 ), + _i5 = 0, + _iterator5 = _isArray5 ? _iterator5 : _iterator5[ Symbol.iterator ](); + ; + + ) { + var _ref7; + + if ( _isArray5 ) { + if ( _i5 >= _iterator5.length ) break; + _ref7 = _iterator5[ _i5++ ]; + } else { + _i5 = _iterator5.next(); + if ( _i5.done ) break; + _ref7 = _i5.value; + } + + const file = _ref7; + + possibleExtraneous.add( + ( _path || _load_path() ).default.join( loc, file ) + ); + } + } + } + } + } + } + + if ( destStat && destStat.isSymbolicLink() ) { + yield ( 0, ( _fsNormalized || _load_fsNormalized() ).unlink )( dest ); + destStat = null; + } + + if ( srcStat.isSymbolicLink() ) { + onFresh(); + const linkname = yield readlink( src ); + actions.symlink.push( { + dest, + linkname, + } ); + onDone(); + } else if ( srcStat.isDirectory() ) { + if ( ! destStat ) { + reporter.verbose( reporter.lang( 'verboseFileFolder', dest ) ); + yield mkdirp( dest ); + } + + const destParts = dest.split( ( _path || _load_path() ).default.sep ); + while ( destParts.length ) { + files.add( + destParts.join( ( _path || _load_path() ).default.sep ).toLowerCase() + ); + destParts.pop(); + } + + // push all files to queue + invariant( srcFiles, 'src files not initialised' ); + let remaining = srcFiles.length; + if ( ! remaining ) { + onDone(); + } + for ( + var _iterator6 = srcFiles, + _isArray6 = Array.isArray( _iterator6 ), + _i6 = 0, + _iterator6 = _isArray6 ? _iterator6 : _iterator6[ Symbol.iterator ](); + ; + + ) { + var _ref8; + + if ( _isArray6 ) { + if ( _i6 >= _iterator6.length ) break; + _ref8 = _iterator6[ _i6++ ]; + } else { + _i6 = _iterator6.next(); + if ( _i6.done ) break; + _ref8 = _i6.value; + } + + const file = _ref8; + + queue.push( { + dest: ( _path || _load_path() ).default.join( dest, file ), + onFresh, + onDone: ( function( _onDone ) { + function onDone() { + return _onDone.apply( this, arguments ); + } + + onDone.toString = function() { + return _onDone.toString(); + }; + + return onDone; + } )( function() { + if ( --remaining === 0 ) { + onDone(); + } + } ), + src: ( _path || _load_path() ).default.join( src, file ), + } ); + } + } else if ( srcStat.isFile() ) { + onFresh(); + actions.file.push( { + src, + dest, + atime: srcStat.atime, + mtime: srcStat.mtime, + mode: srcStat.mode, + } ); + onDone(); + } else { + throw new Error( `unsure how to copy this: ${ src }` ); + } + } + ); + + return function build( _x5 ) { + return _ref5.apply( this, arguments ); + }; + } )(); + + const artifactFiles = new Set( events.artifactFiles || [] ); + const files = new Set(); + + // initialise events + for ( + var _iterator = queue, + _isArray = Array.isArray( _iterator ), + _i = 0, + _iterator = _isArray ? _iterator : _iterator[ Symbol.iterator ](); + ; + + ) { + var _ref2; + + if ( _isArray ) { + if ( _i >= _iterator.length ) break; + _ref2 = _iterator[ _i++ ]; + } else { + _i = _iterator.next(); + if ( _i.done ) break; + _ref2 = _i.value; + } + + const item = _ref2; + + const onDone = item.onDone; + item.onDone = function() { + events.onProgress( item.dest ); + if ( onDone ) { + onDone(); + } + }; + } + events.onStart( queue.length ); + + // start building actions + const actions = { + file: [], + symlink: [], + link: [], + }; + + // custom concurrency logic as we're always executing stacks of CONCURRENT_QUEUE_ITEMS queue items + // at a time due to the requirement to push items onto the queue + while ( queue.length ) { + const items = queue.splice( 0, CONCURRENT_QUEUE_ITEMS ); + yield Promise.all( items.map( build ) ); + } + + // simulate the existence of some files to prevent considering them extraneous + for ( + var _iterator2 = artifactFiles, + _isArray2 = Array.isArray( _iterator2 ), + _i2 = 0, + _iterator2 = _isArray2 ? _iterator2 : _iterator2[ Symbol.iterator ](); + ; + + ) { + var _ref3; + + if ( _isArray2 ) { + if ( _i2 >= _iterator2.length ) break; + _ref3 = _iterator2[ _i2++ ]; + } else { + _i2 = _iterator2.next(); + if ( _i2.done ) break; + _ref3 = _i2.value; + } + + const file = _ref3; + + if ( possibleExtraneous.has( file ) ) { + reporter.verbose( reporter.lang( 'verboseFilePhantomExtraneous', file ) ); + possibleExtraneous.delete( file ); + } + } + + for ( + var _iterator3 = possibleExtraneous, + _isArray3 = Array.isArray( _iterator3 ), + _i3 = 0, + _iterator3 = _isArray3 ? _iterator3 : _iterator3[ Symbol.iterator ](); + ; + + ) { + var _ref4; + + if ( _isArray3 ) { + if ( _i3 >= _iterator3.length ) break; + _ref4 = _iterator3[ _i3++ ]; + } else { + _i3 = _iterator3.next(); + if ( _i3.done ) break; + _ref4 = _i3.value; + } + + const loc = _ref4; + + if ( files.has( loc.toLowerCase() ) ) { + possibleExtraneous.delete( loc ); + } + } + + return actions; + } ); + + return function buildActionsForCopy( _x, _x2, _x3, _x4 ) { + return _ref.apply( this, arguments ); + }; + } )(); + + let buildActionsForHardlink = ( () => { + var _ref9 = ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*( + queue, + events, + possibleExtraneous, + reporter + ) { + // + let build = ( () => { + var _ref13 = ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( + function*( data ) { + const src = data.src, + dest = data.dest; + + const onFresh = data.onFresh || noop; + const onDone = data.onDone || noop; + if ( files.has( dest.toLowerCase() ) ) { + // Fixes issue https://github.com/yarnpkg/yarn/issues/2734 + // When bulk hardlinking we have A -> B structure that we want to hardlink to A1 -> B1, + // package-linker passes that modules A1 and B1 need to be hardlinked, + // the recursive linking algorithm of A1 ends up scheduling files in B1 to be linked twice which will case + // an exception. + onDone(); + return; + } + files.add( dest.toLowerCase() ); + + if ( + events.ignoreBasenames.indexOf( + ( _path || _load_path() ).default.basename( src ) + ) >= 0 + ) { + // ignored file + return; + } + + const srcStat = yield lstat( src ); + let srcFiles; + + if ( srcStat.isDirectory() ) { + srcFiles = yield readdir( src ); + } + + const destExists = yield exists( dest ); + if ( destExists ) { + const destStat = yield lstat( dest ); + + const bothSymlinks = srcStat.isSymbolicLink() && destStat.isSymbolicLink(); + const bothFolders = srcStat.isDirectory() && destStat.isDirectory(); + const bothFiles = srcStat.isFile() && destStat.isFile(); + + if ( srcStat.mode !== destStat.mode ) { + try { + yield access( dest, srcStat.mode ); + } catch ( err ) { + // EINVAL access errors sometimes happen which shouldn't because node shouldn't be giving + // us modes that aren't valid. investigate this, it's generally safe to proceed. + reporter.verbose( err ); + } + } + + if ( bothFiles && artifactFiles.has( dest ) ) { + // this file gets changed during build, likely by a custom install script. Don't bother checking it. + onDone(); + reporter.verbose( reporter.lang( 'verboseFileSkipArtifact', src ) ); + return; + } + + // correct hardlink + if ( bothFiles && srcStat.ino !== null && srcStat.ino === destStat.ino ) { + onDone(); + reporter.verbose( reporter.lang( 'verboseFileSkip', src, dest, srcStat.ino ) ); + return; + } + + if ( bothSymlinks ) { + const srcReallink = yield readlink( src ); + if ( srcReallink === ( yield readlink( dest ) ) ) { + // if both symlinks are the same then we can continue on + onDone(); + reporter.verbose( + reporter.lang( 'verboseFileSkipSymlink', src, dest, srcReallink ) + ); + return; + } + } + + if ( bothFolders ) { + // mark files that aren't in this folder as possibly extraneous + const destFiles = yield readdir( dest ); + invariant( srcFiles, 'src files not initialised' ); + + for ( + var _iterator10 = destFiles, + _isArray10 = Array.isArray( _iterator10 ), + _i10 = 0, + _iterator10 = _isArray10 ? _iterator10 : _iterator10[ Symbol.iterator ](); + ; + + ) { + var _ref14; + + if ( _isArray10 ) { + if ( _i10 >= _iterator10.length ) break; + _ref14 = _iterator10[ _i10++ ]; + } else { + _i10 = _iterator10.next(); + if ( _i10.done ) break; + _ref14 = _i10.value; + } + + const file = _ref14; + + if ( srcFiles.indexOf( file ) < 0 ) { + const loc = ( _path || _load_path() ).default.join( dest, file ); + possibleExtraneous.add( loc ); + + if ( ( yield lstat( loc ) ).isDirectory() ) { + for ( + var _iterator11 = yield readdir( loc ), + _isArray11 = Array.isArray( _iterator11 ), + _i11 = 0, + _iterator11 = _isArray11 + ? _iterator11 + : _iterator11[ Symbol.iterator ](); + ; + + ) { + var _ref15; + + if ( _isArray11 ) { + if ( _i11 >= _iterator11.length ) break; + _ref15 = _iterator11[ _i11++ ]; + } else { + _i11 = _iterator11.next(); + if ( _i11.done ) break; + _ref15 = _i11.value; + } + + const file = _ref15; + + possibleExtraneous.add( + ( _path || _load_path() ).default.join( loc, file ) + ); + } + } + } + } + } + } + + if ( srcStat.isSymbolicLink() ) { + onFresh(); + const linkname = yield readlink( src ); + actions.symlink.push( { + dest, + linkname, + } ); + onDone(); + } else if ( srcStat.isDirectory() ) { + reporter.verbose( reporter.lang( 'verboseFileFolder', dest ) ); + yield mkdirp( dest ); + + const destParts = dest.split( ( _path || _load_path() ).default.sep ); + while ( destParts.length ) { + files.add( + destParts.join( ( _path || _load_path() ).default.sep ).toLowerCase() + ); + destParts.pop(); + } + + // push all files to queue + invariant( srcFiles, 'src files not initialised' ); + let remaining = srcFiles.length; + if ( ! remaining ) { + onDone(); + } + for ( + var _iterator12 = srcFiles, + _isArray12 = Array.isArray( _iterator12 ), + _i12 = 0, + _iterator12 = _isArray12 ? _iterator12 : _iterator12[ Symbol.iterator ](); + ; + + ) { + var _ref16; + + if ( _isArray12 ) { + if ( _i12 >= _iterator12.length ) break; + _ref16 = _iterator12[ _i12++ ]; + } else { + _i12 = _iterator12.next(); + if ( _i12.done ) break; + _ref16 = _i12.value; + } + + const file = _ref16; + + queue.push( { + onFresh, + src: ( _path || _load_path() ).default.join( src, file ), + dest: ( _path || _load_path() ).default.join( dest, file ), + onDone: ( function( _onDone2 ) { + function onDone() { + return _onDone2.apply( this, arguments ); + } + + onDone.toString = function() { + return _onDone2.toString(); + }; + + return onDone; + } )( function() { + if ( --remaining === 0 ) { + onDone(); + } + } ), + } ); + } + } else if ( srcStat.isFile() ) { + onFresh(); + actions.link.push( { + src, + dest, + removeDest: destExists, + } ); + onDone(); + } else { + throw new Error( `unsure how to copy this: ${ src }` ); + } + } + ); + + return function build( _x10 ) { + return _ref13.apply( this, arguments ); + }; + } )(); + + const artifactFiles = new Set( events.artifactFiles || [] ); + const files = new Set(); + + // initialise events + for ( + var _iterator7 = queue, + _isArray7 = Array.isArray( _iterator7 ), + _i7 = 0, + _iterator7 = _isArray7 ? _iterator7 : _iterator7[ Symbol.iterator ](); + ; + + ) { + var _ref10; + + if ( _isArray7 ) { + if ( _i7 >= _iterator7.length ) break; + _ref10 = _iterator7[ _i7++ ]; + } else { + _i7 = _iterator7.next(); + if ( _i7.done ) break; + _ref10 = _i7.value; + } + + const item = _ref10; + + const onDone = item.onDone || noop; + item.onDone = function() { + events.onProgress( item.dest ); + onDone(); + }; + } + events.onStart( queue.length ); + + // start building actions + const actions = { + file: [], + symlink: [], + link: [], + }; + + // custom concurrency logic as we're always executing stacks of CONCURRENT_QUEUE_ITEMS queue items + // at a time due to the requirement to push items onto the queue + while ( queue.length ) { + const items = queue.splice( 0, CONCURRENT_QUEUE_ITEMS ); + yield Promise.all( items.map( build ) ); + } + + // simulate the existence of some files to prevent considering them extraneous + for ( + var _iterator8 = artifactFiles, + _isArray8 = Array.isArray( _iterator8 ), + _i8 = 0, + _iterator8 = _isArray8 ? _iterator8 : _iterator8[ Symbol.iterator ](); + ; + + ) { + var _ref11; + + if ( _isArray8 ) { + if ( _i8 >= _iterator8.length ) break; + _ref11 = _iterator8[ _i8++ ]; + } else { + _i8 = _iterator8.next(); + if ( _i8.done ) break; + _ref11 = _i8.value; + } + + const file = _ref11; + + if ( possibleExtraneous.has( file ) ) { + reporter.verbose( reporter.lang( 'verboseFilePhantomExtraneous', file ) ); + possibleExtraneous.delete( file ); + } + } + + for ( + var _iterator9 = possibleExtraneous, + _isArray9 = Array.isArray( _iterator9 ), + _i9 = 0, + _iterator9 = _isArray9 ? _iterator9 : _iterator9[ Symbol.iterator ](); + ; + + ) { + var _ref12; + + if ( _isArray9 ) { + if ( _i9 >= _iterator9.length ) break; + _ref12 = _iterator9[ _i9++ ]; + } else { + _i9 = _iterator9.next(); + if ( _i9.done ) break; + _ref12 = _i9.value; + } + + const loc = _ref12; + + if ( files.has( loc.toLowerCase() ) ) { + possibleExtraneous.delete( loc ); + } + } + + return actions; + } ); + + return function buildActionsForHardlink( _x6, _x7, _x8, _x9 ) { + return _ref9.apply( this, arguments ); + }; + } )(); + + let copyBulk = ( exports.copyBulk = ( () => { + var _ref17 = ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*( + queue, + reporter, + _events + ) { + const events = { + onStart: ( _events && _events.onStart ) || noop, + onProgress: ( _events && _events.onProgress ) || noop, + possibleExtraneous: _events ? _events.possibleExtraneous : new Set(), + ignoreBasenames: ( _events && _events.ignoreBasenames ) || [], + artifactFiles: ( _events && _events.artifactFiles ) || [], + }; + + const actions = yield buildActionsForCopy( + queue, + events, + events.possibleExtraneous, + reporter + ); + events.onStart( actions.file.length + actions.symlink.length + actions.link.length ); + + const fileActions = actions.file; + + const currentlyWriting = new Map(); + + yield ( _promise || _load_promise() ).queue( + fileActions, + ( () => { + var _ref18 = ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( + function*( data ) { + let writePromise; + while ( ( writePromise = currentlyWriting.get( data.dest ) ) ) { + yield writePromise; + } + + reporter.verbose( reporter.lang( 'verboseFileCopy', data.src, data.dest ) ); + const copier = ( 0, ( _fsNormalized || _load_fsNormalized() ).copyFile )( + data, + function() { + return currentlyWriting.delete( data.dest ); + } + ); + currentlyWriting.set( data.dest, copier ); + events.onProgress( data.dest ); + return copier; + } + ); + + return function( _x14 ) { + return _ref18.apply( this, arguments ); + }; + } )(), + CONCURRENT_QUEUE_ITEMS + ); + + // we need to copy symlinks last as they could reference files we were copying + const symlinkActions = actions.symlink; + yield ( _promise || _load_promise() ).queue( symlinkActions, function( data ) { + const linkname = ( _path || _load_path() ).default.resolve( + ( _path || _load_path() ).default.dirname( data.dest ), + data.linkname + ); + reporter.verbose( reporter.lang( 'verboseFileSymlink', data.dest, linkname ) ); + return symlink( linkname, data.dest ); + } ); + } ); + + return function copyBulk( _x11, _x12, _x13 ) { + return _ref17.apply( this, arguments ); + }; + } )() ); + + let hardlinkBulk = ( exports.hardlinkBulk = ( () => { + var _ref19 = ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*( + queue, + reporter, + _events + ) { + const events = { + onStart: ( _events && _events.onStart ) || noop, + onProgress: ( _events && _events.onProgress ) || noop, + possibleExtraneous: _events ? _events.possibleExtraneous : new Set(), + artifactFiles: ( _events && _events.artifactFiles ) || [], + ignoreBasenames: [], + }; + + const actions = yield buildActionsForHardlink( + queue, + events, + events.possibleExtraneous, + reporter + ); + events.onStart( actions.file.length + actions.symlink.length + actions.link.length ); + + const fileActions = actions.link; + + yield ( _promise || _load_promise() ).queue( + fileActions, + ( () => { + var _ref20 = ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( + function*( data ) { + reporter.verbose( reporter.lang( 'verboseFileLink', data.src, data.dest ) ); + if ( data.removeDest ) { + yield ( 0, ( _fsNormalized || _load_fsNormalized() ).unlink )( data.dest ); + } + yield link( data.src, data.dest ); + } + ); + + return function( _x18 ) { + return _ref20.apply( this, arguments ); + }; + } )(), + CONCURRENT_QUEUE_ITEMS + ); + + // we need to copy symlinks last as they could reference files we were copying + const symlinkActions = actions.symlink; + yield ( _promise || _load_promise() ).queue( symlinkActions, function( data ) { + const linkname = ( _path || _load_path() ).default.resolve( + ( _path || _load_path() ).default.dirname( data.dest ), + data.linkname + ); + reporter.verbose( reporter.lang( 'verboseFileSymlink', data.dest, linkname ) ); + return symlink( linkname, data.dest ); + } ); + } ); + + return function hardlinkBulk( _x15, _x16, _x17 ) { + return _ref19.apply( this, arguments ); + }; + } )() ); + + let readFileAny = ( exports.readFileAny = ( () => { + var _ref21 = ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*( + files + ) { + for ( + var _iterator13 = files, + _isArray13 = Array.isArray( _iterator13 ), + _i13 = 0, + _iterator13 = _isArray13 ? _iterator13 : _iterator13[ Symbol.iterator ](); + ; + + ) { + var _ref22; + + if ( _isArray13 ) { + if ( _i13 >= _iterator13.length ) break; + _ref22 = _iterator13[ _i13++ ]; + } else { + _i13 = _iterator13.next(); + if ( _i13.done ) break; + _ref22 = _i13.value; + } + + const file = _ref22; + + if ( yield exists( file ) ) { + return readFile( file ); + } + } + return null; + } ); + + return function readFileAny( _x19 ) { + return _ref21.apply( this, arguments ); + }; + } )() ); + + let readJson = ( exports.readJson = ( () => { + var _ref23 = ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*( + loc + ) { + return ( yield readJsonAndFile( loc ) ).object; + } ); + + return function readJson( _x20 ) { + return _ref23.apply( this, arguments ); + }; + } )() ); + + let readJsonAndFile = ( exports.readJsonAndFile = ( () => { + var _ref24 = ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*( + loc + ) { + const file = yield readFile( loc ); + try { + return { + object: ( 0, ( _map || _load_map() ).default )( JSON.parse( stripBOM( file ) ) ), + content: file, + }; + } catch ( err ) { + err.message = `${ loc }: ${ err.message }`; + throw err; + } + } ); + + return function readJsonAndFile( _x21 ) { + return _ref24.apply( this, arguments ); + }; + } )() ); + + let find = ( exports.find = ( () => { + var _ref25 = ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*( + filename, + dir + ) { + const parts = dir.split( ( _path || _load_path() ).default.sep ); + + while ( parts.length ) { + const loc = parts.concat( filename ).join( ( _path || _load_path() ).default.sep ); + + if ( yield exists( loc ) ) { + return loc; + } else { + parts.pop(); + } + } + + return false; + } ); + + return function find( _x22, _x23 ) { + return _ref25.apply( this, arguments ); + }; + } )() ); + + let symlink = ( exports.symlink = ( () => { + var _ref26 = ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*( + src, + dest + ) { + if ( process.platform !== 'win32' ) { + // use relative paths otherwise which will be retained if the directory is moved + src = ( _path || _load_path() ).default.relative( + ( _path || _load_path() ).default.dirname( dest ), + src + ); + // When path.relative returns an empty string for the current directory, we should instead use + // '.', which is a valid fs.symlink target. + src = src || '.'; + } + + try { + const stats = yield lstat( dest ); + if ( stats.isSymbolicLink() ) { + const resolved = dest; + if ( resolved === src ) { + return; + } + } + } catch ( err ) { + if ( err.code !== 'ENOENT' ) { + throw err; + } + } + + // We use rimraf for unlink which never throws an ENOENT on missing target + yield ( 0, ( _fsNormalized || _load_fsNormalized() ).unlink )( dest ); + + if ( process.platform === 'win32' ) { + // use directory junctions if possible on win32, this requires absolute paths + yield fsSymlink( src, dest, 'junction' ); + } else { + yield fsSymlink( src, dest ); + } + } ); + + return function symlink( _x24, _x25 ) { + return _ref26.apply( this, arguments ); + }; + } )() ); + + let walk = ( exports.walk = ( () => { + var _ref27 = ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*( + dir, + relativeDir, + ignoreBasenames = new Set() + ) { + let files = []; + + let filenames = yield readdir( dir ); + if ( ignoreBasenames.size ) { + filenames = filenames.filter( function( name ) { + return ! ignoreBasenames.has( name ); + } ); + } + + for ( + var _iterator14 = filenames, + _isArray14 = Array.isArray( _iterator14 ), + _i14 = 0, + _iterator14 = _isArray14 ? _iterator14 : _iterator14[ Symbol.iterator ](); + ; + + ) { + var _ref28; + + if ( _isArray14 ) { + if ( _i14 >= _iterator14.length ) break; + _ref28 = _iterator14[ _i14++ ]; + } else { + _i14 = _iterator14.next(); + if ( _i14.done ) break; + _ref28 = _i14.value; + } + + const name = _ref28; + + const relative = relativeDir + ? ( _path || _load_path() ).default.join( relativeDir, name ) + : name; + const loc = ( _path || _load_path() ).default.join( dir, name ); + const stat = yield lstat( loc ); + + files.push( { + relative, + basename: name, + absolute: loc, + mtime: +stat.mtime, + } ); + + if ( stat.isDirectory() ) { + files = files.concat( yield walk( loc, relative, ignoreBasenames ) ); + } + } + + return files; + } ); + + return function walk( _x26, _x27 ) { + return _ref27.apply( this, arguments ); + }; + } )() ); + + let getFileSizeOnDisk = ( exports.getFileSizeOnDisk = ( () => { + var _ref29 = ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*( + loc + ) { + const stat = yield lstat( loc ); + const size = stat.size, + blockSize = stat.blksize; + + return Math.ceil( size / blockSize ) * blockSize; + } ); + + return function getFileSizeOnDisk( _x28 ) { + return _ref29.apply( this, arguments ); + }; + } )() ); + + let getEolFromFile = ( () => { + var _ref30 = ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*( + path + ) { + if ( ! ( yield exists( path ) ) ) { + return undefined; + } + + const buffer = yield readFileBuffer( path ); + + for ( let i = 0; i < buffer.length; ++i ) { + if ( buffer[ i ] === cr ) { + return '\r\n'; + } + if ( buffer[ i ] === lf ) { + return '\n'; + } + } + return undefined; + } ); + + return function getEolFromFile( _x29 ) { + return _ref30.apply( this, arguments ); + }; + } )(); + + let writeFilePreservingEol = ( exports.writeFilePreservingEol = ( () => { + var _ref31 = ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*( + path, + data + ) { + const eol = ( yield getEolFromFile( path ) ) || ( _os || _load_os() ).default.EOL; + if ( eol !== '\n' ) { + data = data.replace( /\n/g, eol ); + } + yield writeFile( path, data ); + } ); + + return function writeFilePreservingEol( _x30, _x31 ) { + return _ref31.apply( this, arguments ); + }; + } )() ); + + let hardlinksWork = ( exports.hardlinksWork = ( () => { + var _ref32 = ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*( + dir + ) { + const filename = 'test-file' + Math.random(); + const file = ( _path || _load_path() ).default.join( dir, filename ); + const fileLink = ( _path || _load_path() ).default.join( dir, filename + '-link' ); + try { + yield writeFile( file, 'test' ); + yield link( file, fileLink ); + } catch ( err ) { + return false; + } finally { + yield ( 0, ( _fsNormalized || _load_fsNormalized() ).unlink )( file ); + yield ( 0, ( _fsNormalized || _load_fsNormalized() ).unlink )( fileLink ); + } + return true; + } ); + + return function hardlinksWork( _x32 ) { + return _ref32.apply( this, arguments ); + }; + } )() ); + + // not a strict polyfill for Node's fs.mkdtemp + + let makeTempDir = ( exports.makeTempDir = ( () => { + var _ref33 = ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*( + prefix + ) { + const dir = ( _path || _load_path() ).default.join( + ( _os || _load_os() ).default.tmpdir(), + `yarn-${ prefix || '' }-${ Date.now() }-${ Math.random() }` + ); + yield ( 0, ( _fsNormalized || _load_fsNormalized() ).unlink )( dir ); + yield mkdirp( dir ); + return dir; + } ); + + return function makeTempDir( _x33 ) { + return _ref33.apply( this, arguments ); + }; + } )() ); + + let readFirstAvailableStream = ( exports.readFirstAvailableStream = ( () => { + var _ref34 = ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*( + paths + ) { + for ( + var _iterator15 = paths, + _isArray15 = Array.isArray( _iterator15 ), + _i15 = 0, + _iterator15 = _isArray15 ? _iterator15 : _iterator15[ Symbol.iterator ](); + ; + + ) { + var _ref35; + + if ( _isArray15 ) { + if ( _i15 >= _iterator15.length ) break; + _ref35 = _iterator15[ _i15++ ]; + } else { + _i15 = _iterator15.next(); + if ( _i15.done ) break; + _ref35 = _i15.value; + } + + const path = _ref35; + + try { + const fd = yield open( path, 'r' ); + return ( _fs || _load_fs() ).default.createReadStream( path, { fd } ); + } catch ( err ) { + // Try the next one + } + } + return null; + } ); + + return function readFirstAvailableStream( _x34 ) { + return _ref34.apply( this, arguments ); + }; + } )() ); + + let getFirstSuitableFolder = ( exports.getFirstSuitableFolder = ( () => { + var _ref36 = ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*( + paths, + mode = constants.W_OK | constants.X_OK + ) { + const result = { + skipped: [], + folder: null, + }; + + for ( + var _iterator16 = paths, + _isArray16 = Array.isArray( _iterator16 ), + _i16 = 0, + _iterator16 = _isArray16 ? _iterator16 : _iterator16[ Symbol.iterator ](); + ; + + ) { + var _ref37; + + if ( _isArray16 ) { + if ( _i16 >= _iterator16.length ) break; + _ref37 = _iterator16[ _i16++ ]; + } else { + _i16 = _iterator16.next(); + if ( _i16.done ) break; + _ref37 = _i16.value; + } + + const folder = _ref37; + + try { + yield mkdirp( folder ); + yield access( folder, mode ); + + result.folder = folder; + + return result; + } catch ( error ) { + result.skipped.push( { + error, + folder, + } ); + } + } + return result; + } ); + + return function getFirstSuitableFolder( _x35 ) { + return _ref36.apply( this, arguments ); + }; + } )() ); + + exports.copy = copy; + exports.readFile = readFile; + exports.readFileRaw = readFileRaw; + exports.normalizeOS = normalizeOS; + + var _fs; + + function _load_fs() { + return ( _fs = _interopRequireDefault( __webpack_require__( 5 ) ) ); + } + + var _glob; + + function _load_glob() { + return ( _glob = _interopRequireDefault( __webpack_require__( 99 ) ) ); + } + + var _os; + + function _load_os() { + return ( _os = _interopRequireDefault( __webpack_require__( 46 ) ) ); + } + + var _path; + + function _load_path() { + return ( _path = _interopRequireDefault( __webpack_require__( 0 ) ) ); + } + + var _blockingQueue; + + function _load_blockingQueue() { + return ( _blockingQueue = _interopRequireDefault( __webpack_require__( 110 ) ) ); + } + + var _promise; + + function _load_promise() { + return ( _promise = _interopRequireWildcard( __webpack_require__( 50 ) ) ); + } + + var _promise2; + + function _load_promise2() { + return ( _promise2 = __webpack_require__( 50 ) ); + } + + var _map; + + function _load_map() { + return ( _map = _interopRequireDefault( __webpack_require__( 29 ) ) ); + } + + var _fsNormalized; + + function _load_fsNormalized() { + return ( _fsNormalized = __webpack_require__( 218 ) ); + } + + function _interopRequireWildcard( obj ) { + if ( obj && obj.__esModule ) { + return obj; + } else { + var newObj = {}; + if ( obj != null ) { + for ( var key in obj ) { + if ( Object.prototype.hasOwnProperty.call( obj, key ) ) newObj[ key ] = obj[ key ]; + } + } + newObj.default = obj; + return newObj; + } + } + + function _interopRequireDefault( obj ) { + return obj && obj.__esModule ? obj : { default: obj }; + } + + const constants = ( exports.constants = + typeof ( _fs || _load_fs() ).default.constants !== 'undefined' + ? ( _fs || _load_fs() ).default.constants + : { + R_OK: ( _fs || _load_fs() ).default.R_OK, + W_OK: ( _fs || _load_fs() ).default.W_OK, + X_OK: ( _fs || _load_fs() ).default.X_OK, + } ); + + const lockQueue = ( exports.lockQueue = new ( + _blockingQueue || _load_blockingQueue() + ).default( 'fs lock' ) ); + + const readFileBuffer = ( exports.readFileBuffer = ( 0, + ( _promise2 || _load_promise2() ).promisify )( ( _fs || _load_fs() ).default.readFile ) ); + const open = ( exports.open = ( 0, ( _promise2 || _load_promise2() ).promisify )( + ( _fs || _load_fs() ).default.open + ) ); + const writeFile = ( exports.writeFile = ( 0, ( _promise2 || _load_promise2() ).promisify )( + ( _fs || _load_fs() ).default.writeFile + ) ); + const readlink = ( exports.readlink = ( 0, ( _promise2 || _load_promise2() ).promisify )( + ( _fs || _load_fs() ).default.readlink + ) ); + const realpath = ( exports.realpath = ( 0, ( _promise2 || _load_promise2() ).promisify )( + ( _fs || _load_fs() ).default.realpath + ) ); + const readdir = ( exports.readdir = ( 0, ( _promise2 || _load_promise2() ).promisify )( + ( _fs || _load_fs() ).default.readdir + ) ); + const rename = ( exports.rename = ( 0, ( _promise2 || _load_promise2() ).promisify )( + ( _fs || _load_fs() ).default.rename + ) ); + const access = ( exports.access = ( 0, ( _promise2 || _load_promise2() ).promisify )( + ( _fs || _load_fs() ).default.access + ) ); + const stat = ( exports.stat = ( 0, ( _promise2 || _load_promise2() ).promisify )( + ( _fs || _load_fs() ).default.stat + ) ); + const mkdirp = ( exports.mkdirp = ( 0, ( _promise2 || _load_promise2() ).promisify )( + __webpack_require__( 145 ) + ) ); + const exists = ( exports.exists = ( 0, ( _promise2 || _load_promise2() ).promisify )( + ( _fs || _load_fs() ).default.exists, + true + ) ); + const lstat = ( exports.lstat = ( 0, ( _promise2 || _load_promise2() ).promisify )( + ( _fs || _load_fs() ).default.lstat + ) ); + const chmod = ( exports.chmod = ( 0, ( _promise2 || _load_promise2() ).promisify )( + ( _fs || _load_fs() ).default.chmod + ) ); + const link = ( exports.link = ( 0, ( _promise2 || _load_promise2() ).promisify )( + ( _fs || _load_fs() ).default.link + ) ); + const glob = ( exports.glob = ( 0, ( _promise2 || _load_promise2() ).promisify )( + ( _glob || _load_glob() ).default + ) ); + exports.unlink = ( _fsNormalized || _load_fsNormalized() ).unlink; + + // fs.copyFile uses the native file copying instructions on the system, performing much better + // than any JS-based solution and consumes fewer resources. Repeated testing to fine tune the + // concurrency level revealed 128 as the sweet spot on a quad-core, 16 CPU Intel system with SSD. + + const CONCURRENT_QUEUE_ITEMS = ( _fs || _load_fs() ).default.copyFile ? 128 : 4; + + const fsSymlink = ( 0, ( _promise2 || _load_promise2() ).promisify )( + ( _fs || _load_fs() ).default.symlink + ); + const invariant = __webpack_require__( 9 ); + const stripBOM = __webpack_require__( 160 ); + + const noop = () => {}; + + function copy( src, dest, reporter ) { + return copyBulk( [ { src, dest } ], reporter ); + } + + function _readFile( loc, encoding ) { + return new Promise( ( resolve, reject ) => { + ( _fs || _load_fs() ).default.readFile( loc, encoding, function( err, content ) { + if ( err ) { + reject( err ); + } else { + resolve( content ); + } + } ); + } ); + } + + function readFile( loc ) { + return _readFile( loc, 'utf8' ).then( normalizeOS ); + } + + function readFileRaw( loc ) { + return _readFile( loc, 'binary' ); + } + + function normalizeOS( body ) { + return body.replace( /\r\n/g, '\n' ); + } + + const cr = '\r'.charCodeAt( 0 ); + const lf = '\n'.charCodeAt( 0 ); + + /***/ + }, + /* 5 */ + /***/ function( module, exports ) { + module.exports = require( 'fs' ); + + /***/ + }, + /* 6 */ + /***/ function( module, exports, __webpack_require__ ) { + 'use strict'; + + Object.defineProperty( exports, '__esModule', { + value: true, + } ); + class MessageError extends Error { + constructor( msg, code ) { + super( msg ); + this.code = code; + } + } + + exports.MessageError = MessageError; + class ProcessSpawnError extends MessageError { + constructor( msg, code, process ) { + super( msg, code ); + this.process = process; + } + } + + exports.ProcessSpawnError = ProcessSpawnError; + class SecurityError extends MessageError {} + + exports.SecurityError = SecurityError; + class ProcessTermError extends MessageError {} + + exports.ProcessTermError = ProcessTermError; + class ResponseError extends Error { + constructor( msg, responseCode ) { + super( msg ); + this.responseCode = responseCode; + } + } + + exports.ResponseError = ResponseError; + class OneTimePasswordError extends Error {} + exports.OneTimePasswordError = OneTimePasswordError; + + /***/ + }, + /* 7 */ + /***/ function( module, __webpack_exports__, __webpack_require__ ) { + 'use strict'; + /* harmony export (binding) */ __webpack_require__.d( __webpack_exports__, 'a', function() { + return Subscriber; + } ); + /* unused harmony export SafeSubscriber */ + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__( 1 ); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__util_isFunction__ = __webpack_require__( + 154 + ); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__Observer__ = __webpack_require__( 420 ); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__Subscription__ = __webpack_require__( + 25 + ); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__internal_symbol_rxSubscriber__ = __webpack_require__( + 321 + ); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__config__ = __webpack_require__( 185 ); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__util_hostReportError__ = __webpack_require__( + 323 + ); + /** PURE_IMPORTS_START tslib,_util_isFunction,_Observer,_Subscription,_internal_symbol_rxSubscriber,_config,_util_hostReportError PURE_IMPORTS_END */ + + var Subscriber = /*@__PURE__*/ ( function( _super ) { + __WEBPACK_IMPORTED_MODULE_0_tslib__[ 'a' /* __extends */ ]( Subscriber, _super ); + function Subscriber( destinationOrNext, error, complete ) { + var _this = _super.call( this ) || this; + _this.syncErrorValue = null; + _this.syncErrorThrown = false; + _this.syncErrorThrowable = false; + _this.isStopped = false; + _this._parentSubscription = null; + switch ( arguments.length ) { + case 0: + _this.destination = __WEBPACK_IMPORTED_MODULE_2__Observer__[ 'a' /* empty */ ]; + break; + case 1: + if ( ! destinationOrNext ) { + _this.destination = __WEBPACK_IMPORTED_MODULE_2__Observer__[ 'a' /* empty */ ]; + break; + } + if ( typeof destinationOrNext === 'object' ) { + if ( destinationOrNext instanceof Subscriber ) { + _this.syncErrorThrowable = destinationOrNext.syncErrorThrowable; + _this.destination = destinationOrNext; + destinationOrNext.add( _this ); + } else { + _this.syncErrorThrowable = true; + _this.destination = new SafeSubscriber( _this, destinationOrNext ); + } + break; + } + default: + _this.syncErrorThrowable = true; + _this.destination = new SafeSubscriber( _this, destinationOrNext, error, complete ); + break; + } + return _this; + } + Subscriber.prototype[ + __WEBPACK_IMPORTED_MODULE_4__internal_symbol_rxSubscriber__[ 'a' /* rxSubscriber */ ] + ] = function() { + return this; + }; + Subscriber.create = function( next, error, complete ) { + var subscriber = new Subscriber( next, error, complete ); + subscriber.syncErrorThrowable = false; + return subscriber; + }; + Subscriber.prototype.next = function( value ) { + if ( ! this.isStopped ) { + this._next( value ); + } + }; + Subscriber.prototype.error = function( err ) { + if ( ! this.isStopped ) { + this.isStopped = true; + this._error( err ); + } + }; + Subscriber.prototype.complete = function() { + if ( ! this.isStopped ) { + this.isStopped = true; + this._complete(); + } + }; + Subscriber.prototype.unsubscribe = function() { + if ( this.closed ) { + return; + } + this.isStopped = true; + _super.prototype.unsubscribe.call( this ); + }; + Subscriber.prototype._next = function( value ) { + this.destination.next( value ); + }; + Subscriber.prototype._error = function( err ) { + this.destination.error( err ); + this.unsubscribe(); + }; + Subscriber.prototype._complete = function() { + this.destination.complete(); + this.unsubscribe(); + }; + Subscriber.prototype._unsubscribeAndRecycle = function() { + var _a = this, + _parent = _a._parent, + _parents = _a._parents; + this._parent = null; + this._parents = null; + this.unsubscribe(); + this.closed = false; + this.isStopped = false; + this._parent = _parent; + this._parents = _parents; + this._parentSubscription = null; + return this; + }; + return Subscriber; + } )( __WEBPACK_IMPORTED_MODULE_3__Subscription__[ 'a' /* Subscription */ ] ); + + var SafeSubscriber = /*@__PURE__*/ ( function( _super ) { + __WEBPACK_IMPORTED_MODULE_0_tslib__[ 'a' /* __extends */ ]( SafeSubscriber, _super ); + function SafeSubscriber( _parentSubscriber, observerOrNext, error, complete ) { + var _this = _super.call( this ) || this; + _this._parentSubscriber = _parentSubscriber; + var next; + var context = _this; + if ( + __webpack_require__.i( + __WEBPACK_IMPORTED_MODULE_1__util_isFunction__[ 'a' /* isFunction */ ] + )( observerOrNext ) + ) { + next = observerOrNext; + } else if ( observerOrNext ) { + next = observerOrNext.next; + error = observerOrNext.error; + complete = observerOrNext.complete; + if ( observerOrNext !== __WEBPACK_IMPORTED_MODULE_2__Observer__[ 'a' /* empty */ ] ) { + context = Object.create( observerOrNext ); + if ( + __webpack_require__.i( + __WEBPACK_IMPORTED_MODULE_1__util_isFunction__[ 'a' /* isFunction */ ] + )( context.unsubscribe ) + ) { + _this.add( context.unsubscribe.bind( context ) ); + } + context.unsubscribe = _this.unsubscribe.bind( _this ); + } + } + _this._context = context; + _this._next = next; + _this._error = error; + _this._complete = complete; + return _this; + } + SafeSubscriber.prototype.next = function( value ) { + if ( ! this.isStopped && this._next ) { + var _parentSubscriber = this._parentSubscriber; + if ( + ! __WEBPACK_IMPORTED_MODULE_5__config__[ 'a' /* config */ ] + .useDeprecatedSynchronousErrorHandling || + ! _parentSubscriber.syncErrorThrowable + ) { + this.__tryOrUnsub( this._next, value ); + } else if ( this.__tryOrSetError( _parentSubscriber, this._next, value ) ) { + this.unsubscribe(); + } + } + }; + SafeSubscriber.prototype.error = function( err ) { + if ( ! this.isStopped ) { + var _parentSubscriber = this._parentSubscriber; + var useDeprecatedSynchronousErrorHandling = + __WEBPACK_IMPORTED_MODULE_5__config__[ 'a' /* config */ ] + .useDeprecatedSynchronousErrorHandling; + if ( this._error ) { + if ( + ! useDeprecatedSynchronousErrorHandling || + ! _parentSubscriber.syncErrorThrowable + ) { + this.__tryOrUnsub( this._error, err ); + this.unsubscribe(); + } else { + this.__tryOrSetError( _parentSubscriber, this._error, err ); + this.unsubscribe(); + } + } else if ( ! _parentSubscriber.syncErrorThrowable ) { + this.unsubscribe(); + if ( useDeprecatedSynchronousErrorHandling ) { + throw err; + } + __webpack_require__.i( + __WEBPACK_IMPORTED_MODULE_6__util_hostReportError__[ 'a' /* hostReportError */ ] + )( err ); + } else { + if ( useDeprecatedSynchronousErrorHandling ) { + _parentSubscriber.syncErrorValue = err; + _parentSubscriber.syncErrorThrown = true; + } else { + __webpack_require__.i( + __WEBPACK_IMPORTED_MODULE_6__util_hostReportError__[ 'a' /* hostReportError */ ] + )( err ); + } + this.unsubscribe(); + } + } + }; + SafeSubscriber.prototype.complete = function() { + var _this = this; + if ( ! this.isStopped ) { + var _parentSubscriber = this._parentSubscriber; + if ( this._complete ) { + var wrappedComplete = function() { + return _this._complete.call( _this._context ); + }; + if ( + ! __WEBPACK_IMPORTED_MODULE_5__config__[ 'a' /* config */ ] + .useDeprecatedSynchronousErrorHandling || + ! _parentSubscriber.syncErrorThrowable + ) { + this.__tryOrUnsub( wrappedComplete ); + this.unsubscribe(); + } else { + this.__tryOrSetError( _parentSubscriber, wrappedComplete ); + this.unsubscribe(); + } + } else { + this.unsubscribe(); + } + } + }; + SafeSubscriber.prototype.__tryOrUnsub = function( fn, value ) { + try { + fn.call( this._context, value ); + } catch ( err ) { + this.unsubscribe(); + if ( + __WEBPACK_IMPORTED_MODULE_5__config__[ 'a' /* config */ ] + .useDeprecatedSynchronousErrorHandling + ) { + throw err; + } else { + __webpack_require__.i( + __WEBPACK_IMPORTED_MODULE_6__util_hostReportError__[ 'a' /* hostReportError */ ] + )( err ); + } + } + }; + SafeSubscriber.prototype.__tryOrSetError = function( parent, fn, value ) { + if ( + ! __WEBPACK_IMPORTED_MODULE_5__config__[ 'a' /* config */ ] + .useDeprecatedSynchronousErrorHandling + ) { + throw new Error( 'bad call' ); + } + try { + fn.call( this._context, value ); + } catch ( err ) { + if ( + __WEBPACK_IMPORTED_MODULE_5__config__[ 'a' /* config */ ] + .useDeprecatedSynchronousErrorHandling + ) { + parent.syncErrorValue = err; + parent.syncErrorThrown = true; + return true; + } else { + __webpack_require__.i( + __WEBPACK_IMPORTED_MODULE_6__util_hostReportError__[ 'a' /* hostReportError */ ] + )( err ); + return true; + } + } + return false; + }; + SafeSubscriber.prototype._unsubscribe = function() { + var _parentSubscriber = this._parentSubscriber; + this._context = null; + this._parentSubscriber = null; + _parentSubscriber.unsubscribe(); + }; + return SafeSubscriber; + } )( Subscriber ); + + //# sourceMappingURL=Subscriber.js.map + + /***/ + }, + /* 8 */ + /***/ function( module, exports, __webpack_require__ ) { + 'use strict'; + + Object.defineProperty( exports, '__esModule', { + value: true, + } ); + exports.getPathKey = getPathKey; + const os = __webpack_require__( 46 ); + const path = __webpack_require__( 0 ); + const userHome = __webpack_require__( 67 ).default; + + var _require = __webpack_require__( 225 ); + + const getCacheDir = _require.getCacheDir, + getConfigDir = _require.getConfigDir, + getDataDir = _require.getDataDir; + + const isWebpackBundle = __webpack_require__( 278 ); + + const DEPENDENCY_TYPES = ( exports.DEPENDENCY_TYPES = [ + 'devDependencies', + 'dependencies', + 'optionalDependencies', + 'peerDependencies', + ] ); + const OWNED_DEPENDENCY_TYPES = ( exports.OWNED_DEPENDENCY_TYPES = [ + 'devDependencies', + 'dependencies', + 'optionalDependencies', + ] ); + + const RESOLUTIONS = ( exports.RESOLUTIONS = 'resolutions' ); + const MANIFEST_FIELDS = ( exports.MANIFEST_FIELDS = [ RESOLUTIONS, ...DEPENDENCY_TYPES ] ); + + const SUPPORTED_NODE_VERSIONS = ( exports.SUPPORTED_NODE_VERSIONS = + '^4.8.0 || ^5.7.0 || ^6.2.2 || >=8.0.0' ); + + const YARN_REGISTRY = ( exports.YARN_REGISTRY = 'https://registry.yarnpkg.com' ); + const NPM_REGISTRY_RE = ( exports.NPM_REGISTRY_RE = /https?:\/\/registry\.npmjs\.org/g ); + + const YARN_DOCS = ( exports.YARN_DOCS = 'https://yarnpkg.com/en/docs/cli/' ); + const YARN_INSTALLER_SH = ( exports.YARN_INSTALLER_SH = 'https://yarnpkg.com/install.sh' ); + const YARN_INSTALLER_MSI = ( exports.YARN_INSTALLER_MSI = 'https://yarnpkg.com/latest.msi' ); + + const SELF_UPDATE_VERSION_URL = ( exports.SELF_UPDATE_VERSION_URL = + 'https://yarnpkg.com/latest-version' ); + + // cache version, bump whenever we make backwards incompatible changes + const CACHE_VERSION = ( exports.CACHE_VERSION = 6 ); + + // lockfile version, bump whenever we make backwards incompatible changes + const LOCKFILE_VERSION = ( exports.LOCKFILE_VERSION = 1 ); + + // max amount of network requests to perform concurrently + const NETWORK_CONCURRENCY = ( exports.NETWORK_CONCURRENCY = 8 ); + + // HTTP timeout used when downloading packages + const NETWORK_TIMEOUT = ( exports.NETWORK_TIMEOUT = 30 * 1000 ); // in milliseconds + + // max amount of child processes to execute concurrently + const CHILD_CONCURRENCY = ( exports.CHILD_CONCURRENCY = 5 ); + + const REQUIRED_PACKAGE_KEYS = ( exports.REQUIRED_PACKAGE_KEYS = [ + 'name', + 'version', + '_uid', + ] ); + + function getPreferredCacheDirectories() { + const preferredCacheDirectories = [ getCacheDir() ]; + + if ( process.getuid ) { + // $FlowFixMe: process.getuid exists, dammit + preferredCacheDirectories.push( + path.join( os.tmpdir(), `.yarn-cache-${ process.getuid() }` ) + ); + } + + preferredCacheDirectories.push( path.join( os.tmpdir(), `.yarn-cache` ) ); + + return preferredCacheDirectories; + } + + const PREFERRED_MODULE_CACHE_DIRECTORIES = ( exports.PREFERRED_MODULE_CACHE_DIRECTORIES = getPreferredCacheDirectories() ); + const CONFIG_DIRECTORY = ( exports.CONFIG_DIRECTORY = getConfigDir() ); + const DATA_DIRECTORY = ( exports.DATA_DIRECTORY = getDataDir() ); + const LINK_REGISTRY_DIRECTORY = ( exports.LINK_REGISTRY_DIRECTORY = path.join( + DATA_DIRECTORY, + 'link' + ) ); + const GLOBAL_MODULE_DIRECTORY = ( exports.GLOBAL_MODULE_DIRECTORY = path.join( + DATA_DIRECTORY, + 'global' + ) ); + + const NODE_BIN_PATH = ( exports.NODE_BIN_PATH = process.execPath ); + const YARN_BIN_PATH = ( exports.YARN_BIN_PATH = getYarnBinPath() ); + + // Webpack needs to be configured with node.__dirname/__filename = false + function getYarnBinPath() { + if ( isWebpackBundle ) { + return __filename; + } else { + return path.join( __dirname, '..', 'bin', 'yarn.js' ); + } + } + + const NODE_MODULES_FOLDER = ( exports.NODE_MODULES_FOLDER = 'node_modules' ); + const NODE_PACKAGE_JSON = ( exports.NODE_PACKAGE_JSON = 'package.json' ); + + const PNP_FILENAME = ( exports.PNP_FILENAME = '.pnp.js' ); + + const POSIX_GLOBAL_PREFIX = ( exports.POSIX_GLOBAL_PREFIX = `${ process.env.DESTDIR || + '' }/usr/local` ); + const FALLBACK_GLOBAL_PREFIX = ( exports.FALLBACK_GLOBAL_PREFIX = path.join( + userHome, + '.yarn' + ) ); + + const META_FOLDER = ( exports.META_FOLDER = '.yarn-meta' ); + const INTEGRITY_FILENAME = ( exports.INTEGRITY_FILENAME = '.yarn-integrity' ); + const LOCKFILE_FILENAME = ( exports.LOCKFILE_FILENAME = 'yarn.lock' ); + const METADATA_FILENAME = ( exports.METADATA_FILENAME = '.yarn-metadata.json' ); + const TARBALL_FILENAME = ( exports.TARBALL_FILENAME = '.yarn-tarball.tgz' ); + const CLEAN_FILENAME = ( exports.CLEAN_FILENAME = '.yarnclean' ); + + const NPM_LOCK_FILENAME = ( exports.NPM_LOCK_FILENAME = 'package-lock.json' ); + const NPM_SHRINKWRAP_FILENAME = ( exports.NPM_SHRINKWRAP_FILENAME = 'npm-shrinkwrap.json' ); + + const DEFAULT_INDENT = ( exports.DEFAULT_INDENT = ' ' ); + const SINGLE_INSTANCE_PORT = ( exports.SINGLE_INSTANCE_PORT = 31997 ); + const SINGLE_INSTANCE_FILENAME = ( exports.SINGLE_INSTANCE_FILENAME = + '.yarn-single-instance' ); + + const ENV_PATH_KEY = ( exports.ENV_PATH_KEY = getPathKey( process.platform, process.env ) ); + + function getPathKey( platform, env ) { + let pathKey = 'PATH'; + + // windows calls its path "Path" usually, but this is not guaranteed. + if ( platform === 'win32' ) { + pathKey = 'Path'; + + for ( const key in env ) { + if ( key.toLowerCase() === 'path' ) { + pathKey = key; + } + } + } + + return pathKey; + } + + const VERSION_COLOR_SCHEME = ( exports.VERSION_COLOR_SCHEME = { + major: 'red', + premajor: 'red', + minor: 'yellow', + preminor: 'yellow', + patch: 'green', + prepatch: 'green', + prerelease: 'red', + unchanged: 'white', + unknown: 'red', + } ); + + /***/ + }, + /* 9 */ + /***/ function( module, exports, __webpack_require__ ) { + 'use strict'; + /** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + + /** + * Use invariant() to assert state which your program assumes to be true. + * + * Provide sprintf-style format (only %s is supported) and arguments + * to provide information about what broke and what you were + * expecting. + * + * The invariant message will be stripped in production, but the invariant + * will remain to ensure logic does not differ in production. + */ + + var NODE_ENV = process.env.NODE_ENV; + + var invariant = function( condition, format, a, b, c, d, e, f ) { + if ( NODE_ENV !== 'production' ) { + if ( format === undefined ) { + throw new Error( 'invariant requires an error message argument' ); + } + } + + if ( ! condition ) { + var error; + if ( format === undefined ) { + error = new Error( + 'Minified exception occurred; use the non-minified dev environment ' + + 'for the full error message and additional helpful warnings.' + ); + } else { + var args = [ a, b, c, d, e, f ]; + var argIndex = 0; + error = new Error( + format.replace( /%s/g, function() { + return args[ argIndex++ ]; + } ) + ); + error.name = 'Invariant Violation'; + } + + error.framesToPop = 1; // we don't care about invariant's own frame + throw error; + } + }; + + module.exports = invariant; + + /***/ + }, + /* 10 */ + /***/ function( module, exports, __webpack_require__ ) { + 'use strict'; + + var YAMLException = __webpack_require__( 54 ); + + var TYPE_CONSTRUCTOR_OPTIONS = [ + 'kind', + 'resolve', + 'construct', + 'instanceOf', + 'predicate', + 'represent', + 'defaultStyle', + 'styleAliases', + ]; + + var YAML_NODE_KINDS = [ 'scalar', 'sequence', 'mapping' ]; + + function compileStyleAliases( map ) { + var result = {}; + + if ( map !== null ) { + Object.keys( map ).forEach( function( style ) { + map[ style ].forEach( function( alias ) { + result[ String( alias ) ] = style; + } ); + } ); + } + + return result; + } + + function Type( tag, options ) { + options = options || {}; + + Object.keys( options ).forEach( function( name ) { + if ( TYPE_CONSTRUCTOR_OPTIONS.indexOf( name ) === -1 ) { + throw new YAMLException( + 'Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.' + ); + } + } ); + + // TODO: Add tag format check. + this.tag = tag; + this.kind = options[ 'kind' ] || null; + this.resolve = + options[ 'resolve' ] || + function() { + return true; + }; + this.construct = + options[ 'construct' ] || + function( data ) { + return data; + }; + this.instanceOf = options[ 'instanceOf' ] || null; + this.predicate = options[ 'predicate' ] || null; + this.represent = options[ 'represent' ] || null; + this.defaultStyle = options[ 'defaultStyle' ] || null; + this.styleAliases = compileStyleAliases( options[ 'styleAliases' ] || null ); + + if ( YAML_NODE_KINDS.indexOf( this.kind ) === -1 ) { + throw new YAMLException( + 'Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.' + ); + } + } + + module.exports = Type; + + /***/ + }, + /* 11 */ + /***/ function( module, exports ) { + module.exports = require( 'crypto' ); + + /***/ + }, + /* 12 */ + /***/ function( module, __webpack_exports__, __webpack_require__ ) { + 'use strict'; + /* harmony export (binding) */ __webpack_require__.d( __webpack_exports__, 'a', function() { + return Observable; + } ); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__util_canReportError__ = __webpack_require__( + 322 + ); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__util_toSubscriber__ = __webpack_require__( + 932 + ); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__internal_symbol_observable__ = __webpack_require__( + 117 + ); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__util_pipe__ = __webpack_require__( + 324 + ); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__config__ = __webpack_require__( 185 ); + /** PURE_IMPORTS_START _util_canReportError,_util_toSubscriber,_internal_symbol_observable,_util_pipe,_config PURE_IMPORTS_END */ + + var Observable = /*@__PURE__*/ ( function() { + function Observable( subscribe ) { + this._isScalar = false; + if ( subscribe ) { + this._subscribe = subscribe; + } + } + Observable.prototype.lift = function( operator ) { + var observable = new Observable(); + observable.source = this; + observable.operator = operator; + return observable; + }; + Observable.prototype.subscribe = function( observerOrNext, error, complete ) { + var operator = this.operator; + var sink = __webpack_require__.i( + __WEBPACK_IMPORTED_MODULE_1__util_toSubscriber__[ 'a' /* toSubscriber */ ] + )( observerOrNext, error, complete ); + if ( operator ) { + operator.call( sink, this.source ); + } else { + sink.add( + this.source || + ( __WEBPACK_IMPORTED_MODULE_4__config__[ 'a' /* config */ ] + .useDeprecatedSynchronousErrorHandling && + ! sink.syncErrorThrowable ) + ? this._subscribe( sink ) + : this._trySubscribe( sink ) + ); + } + if ( + __WEBPACK_IMPORTED_MODULE_4__config__[ 'a' /* config */ ] + .useDeprecatedSynchronousErrorHandling + ) { + if ( sink.syncErrorThrowable ) { + sink.syncErrorThrowable = false; + if ( sink.syncErrorThrown ) { + throw sink.syncErrorValue; + } + } + } + return sink; + }; + Observable.prototype._trySubscribe = function( sink ) { + try { + return this._subscribe( sink ); + } catch ( err ) { + if ( + __WEBPACK_IMPORTED_MODULE_4__config__[ 'a' /* config */ ] + .useDeprecatedSynchronousErrorHandling + ) { + sink.syncErrorThrown = true; + sink.syncErrorValue = err; + } + if ( + __webpack_require__.i( + __WEBPACK_IMPORTED_MODULE_0__util_canReportError__[ 'a' /* canReportError */ ] + )( sink ) + ) { + sink.error( err ); + } else { + console.warn( err ); + } + } + }; + Observable.prototype.forEach = function( next, promiseCtor ) { + var _this = this; + promiseCtor = getPromiseCtor( promiseCtor ); + return new promiseCtor( function( resolve, reject ) { + var subscription; + subscription = _this.subscribe( + function( value ) { + try { + next( value ); + } catch ( err ) { + reject( err ); + if ( subscription ) { + subscription.unsubscribe(); + } + } + }, + reject, + resolve + ); + } ); + }; + Observable.prototype._subscribe = function( subscriber ) { + var source = this.source; + return source && source.subscribe( subscriber ); + }; + Observable.prototype[ + __WEBPACK_IMPORTED_MODULE_2__internal_symbol_observable__[ 'a' /* observable */ ] + ] = function() { + return this; + }; + Observable.prototype.pipe = function() { + var operations = []; + for ( var _i = 0; _i < arguments.length; _i++ ) { + operations[ _i ] = arguments[ _i ]; + } + if ( operations.length === 0 ) { + return this; + } + return __webpack_require__.i( + __WEBPACK_IMPORTED_MODULE_3__util_pipe__[ 'b' /* pipeFromArray */ ] + )( operations )( this ); + }; + Observable.prototype.toPromise = function( promiseCtor ) { + var _this = this; + promiseCtor = getPromiseCtor( promiseCtor ); + return new promiseCtor( function( resolve, reject ) { + var value; + _this.subscribe( + function( x ) { + return ( value = x ); + }, + function( err ) { + return reject( err ); + }, + function() { + return resolve( value ); + } + ); + } ); + }; + Observable.create = function( subscribe ) { + return new Observable( subscribe ); + }; + return Observable; + } )(); + + function getPromiseCtor( promiseCtor ) { + if ( ! promiseCtor ) { + promiseCtor = + __WEBPACK_IMPORTED_MODULE_4__config__[ 'a' /* config */ ].Promise || Promise; + } + if ( ! promiseCtor ) { + throw new Error( 'no Promise impl found' ); + } + return promiseCtor; + } + //# sourceMappingURL=Observable.js.map + + /***/ + }, + /* 13 */ + /***/ function( module, __webpack_exports__, __webpack_require__ ) { + 'use strict'; + /* harmony export (binding) */ __webpack_require__.d( __webpack_exports__, 'a', function() { + return OuterSubscriber; + } ); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__( 1 ); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__Subscriber__ = __webpack_require__( 7 ); + /** PURE_IMPORTS_START tslib,_Subscriber PURE_IMPORTS_END */ + + var OuterSubscriber = /*@__PURE__*/ ( function( _super ) { + __WEBPACK_IMPORTED_MODULE_0_tslib__[ 'a' /* __extends */ ]( OuterSubscriber, _super ); + function OuterSubscriber() { + return ( _super !== null && _super.apply( this, arguments ) ) || this; + } + OuterSubscriber.prototype.notifyNext = function( + outerValue, + innerValue, + outerIndex, + innerIndex, + innerSub + ) { + this.destination.next( innerValue ); + }; + OuterSubscriber.prototype.notifyError = function( error, innerSub ) { + this.destination.error( error ); + }; + OuterSubscriber.prototype.notifyComplete = function( innerSub ) { + this.destination.complete(); + }; + return OuterSubscriber; + } )( __WEBPACK_IMPORTED_MODULE_1__Subscriber__[ 'a' /* Subscriber */ ] ); + + //# sourceMappingURL=OuterSubscriber.js.map + + /***/ + }, + /* 14 */ + /***/ function( module, __webpack_exports__, __webpack_require__ ) { + 'use strict'; + /* harmony export (immutable) */ __webpack_exports__[ 'a' ] = subscribeToResult; + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__InnerSubscriber__ = __webpack_require__( + 84 + ); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__subscribeTo__ = __webpack_require__( + 446 + ); + /** PURE_IMPORTS_START _InnerSubscriber,_subscribeTo PURE_IMPORTS_END */ + + function subscribeToResult( outerSubscriber, result, outerValue, outerIndex, destination ) { + if ( destination === void 0 ) { + destination = new __WEBPACK_IMPORTED_MODULE_0__InnerSubscriber__[ + 'a' /* InnerSubscriber */ + ]( outerSubscriber, outerValue, outerIndex ); + } + if ( destination.closed ) { + return; + } + return __webpack_require__.i( + __WEBPACK_IMPORTED_MODULE_1__subscribeTo__[ 'a' /* subscribeTo */ ] + )( result )( destination ); + } + //# sourceMappingURL=subscribeToResult.js.map + + /***/ + }, + /* 15 */ + /***/ function( module, exports, __webpack_require__ ) { + 'use strict'; + /* eslint-disable node/no-deprecated-api */ + + var buffer = __webpack_require__( 64 ); + var Buffer = buffer.Buffer; + + var safer = {}; + + var key; + + for ( key in buffer ) { + if ( ! buffer.hasOwnProperty( key ) ) continue; + if ( key === 'SlowBuffer' || key === 'Buffer' ) continue; + safer[ key ] = buffer[ key ]; + } + + var Safer = ( safer.Buffer = {} ); + for ( key in Buffer ) { + if ( ! Buffer.hasOwnProperty( key ) ) continue; + if ( key === 'allocUnsafe' || key === 'allocUnsafeSlow' ) continue; + Safer[ key ] = Buffer[ key ]; + } + + safer.Buffer.prototype = Buffer.prototype; + + if ( ! Safer.from || Safer.from === Uint8Array.from ) { + Safer.from = function( value, encodingOrOffset, length ) { + if ( typeof value === 'number' ) { + throw new TypeError( + 'The "value" argument must not be of type number. Received type ' + typeof value + ); + } + if ( value && typeof value.length === 'undefined' ) { + throw new TypeError( + 'The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type ' + + typeof value + ); + } + return Buffer( value, encodingOrOffset, length ); + }; + } + + if ( ! Safer.alloc ) { + Safer.alloc = function( size, fill, encoding ) { + if ( typeof size !== 'number' ) { + throw new TypeError( + 'The "size" argument must be of type number. Received type ' + typeof size + ); + } + if ( size < 0 || size >= 2 * ( 1 << 30 ) ) { + throw new RangeError( 'The value "' + size + '" is invalid for option "size"' ); + } + var buf = Buffer( size ); + if ( ! fill || fill.length === 0 ) { + buf.fill( 0 ); + } else if ( typeof encoding === 'string' ) { + buf.fill( fill, encoding ); + } else { + buf.fill( fill ); + } + return buf; + }; + } + + if ( ! safer.kStringMaxLength ) { + try { + safer.kStringMaxLength = process.binding( 'buffer' ).kStringMaxLength; + } catch ( e ) { + // we can't determine kStringMaxLength in environments where process.binding + // is unsupported, so let's not set it + } + } + + if ( ! safer.constants ) { + safer.constants = { + MAX_LENGTH: safer.kMaxLength, + }; + if ( safer.kStringMaxLength ) { + safer.constants.MAX_STRING_LENGTH = safer.kStringMaxLength; + } + } + + module.exports = safer; + + /***/ + }, + /* 16 */ + /***/ function( module, exports, __webpack_require__ ) { + // Copyright (c) 2012, Mark Cavage. All rights reserved. + // Copyright 2015 Joyent, Inc. + + var assert = __webpack_require__( 28 ); + var Stream = __webpack_require__( 23 ).Stream; + var util = __webpack_require__( 3 ); + + ///--- Globals + + /* JSSTYLED */ + var UUID_REGEXP = /^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$/; + + ///--- Internal + + function _capitalize( str ) { + return str.charAt( 0 ).toUpperCase() + str.slice( 1 ); + } + + function _toss( name, expected, oper, arg, actual ) { + throw new assert.AssertionError( { + message: util.format( '%s (%s) is required', name, expected ), + actual: actual === undefined ? typeof arg : actual( arg ), + expected: expected, + operator: oper || '===', + stackStartFunction: _toss.caller, + } ); + } + + function _getClass( arg ) { + return Object.prototype.toString.call( arg ).slice( 8, -1 ); + } + + function noop() { + // Why even bother with asserts? + } + + ///--- Exports + + var types = { + bool: { + check: function( arg ) { + return typeof arg === 'boolean'; + }, + }, + func: { + check: function( arg ) { + return typeof arg === 'function'; + }, + }, + string: { + check: function( arg ) { + return typeof arg === 'string'; + }, + }, + object: { + check: function( arg ) { + return typeof arg === 'object' && arg !== null; + }, + }, + number: { + check: function( arg ) { + return typeof arg === 'number' && ! isNaN( arg ); + }, + }, + finite: { + check: function( arg ) { + return typeof arg === 'number' && ! isNaN( arg ) && isFinite( arg ); + }, + }, + buffer: { + check: function( arg ) { + return Buffer.isBuffer( arg ); + }, + operator: 'Buffer.isBuffer', + }, + array: { + check: function( arg ) { + return Array.isArray( arg ); + }, + operator: 'Array.isArray', + }, + stream: { + check: function( arg ) { + return arg instanceof Stream; + }, + operator: 'instanceof', + actual: _getClass, + }, + date: { + check: function( arg ) { + return arg instanceof Date; + }, + operator: 'instanceof', + actual: _getClass, + }, + regexp: { + check: function( arg ) { + return arg instanceof RegExp; + }, + operator: 'instanceof', + actual: _getClass, + }, + uuid: { + check: function( arg ) { + return typeof arg === 'string' && UUID_REGEXP.test( arg ); + }, + operator: 'isUUID', + }, + }; + + function _setExports( ndebug ) { + var keys = Object.keys( types ); + var out; + + /* re-export standard assert */ + if ( process.env.NODE_NDEBUG ) { + out = noop; + } else { + out = function( arg, msg ) { + if ( ! arg ) { + _toss( msg, 'true', arg ); + } + }; + } + + /* standard checks */ + keys.forEach( function( k ) { + if ( ndebug ) { + out[ k ] = noop; + return; + } + var type = types[ k ]; + out[ k ] = function( arg, msg ) { + if ( ! type.check( arg ) ) { + _toss( msg, k, type.operator, arg, type.actual ); + } + }; + } ); + + /* optional checks */ + keys.forEach( function( k ) { + var name = 'optional' + _capitalize( k ); + if ( ndebug ) { + out[ name ] = noop; + return; + } + var type = types[ k ]; + out[ name ] = function( arg, msg ) { + if ( arg === undefined || arg === null ) { + return; + } + if ( ! type.check( arg ) ) { + _toss( msg, k, type.operator, arg, type.actual ); + } + }; + } ); + + /* arrayOf checks */ + keys.forEach( function( k ) { + var name = 'arrayOf' + _capitalize( k ); + if ( ndebug ) { + out[ name ] = noop; + return; + } + var type = types[ k ]; + var expected = '[' + k + ']'; + out[ name ] = function( arg, msg ) { + if ( ! Array.isArray( arg ) ) { + _toss( msg, expected, type.operator, arg, type.actual ); + } + var i; + for ( i = 0; i < arg.length; i++ ) { + if ( ! type.check( arg[ i ] ) ) { + _toss( msg, expected, type.operator, arg, type.actual ); + } + } + }; + } ); + + /* optionalArrayOf checks */ + keys.forEach( function( k ) { + var name = 'optionalArrayOf' + _capitalize( k ); + if ( ndebug ) { + out[ name ] = noop; + return; + } + var type = types[ k ]; + var expected = '[' + k + ']'; + out[ name ] = function( arg, msg ) { + if ( arg === undefined || arg === null ) { + return; + } + if ( ! Array.isArray( arg ) ) { + _toss( msg, expected, type.operator, arg, type.actual ); + } + var i; + for ( i = 0; i < arg.length; i++ ) { + if ( ! type.check( arg[ i ] ) ) { + _toss( msg, expected, type.operator, arg, type.actual ); + } + } + }; + } ); + + /* re-export built-in assertions */ + Object.keys( assert ).forEach( function( k ) { + if ( k === 'AssertionError' ) { + out[ k ] = assert[ k ]; + return; + } + if ( ndebug ) { + out[ k ] = noop; + return; + } + out[ k ] = assert[ k ]; + } ); + + /* export ourselves (for unit tests _only_) */ + out._setExports = _setExports; + + return out; + } + + module.exports = _setExports( process.env.NODE_NDEBUG ); + + /***/ + }, + /* 17 */ + /***/ function( module, exports ) { + // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 + var global = ( module.exports = + typeof window != 'undefined' && window.Math == Math + ? window + : typeof self != 'undefined' && self.Math == Math + ? self + : // eslint-disable-next-line no-new-func + Function( 'return this' )() ); + if ( typeof __g == 'number' ) __g = global; // eslint-disable-line no-undef + + /***/ + }, + /* 18 */ + /***/ function( module, exports, __webpack_require__ ) { + 'use strict'; + + Object.defineProperty( exports, '__esModule', { + value: true, + } ); + exports.sortAlpha = sortAlpha; + exports.sortOptionsByFlags = sortOptionsByFlags; + exports.entries = entries; + exports.removePrefix = removePrefix; + exports.removeSuffix = removeSuffix; + exports.addSuffix = addSuffix; + exports.hyphenate = hyphenate; + exports.camelCase = camelCase; + exports.compareSortedArrays = compareSortedArrays; + exports.sleep = sleep; + const _camelCase = __webpack_require__( 230 ); + + function sortAlpha( a, b ) { + // sort alphabetically in a deterministic way + const shortLen = Math.min( a.length, b.length ); + for ( let i = 0; i < shortLen; i++ ) { + const aChar = a.charCodeAt( i ); + const bChar = b.charCodeAt( i ); + if ( aChar !== bChar ) { + return aChar - bChar; + } + } + return a.length - b.length; + } + + function sortOptionsByFlags( a, b ) { + const aOpt = a.flags.replace( /-/g, '' ); + const bOpt = b.flags.replace( /-/g, '' ); + return sortAlpha( aOpt, bOpt ); + } + + function entries( obj ) { + const entries = []; + if ( obj ) { + for ( const key in obj ) { + entries.push( [ key, obj[ key ] ] ); + } + } + return entries; + } + + function removePrefix( pattern, prefix ) { + if ( pattern.startsWith( prefix ) ) { + pattern = pattern.slice( prefix.length ); + } + + return pattern; + } + + function removeSuffix( pattern, suffix ) { + if ( pattern.endsWith( suffix ) ) { + return pattern.slice( 0, -suffix.length ); + } + + return pattern; + } + + function addSuffix( pattern, suffix ) { + if ( ! pattern.endsWith( suffix ) ) { + return pattern + suffix; + } + + return pattern; + } + + function hyphenate( str ) { + return str.replace( /[A-Z]/g, match => { + return '-' + match.charAt( 0 ).toLowerCase(); + } ); + } + + function camelCase( str ) { + if ( /[A-Z]/.test( str ) ) { + return null; + } else { + return _camelCase( str ); + } + } + + function compareSortedArrays( array1, array2 ) { + if ( array1.length !== array2.length ) { + return false; + } + for ( let i = 0, len = array1.length; i < len; i++ ) { + if ( array1[ i ] !== array2[ i ] ) { + return false; + } + } + return true; + } + + function sleep( ms ) { + return new Promise( resolve => { + setTimeout( resolve, ms ); + } ); + } + + /***/ + }, + /* 19 */ + /***/ function( module, exports, __webpack_require__ ) { + 'use strict'; + + Object.defineProperty( exports, '__esModule', { + value: true, + } ); + exports.stringify = exports.parse = undefined; + + var _asyncToGenerator2; + + function _load_asyncToGenerator() { + return ( _asyncToGenerator2 = _interopRequireDefault( __webpack_require__( 2 ) ) ); + } + + var _parse; + + function _load_parse() { + return ( _parse = __webpack_require__( 105 ) ); + } + + Object.defineProperty( exports, 'parse', { + enumerable: true, + get: function get() { + return _interopRequireDefault( _parse || _load_parse() ).default; + }, + } ); + + var _stringify; + + function _load_stringify() { + return ( _stringify = __webpack_require__( 199 ) ); + } + + Object.defineProperty( exports, 'stringify', { + enumerable: true, + get: function get() { + return _interopRequireDefault( _stringify || _load_stringify() ).default; + }, + } ); + exports.implodeEntry = implodeEntry; + exports.explodeEntry = explodeEntry; + + var _misc; + + function _load_misc() { + return ( _misc = __webpack_require__( 18 ) ); + } + + var _normalizePattern; + + function _load_normalizePattern() { + return ( _normalizePattern = __webpack_require__( 37 ) ); + } + + var _parse2; + + function _load_parse2() { + return ( _parse2 = _interopRequireDefault( __webpack_require__( 105 ) ) ); + } + + var _constants; + + function _load_constants() { + return ( _constants = __webpack_require__( 8 ) ); + } + + var _fs; + + function _load_fs() { + return ( _fs = _interopRequireWildcard( __webpack_require__( 4 ) ) ); + } + + function _interopRequireWildcard( obj ) { + if ( obj && obj.__esModule ) { + return obj; + } else { + var newObj = {}; + if ( obj != null ) { + for ( var key in obj ) { + if ( Object.prototype.hasOwnProperty.call( obj, key ) ) newObj[ key ] = obj[ key ]; + } + } + newObj.default = obj; + return newObj; + } + } + + function _interopRequireDefault( obj ) { + return obj && obj.__esModule ? obj : { default: obj }; + } + + const invariant = __webpack_require__( 9 ); + + const path = __webpack_require__( 0 ); + const ssri = __webpack_require__( 65 ); + + function getName( pattern ) { + return ( 0, ( _normalizePattern || _load_normalizePattern() ).normalizePattern )( pattern ) + .name; + } + + function blankObjectUndefined( obj ) { + return obj && Object.keys( obj ).length ? obj : undefined; + } + + function keyForRemote( remote ) { + return ( + remote.resolved || + ( remote.reference && remote.hash ? `${ remote.reference }#${ remote.hash }` : null ) + ); + } + + function serializeIntegrity( integrity ) { + // We need this because `Integrity.toString()` does not use sorting to ensure a stable string output + // See https://git.io/vx2Hy + return integrity + .toString() + .split( ' ' ) + .sort() + .join( ' ' ); + } + + function implodeEntry( pattern, obj ) { + const inferredName = getName( pattern ); + const integrity = obj.integrity ? serializeIntegrity( obj.integrity ) : ''; + const imploded = { + name: inferredName === obj.name ? undefined : obj.name, + version: obj.version, + uid: obj.uid === obj.version ? undefined : obj.uid, + resolved: obj.resolved, + registry: obj.registry === 'npm' ? undefined : obj.registry, + dependencies: blankObjectUndefined( obj.dependencies ), + optionalDependencies: blankObjectUndefined( obj.optionalDependencies ), + permissions: blankObjectUndefined( obj.permissions ), + prebuiltVariants: blankObjectUndefined( obj.prebuiltVariants ), + }; + if ( integrity ) { + imploded.integrity = integrity; + } + return imploded; + } + + function explodeEntry( pattern, obj ) { + obj.optionalDependencies = obj.optionalDependencies || {}; + obj.dependencies = obj.dependencies || {}; + obj.uid = obj.uid || obj.version; + obj.permissions = obj.permissions || {}; + obj.registry = obj.registry || 'npm'; + obj.name = obj.name || getName( pattern ); + const integrity = obj.integrity; + if ( integrity && integrity.isIntegrity ) { + obj.integrity = ssri.parse( integrity ); + } + return obj; + } + + class Lockfile { + constructor( { cache, source, parseResultType } = {} ) { + this.source = source || ''; + this.cache = cache; + this.parseResultType = parseResultType; + } + + // source string if the `cache` was parsed + + // if true, we're parsing an old yarn file and need to update integrity fields + hasEntriesExistWithoutIntegrity() { + if ( ! this.cache ) { + return false; + } + + for ( const key in this.cache ) { + // $FlowFixMe - `this.cache` is clearly defined at this point + if ( + ! /^.*@(file:|http)/.test( key ) && + this.cache[ key ] && + ! this.cache[ key ].integrity + ) { + return true; + } + } + + return false; + } + + static fromDirectory( dir, reporter ) { + return ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*() { + // read the manifest in this directory + const lockfileLoc = path.join( + dir, + ( _constants || _load_constants() ).LOCKFILE_FILENAME + ); + + let lockfile; + let rawLockfile = ''; + let parseResult; + + if ( yield ( _fs || _load_fs() ).exists( lockfileLoc ) ) { + rawLockfile = yield ( _fs || _load_fs() ).readFile( lockfileLoc ); + parseResult = ( 0, ( _parse2 || _load_parse2() ).default )( + rawLockfile, + lockfileLoc + ); + + if ( reporter ) { + if ( parseResult.type === 'merge' ) { + reporter.info( reporter.lang( 'lockfileMerged' ) ); + } else if ( parseResult.type === 'conflict' ) { + reporter.warn( reporter.lang( 'lockfileConflict' ) ); + } + } + + lockfile = parseResult.object; + } else if ( reporter ) { + reporter.info( reporter.lang( 'noLockfileFound' ) ); + } + + if ( lockfile && lockfile.__metadata ) { + const lockfilev2 = lockfile; + lockfile = {}; + } + + return new Lockfile( { + cache: lockfile, + source: rawLockfile, + parseResultType: parseResult && parseResult.type, + } ); + } )(); + } + + getLocked( pattern ) { + const cache = this.cache; + if ( ! cache ) { + return undefined; + } + + const shrunk = pattern in cache && cache[ pattern ]; + + if ( typeof shrunk === 'string' ) { + return this.getLocked( shrunk ); + } else if ( shrunk ) { + explodeEntry( pattern, shrunk ); + return shrunk; + } + + return undefined; + } + + removePattern( pattern ) { + const cache = this.cache; + if ( ! cache ) { + return; + } + delete cache[ pattern ]; + } + + getLockfile( patterns ) { + const lockfile = {}; + const seen = new Map(); + + // order by name so that lockfile manifest is assigned to the first dependency with this manifest + // the others that have the same remoteKey will just refer to the first + // ordering allows for consistency in lockfile when it is serialized + const sortedPatternsKeys = Object.keys( patterns ).sort( + ( _misc || _load_misc() ).sortAlpha + ); + + for ( + var _iterator = sortedPatternsKeys, + _isArray = Array.isArray( _iterator ), + _i = 0, + _iterator = _isArray ? _iterator : _iterator[ Symbol.iterator ](); + ; + + ) { + var _ref; + + if ( _isArray ) { + if ( _i >= _iterator.length ) break; + _ref = _iterator[ _i++ ]; + } else { + _i = _iterator.next(); + if ( _i.done ) break; + _ref = _i.value; + } + + const pattern = _ref; + + const pkg = patterns[ pattern ]; + const remote = pkg._remote, + ref = pkg._reference; + + invariant( ref, 'Package is missing a reference' ); + invariant( remote, 'Package is missing a remote' ); + + const remoteKey = keyForRemote( remote ); + const seenPattern = remoteKey && seen.get( remoteKey ); + if ( seenPattern ) { + // no point in duplicating it + lockfile[ pattern ] = seenPattern; + + // if we're relying on our name being inferred and two of the patterns have + // different inferred names then we need to set it + if ( ! seenPattern.name && getName( pattern ) !== pkg.name ) { + seenPattern.name = pkg.name; + } + continue; + } + const obj = implodeEntry( pattern, { + name: pkg.name, + version: pkg.version, + uid: pkg._uid, + resolved: remote.resolved, + integrity: remote.integrity, + registry: remote.registry, + dependencies: pkg.dependencies, + peerDependencies: pkg.peerDependencies, + optionalDependencies: pkg.optionalDependencies, + permissions: ref.permissions, + prebuiltVariants: pkg.prebuiltVariants, + } ); + + lockfile[ pattern ] = obj; + + if ( remoteKey ) { + seen.set( remoteKey, obj ); + } + } + + return lockfile; + } + } + exports.default = Lockfile; + + /***/ + }, + /* 20 */ + /***/ function( module, exports, __webpack_require__ ) { + var store = __webpack_require__( 133 )( 'wks' ); + var uid = __webpack_require__( 137 ); + var Symbol = __webpack_require__( 17 ).Symbol; + var USE_SYMBOL = typeof Symbol == 'function'; + + var $exports = ( module.exports = function( name ) { + return ( + store[ name ] || + ( store[ name ] = + ( USE_SYMBOL && Symbol[ name ] ) || ( USE_SYMBOL ? Symbol : uid )( 'Symbol.' + name ) ) + ); + } ); + + $exports.store = store; + + /***/ + }, + /* 21 */ + /***/ function( module, exports, __webpack_require__ ) { + 'use strict'; + + exports.__esModule = true; + + var _assign = __webpack_require__( 591 ); + + var _assign2 = _interopRequireDefault( _assign ); + + function _interopRequireDefault( obj ) { + return obj && obj.__esModule ? obj : { default: obj }; + } + + exports.default = + _assign2.default || + function( target ) { + for ( var i = 1; i < arguments.length; i++ ) { + var source = arguments[ i ]; + + for ( var key in source ) { + if ( Object.prototype.hasOwnProperty.call( source, key ) ) { + target[ key ] = source[ key ]; + } + } + } + + return target; + }; + + /***/ + }, + /* 22 */ + /***/ function( module, exports ) { + exports = module.exports = SemVer; + + // The debug function is excluded entirely from the minified version. + /* nomin */ var debug; + /* nomin */ if ( + typeof process === 'object' && + /* nomin */ process.env && + /* nomin */ process.env.NODE_DEBUG && + /* nomin */ /\bsemver\b/i.test( process.env.NODE_DEBUG ) + ) + /* nomin */ debug = function() { + /* nomin */ var args = Array.prototype.slice.call( arguments, 0 ); + /* nomin */ args.unshift( 'SEMVER' ); + /* nomin */ console.log.apply( console, args ); + /* nomin */ + }; + /* nomin */ + /* nomin */ else debug = function() {}; + + // Note: this is the semver.org version of the spec that it implements + // Not necessarily the package version of this code. + exports.SEMVER_SPEC_VERSION = '2.0.0'; + + var MAX_LENGTH = 256; + var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991; + + // Max safe segment length for coercion. + var MAX_SAFE_COMPONENT_LENGTH = 16; + + // The actual regexps go on exports.re + var re = ( exports.re = [] ); + var src = ( exports.src = [] ); + var R = 0; + + // The following Regular Expressions can be used for tokenizing, + // validating, and parsing SemVer version strings. + + // ## Numeric Identifier + // A single `0`, or a non-zero digit followed by zero or more digits. + + var NUMERICIDENTIFIER = R++; + src[ NUMERICIDENTIFIER ] = '0|[1-9]\\d*'; + var NUMERICIDENTIFIERLOOSE = R++; + src[ NUMERICIDENTIFIERLOOSE ] = '[0-9]+'; + + // ## Non-numeric Identifier + // Zero or more digits, followed by a letter or hyphen, and then zero or + // more letters, digits, or hyphens. + + var NONNUMERICIDENTIFIER = R++; + src[ NONNUMERICIDENTIFIER ] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*'; + + // ## Main Version + // Three dot-separated numeric identifiers. + + var MAINVERSION = R++; + src[ MAINVERSION ] = + '(' + + src[ NUMERICIDENTIFIER ] + + ')\\.' + + '(' + + src[ NUMERICIDENTIFIER ] + + ')\\.' + + '(' + + src[ NUMERICIDENTIFIER ] + + ')'; + + var MAINVERSIONLOOSE = R++; + src[ MAINVERSIONLOOSE ] = + '(' + + src[ NUMERICIDENTIFIERLOOSE ] + + ')\\.' + + '(' + + src[ NUMERICIDENTIFIERLOOSE ] + + ')\\.' + + '(' + + src[ NUMERICIDENTIFIERLOOSE ] + + ')'; + + // ## Pre-release Version Identifier + // A numeric identifier, or a non-numeric identifier. + + var PRERELEASEIDENTIFIER = R++; + src[ PRERELEASEIDENTIFIER ] = + '(?:' + src[ NUMERICIDENTIFIER ] + '|' + src[ NONNUMERICIDENTIFIER ] + ')'; + + var PRERELEASEIDENTIFIERLOOSE = R++; + src[ PRERELEASEIDENTIFIERLOOSE ] = + '(?:' + src[ NUMERICIDENTIFIERLOOSE ] + '|' + src[ NONNUMERICIDENTIFIER ] + ')'; + + // ## Pre-release Version + // Hyphen, followed by one or more dot-separated pre-release version + // identifiers. + + var PRERELEASE = R++; + src[ PRERELEASE ] = + '(?:-(' + src[ PRERELEASEIDENTIFIER ] + '(?:\\.' + src[ PRERELEASEIDENTIFIER ] + ')*))'; + + var PRERELEASELOOSE = R++; + src[ PRERELEASELOOSE ] = + '(?:-?(' + + src[ PRERELEASEIDENTIFIERLOOSE ] + + '(?:\\.' + + src[ PRERELEASEIDENTIFIERLOOSE ] + + ')*))'; + + // ## Build Metadata Identifier + // Any combination of digits, letters, or hyphens. + + var BUILDIDENTIFIER = R++; + src[ BUILDIDENTIFIER ] = '[0-9A-Za-z-]+'; + + // ## Build Metadata + // Plus sign, followed by one or more period-separated build metadata + // identifiers. + + var BUILD = R++; + src[ BUILD ] = + '(?:\\+(' + src[ BUILDIDENTIFIER ] + '(?:\\.' + src[ BUILDIDENTIFIER ] + ')*))'; + + // ## Full Version String + // A main version, followed optionally by a pre-release version and + // build metadata. + + // Note that the only major, minor, patch, and pre-release sections of + // the version string are capturing groups. The build metadata is not a + // capturing group, because it should not ever be used in version + // comparison. + + var FULL = R++; + var FULLPLAIN = 'v?' + src[ MAINVERSION ] + src[ PRERELEASE ] + '?' + src[ BUILD ] + '?'; + + src[ FULL ] = '^' + FULLPLAIN + '$'; + + // like full, but allows v1.2.3 and =1.2.3, which people do sometimes. + // also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty + // common in the npm registry. + var LOOSEPLAIN = + '[v=\\s]*' + src[ MAINVERSIONLOOSE ] + src[ PRERELEASELOOSE ] + '?' + src[ BUILD ] + '?'; + + var LOOSE = R++; + src[ LOOSE ] = '^' + LOOSEPLAIN + '$'; + + var GTLT = R++; + src[ GTLT ] = '((?:<|>)?=?)'; + + // Something like "2.*" or "1.2.x". + // Note that "x.x" is a valid xRange identifer, meaning "any version" + // Only the first item is strictly required. + var XRANGEIDENTIFIERLOOSE = R++; + src[ XRANGEIDENTIFIERLOOSE ] = src[ NUMERICIDENTIFIERLOOSE ] + '|x|X|\\*'; + var XRANGEIDENTIFIER = R++; + src[ XRANGEIDENTIFIER ] = src[ NUMERICIDENTIFIER ] + '|x|X|\\*'; + + var XRANGEPLAIN = R++; + src[ XRANGEPLAIN ] = + '[v=\\s]*(' + + src[ XRANGEIDENTIFIER ] + + ')' + + '(?:\\.(' + + src[ XRANGEIDENTIFIER ] + + ')' + + '(?:\\.(' + + src[ XRANGEIDENTIFIER ] + + ')' + + '(?:' + + src[ PRERELEASE ] + + ')?' + + src[ BUILD ] + + '?' + + ')?)?'; + + var XRANGEPLAINLOOSE = R++; + src[ XRANGEPLAINLOOSE ] = + '[v=\\s]*(' + + src[ XRANGEIDENTIFIERLOOSE ] + + ')' + + '(?:\\.(' + + src[ XRANGEIDENTIFIERLOOSE ] + + ')' + + '(?:\\.(' + + src[ XRANGEIDENTIFIERLOOSE ] + + ')' + + '(?:' + + src[ PRERELEASELOOSE ] + + ')?' + + src[ BUILD ] + + '?' + + ')?)?'; + + var XRANGE = R++; + src[ XRANGE ] = '^' + src[ GTLT ] + '\\s*' + src[ XRANGEPLAIN ] + '$'; + var XRANGELOOSE = R++; + src[ XRANGELOOSE ] = '^' + src[ GTLT ] + '\\s*' + src[ XRANGEPLAINLOOSE ] + '$'; + + // Coercion. + // Extract anything that could conceivably be a part of a valid semver + var COERCE = R++; + src[ COERCE ] = + '(?:^|[^\\d])' + + '(\\d{1,' + + MAX_SAFE_COMPONENT_LENGTH + + '})' + + '(?:\\.(\\d{1,' + + MAX_SAFE_COMPONENT_LENGTH + + '}))?' + + '(?:\\.(\\d{1,' + + MAX_SAFE_COMPONENT_LENGTH + + '}))?' + + '(?:$|[^\\d])'; + + // Tilde ranges. + // Meaning is "reasonably at or greater than" + var LONETILDE = R++; + src[ LONETILDE ] = '(?:~>?)'; + + var TILDETRIM = R++; + src[ TILDETRIM ] = '(\\s*)' + src[ LONETILDE ] + '\\s+'; + re[ TILDETRIM ] = new RegExp( src[ TILDETRIM ], 'g' ); + var tildeTrimReplace = '$1~'; + + var TILDE = R++; + src[ TILDE ] = '^' + src[ LONETILDE ] + src[ XRANGEPLAIN ] + '$'; + var TILDELOOSE = R++; + src[ TILDELOOSE ] = '^' + src[ LONETILDE ] + src[ XRANGEPLAINLOOSE ] + '$'; + + // Caret ranges. + // Meaning is "at least and backwards compatible with" + var LONECARET = R++; + src[ LONECARET ] = '(?:\\^)'; + + var CARETTRIM = R++; + src[ CARETTRIM ] = '(\\s*)' + src[ LONECARET ] + '\\s+'; + re[ CARETTRIM ] = new RegExp( src[ CARETTRIM ], 'g' ); + var caretTrimReplace = '$1^'; + + var CARET = R++; + src[ CARET ] = '^' + src[ LONECARET ] + src[ XRANGEPLAIN ] + '$'; + var CARETLOOSE = R++; + src[ CARETLOOSE ] = '^' + src[ LONECARET ] + src[ XRANGEPLAINLOOSE ] + '$'; + + // A simple gt/lt/eq thing, or just "" to indicate "any version" + var COMPARATORLOOSE = R++; + src[ COMPARATORLOOSE ] = '^' + src[ GTLT ] + '\\s*(' + LOOSEPLAIN + ')$|^$'; + var COMPARATOR = R++; + src[ COMPARATOR ] = '^' + src[ GTLT ] + '\\s*(' + FULLPLAIN + ')$|^$'; + + // An expression to strip any whitespace between the gtlt and the thing + // it modifies, so that `> 1.2.3` ==> `>1.2.3` + var COMPARATORTRIM = R++; + src[ COMPARATORTRIM ] = + '(\\s*)' + src[ GTLT ] + '\\s*(' + LOOSEPLAIN + '|' + src[ XRANGEPLAIN ] + ')'; + + // this one has to use the /g flag + re[ COMPARATORTRIM ] = new RegExp( src[ COMPARATORTRIM ], 'g' ); + var comparatorTrimReplace = '$1$2$3'; + + // Something like `1.2.3 - 1.2.4` + // Note that these all use the loose form, because they'll be + // checked against either the strict or loose comparator form + // later. + var HYPHENRANGE = R++; + src[ HYPHENRANGE ] = + '^\\s*(' + + src[ XRANGEPLAIN ] + + ')' + + '\\s+-\\s+' + + '(' + + src[ XRANGEPLAIN ] + + ')' + + '\\s*$'; + + var HYPHENRANGELOOSE = R++; + src[ HYPHENRANGELOOSE ] = + '^\\s*(' + + src[ XRANGEPLAINLOOSE ] + + ')' + + '\\s+-\\s+' + + '(' + + src[ XRANGEPLAINLOOSE ] + + ')' + + '\\s*$'; + + // Star ranges basically just allow anything at all. + var STAR = R++; + src[ STAR ] = '(<|>)?=?\\s*\\*'; + + // Compile to actual regexp objects. + // All are flag-free, unless they were created above with a flag. + for ( var i = 0; i < R; i++ ) { + debug( i, src[ i ] ); + if ( ! re[ i ] ) re[ i ] = new RegExp( src[ i ] ); + } + + exports.parse = parse; + function parse( version, loose ) { + if ( version instanceof SemVer ) return version; + + if ( typeof version !== 'string' ) return null; + + if ( version.length > MAX_LENGTH ) return null; + + var r = loose ? re[ LOOSE ] : re[ FULL ]; + if ( ! r.test( version ) ) return null; + + try { + return new SemVer( version, loose ); + } catch ( er ) { + return null; + } + } + + exports.valid = valid; + function valid( version, loose ) { + var v = parse( version, loose ); + return v ? v.version : null; + } + + exports.clean = clean; + function clean( version, loose ) { + var s = parse( version.trim().replace( /^[=v]+/, '' ), loose ); + return s ? s.version : null; + } + + exports.SemVer = SemVer; + + function SemVer( version, loose ) { + if ( version instanceof SemVer ) { + if ( version.loose === loose ) return version; + else version = version.version; + } else if ( typeof version !== 'string' ) { + throw new TypeError( 'Invalid Version: ' + version ); + } + + if ( version.length > MAX_LENGTH ) + throw new TypeError( 'version is longer than ' + MAX_LENGTH + ' characters' ); + + if ( ! ( this instanceof SemVer ) ) return new SemVer( version, loose ); + + debug( 'SemVer', version, loose ); + this.loose = loose; + var m = version.trim().match( loose ? re[ LOOSE ] : re[ FULL ] ); + + if ( ! m ) throw new TypeError( 'Invalid Version: ' + version ); + + this.raw = version; + + // these are actually numbers + this.major = +m[ 1 ]; + this.minor = +m[ 2 ]; + this.patch = +m[ 3 ]; + + if ( this.major > MAX_SAFE_INTEGER || this.major < 0 ) + throw new TypeError( 'Invalid major version' ); + + if ( this.minor > MAX_SAFE_INTEGER || this.minor < 0 ) + throw new TypeError( 'Invalid minor version' ); + + if ( this.patch > MAX_SAFE_INTEGER || this.patch < 0 ) + throw new TypeError( 'Invalid patch version' ); + + // numberify any prerelease numeric ids + if ( ! m[ 4 ] ) this.prerelease = []; + else + this.prerelease = m[ 4 ].split( '.' ).map( function( id ) { + if ( /^[0-9]+$/.test( id ) ) { + var num = +id; + if ( num >= 0 && num < MAX_SAFE_INTEGER ) return num; + } + return id; + } ); + + this.build = m[ 5 ] ? m[ 5 ].split( '.' ) : []; + this.format(); + } + + SemVer.prototype.format = function() { + this.version = this.major + '.' + this.minor + '.' + this.patch; + if ( this.prerelease.length ) this.version += '-' + this.prerelease.join( '.' ); + return this.version; + }; + + SemVer.prototype.toString = function() { + return this.version; + }; + + SemVer.prototype.compare = function( other ) { + debug( 'SemVer.compare', this.version, this.loose, other ); + if ( ! ( other instanceof SemVer ) ) other = new SemVer( other, this.loose ); + + return this.compareMain( other ) || this.comparePre( other ); + }; + + SemVer.prototype.compareMain = function( other ) { + if ( ! ( other instanceof SemVer ) ) other = new SemVer( other, this.loose ); + + return ( + compareIdentifiers( this.major, other.major ) || + compareIdentifiers( this.minor, other.minor ) || + compareIdentifiers( this.patch, other.patch ) + ); + }; + + SemVer.prototype.comparePre = function( other ) { + if ( ! ( other instanceof SemVer ) ) other = new SemVer( other, this.loose ); + + // NOT having a prerelease is > having one + if ( this.prerelease.length && ! other.prerelease.length ) return -1; + else if ( ! this.prerelease.length && other.prerelease.length ) return 1; + else if ( ! this.prerelease.length && ! other.prerelease.length ) return 0; + + var i = 0; + do { + var a = this.prerelease[ i ]; + var b = other.prerelease[ i ]; + debug( 'prerelease compare', i, a, b ); + if ( a === undefined && b === undefined ) return 0; + else if ( b === undefined ) return 1; + else if ( a === undefined ) return -1; + else if ( a === b ) continue; + else return compareIdentifiers( a, b ); + } while ( ++i ); + }; + + // preminor will bump the version up to the next minor release, and immediately + // down to pre-release. premajor and prepatch work the same way. + SemVer.prototype.inc = function( release, identifier ) { + switch ( release ) { + case 'premajor': + this.prerelease.length = 0; + this.patch = 0; + this.minor = 0; + this.major++; + this.inc( 'pre', identifier ); + break; + case 'preminor': + this.prerelease.length = 0; + this.patch = 0; + this.minor++; + this.inc( 'pre', identifier ); + break; + case 'prepatch': + // If this is already a prerelease, it will bump to the next version + // drop any prereleases that might already exist, since they are not + // relevant at this point. + this.prerelease.length = 0; + this.inc( 'patch', identifier ); + this.inc( 'pre', identifier ); + break; + // If the input is a non-prerelease version, this acts the same as + // prepatch. + case 'prerelease': + if ( this.prerelease.length === 0 ) this.inc( 'patch', identifier ); + this.inc( 'pre', identifier ); + break; + + case 'major': + // If this is a pre-major version, bump up to the same major version. + // Otherwise increment major. + // 1.0.0-5 bumps to 1.0.0 + // 1.1.0 bumps to 2.0.0 + if ( this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0 ) + this.major++; + this.minor = 0; + this.patch = 0; + this.prerelease = []; + break; + case 'minor': + // If this is a pre-minor version, bump up to the same minor version. + // Otherwise increment minor. + // 1.2.0-5 bumps to 1.2.0 + // 1.2.1 bumps to 1.3.0 + if ( this.patch !== 0 || this.prerelease.length === 0 ) this.minor++; + this.patch = 0; + this.prerelease = []; + break; + case 'patch': + // If this is not a pre-release version, it will increment the patch. + // If it is a pre-release it will bump up to the same patch version. + // 1.2.0-5 patches to 1.2.0 + // 1.2.0 patches to 1.2.1 + if ( this.prerelease.length === 0 ) this.patch++; + this.prerelease = []; + break; + // This probably shouldn't be used publicly. + // 1.0.0 "pre" would become 1.0.0-0 which is the wrong direction. + case 'pre': + if ( this.prerelease.length === 0 ) this.prerelease = [ 0 ]; + else { + var i = this.prerelease.length; + while ( --i >= 0 ) { + if ( typeof this.prerelease[ i ] === 'number' ) { + this.prerelease[ i ]++; + i = -2; + } + } + if ( i === -1 ) + // didn't increment anything + this.prerelease.push( 0 ); + } + if ( identifier ) { + // 1.2.0-beta.1 bumps to 1.2.0-beta.2, + // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0 + if ( this.prerelease[ 0 ] === identifier ) { + if ( isNaN( this.prerelease[ 1 ] ) ) this.prerelease = [ identifier, 0 ]; + } else this.prerelease = [ identifier, 0 ]; + } + break; + + default: + throw new Error( 'invalid increment argument: ' + release ); + } + this.format(); + this.raw = this.version; + return this; + }; + + exports.inc = inc; + function inc( version, release, loose, identifier ) { + if ( typeof loose === 'string' ) { + identifier = loose; + loose = undefined; + } + + try { + return new SemVer( version, loose ).inc( release, identifier ).version; + } catch ( er ) { + return null; + } + } + + exports.diff = diff; + function diff( version1, version2 ) { + if ( eq( version1, version2 ) ) { + return null; + } else { + var v1 = parse( version1 ); + var v2 = parse( version2 ); + if ( v1.prerelease.length || v2.prerelease.length ) { + for ( var key in v1 ) { + if ( key === 'major' || key === 'minor' || key === 'patch' ) { + if ( v1[ key ] !== v2[ key ] ) { + return 'pre' + key; + } + } + } + return 'prerelease'; + } + for ( var key in v1 ) { + if ( key === 'major' || key === 'minor' || key === 'patch' ) { + if ( v1[ key ] !== v2[ key ] ) { + return key; + } + } + } + } + } + + exports.compareIdentifiers = compareIdentifiers; + + var numeric = /^[0-9]+$/; + function compareIdentifiers( a, b ) { + var anum = numeric.test( a ); + var bnum = numeric.test( b ); + + if ( anum && bnum ) { + a = +a; + b = +b; + } + + return anum && ! bnum ? -1 : bnum && ! anum ? 1 : a < b ? -1 : a > b ? 1 : 0; + } + + exports.rcompareIdentifiers = rcompareIdentifiers; + function rcompareIdentifiers( a, b ) { + return compareIdentifiers( b, a ); + } + + exports.major = major; + function major( a, loose ) { + return new SemVer( a, loose ).major; + } + + exports.minor = minor; + function minor( a, loose ) { + return new SemVer( a, loose ).minor; + } + + exports.patch = patch; + function patch( a, loose ) { + return new SemVer( a, loose ).patch; + } + + exports.compare = compare; + function compare( a, b, loose ) { + return new SemVer( a, loose ).compare( new SemVer( b, loose ) ); + } + + exports.compareLoose = compareLoose; + function compareLoose( a, b ) { + return compare( a, b, true ); + } + + exports.rcompare = rcompare; + function rcompare( a, b, loose ) { + return compare( b, a, loose ); + } + + exports.sort = sort; + function sort( list, loose ) { + return list.sort( function( a, b ) { + return exports.compare( a, b, loose ); + } ); + } + + exports.rsort = rsort; + function rsort( list, loose ) { + return list.sort( function( a, b ) { + return exports.rcompare( a, b, loose ); + } ); + } + + exports.gt = gt; + function gt( a, b, loose ) { + return compare( a, b, loose ) > 0; + } + + exports.lt = lt; + function lt( a, b, loose ) { + return compare( a, b, loose ) < 0; + } + + exports.eq = eq; + function eq( a, b, loose ) { + return compare( a, b, loose ) === 0; + } + + exports.neq = neq; + function neq( a, b, loose ) { + return compare( a, b, loose ) !== 0; + } + + exports.gte = gte; + function gte( a, b, loose ) { + return compare( a, b, loose ) >= 0; + } + + exports.lte = lte; + function lte( a, b, loose ) { + return compare( a, b, loose ) <= 0; + } + + exports.cmp = cmp; + function cmp( a, op, b, loose ) { + var ret; + switch ( op ) { + case '===': + if ( typeof a === 'object' ) a = a.version; + if ( typeof b === 'object' ) b = b.version; + ret = a === b; + break; + case '!==': + if ( typeof a === 'object' ) a = a.version; + if ( typeof b === 'object' ) b = b.version; + ret = a !== b; + break; + case '': + case '=': + case '==': + ret = eq( a, b, loose ); + break; + case '!=': + ret = neq( a, b, loose ); + break; + case '>': + ret = gt( a, b, loose ); + break; + case '>=': + ret = gte( a, b, loose ); + break; + case '<': + ret = lt( a, b, loose ); + break; + case '<=': + ret = lte( a, b, loose ); + break; + default: + throw new TypeError( 'Invalid operator: ' + op ); + } + return ret; + } + + exports.Comparator = Comparator; + function Comparator( comp, loose ) { + if ( comp instanceof Comparator ) { + if ( comp.loose === loose ) return comp; + else comp = comp.value; + } + + if ( ! ( this instanceof Comparator ) ) return new Comparator( comp, loose ); + + debug( 'comparator', comp, loose ); + this.loose = loose; + this.parse( comp ); + + if ( this.semver === ANY ) this.value = ''; + else this.value = this.operator + this.semver.version; + + debug( 'comp', this ); + } + + var ANY = {}; + Comparator.prototype.parse = function( comp ) { + var r = this.loose ? re[ COMPARATORLOOSE ] : re[ COMPARATOR ]; + var m = comp.match( r ); + + if ( ! m ) throw new TypeError( 'Invalid comparator: ' + comp ); + + this.operator = m[ 1 ]; + if ( this.operator === '=' ) this.operator = ''; + + // if it literally is just '>' or '' then allow anything. + if ( ! m[ 2 ] ) this.semver = ANY; + else this.semver = new SemVer( m[ 2 ], this.loose ); + }; + + Comparator.prototype.toString = function() { + return this.value; + }; + + Comparator.prototype.test = function( version ) { + debug( 'Comparator.test', version, this.loose ); + + if ( this.semver === ANY ) return true; + + if ( typeof version === 'string' ) version = new SemVer( version, this.loose ); + + return cmp( version, this.operator, this.semver, this.loose ); + }; + + Comparator.prototype.intersects = function( comp, loose ) { + if ( ! ( comp instanceof Comparator ) ) { + throw new TypeError( 'a Comparator is required' ); + } + + var rangeTmp; + + if ( this.operator === '' ) { + rangeTmp = new Range( comp.value, loose ); + return satisfies( this.value, rangeTmp, loose ); + } else if ( comp.operator === '' ) { + rangeTmp = new Range( this.value, loose ); + return satisfies( comp.semver, rangeTmp, loose ); + } + + var sameDirectionIncreasing = + ( this.operator === '>=' || this.operator === '>' ) && + ( comp.operator === '>=' || comp.operator === '>' ); + var sameDirectionDecreasing = + ( this.operator === '<=' || this.operator === '<' ) && + ( comp.operator === '<=' || comp.operator === '<' ); + var sameSemVer = this.semver.version === comp.semver.version; + var differentDirectionsInclusive = + ( this.operator === '>=' || this.operator === '<=' ) && + ( comp.operator === '>=' || comp.operator === '<=' ); + var oppositeDirectionsLessThan = + cmp( this.semver, '<', comp.semver, loose ) && + ( this.operator === '>=' || this.operator === '>' ) && + ( comp.operator === '<=' || comp.operator === '<' ); + var oppositeDirectionsGreaterThan = + cmp( this.semver, '>', comp.semver, loose ) && + ( this.operator === '<=' || this.operator === '<' ) && + ( comp.operator === '>=' || comp.operator === '>' ); + + return ( + sameDirectionIncreasing || + sameDirectionDecreasing || + ( sameSemVer && differentDirectionsInclusive ) || + oppositeDirectionsLessThan || + oppositeDirectionsGreaterThan + ); + }; + + exports.Range = Range; + function Range( range, loose ) { + if ( range instanceof Range ) { + if ( range.loose === loose ) { + return range; + } else { + return new Range( range.raw, loose ); + } + } + + if ( range instanceof Comparator ) { + return new Range( range.value, loose ); + } + + if ( ! ( this instanceof Range ) ) return new Range( range, loose ); + + this.loose = loose; + + // First, split based on boolean or || + this.raw = range; + this.set = range + .split( /\s*\|\|\s*/ ) + .map( function( range ) { + return this.parseRange( range.trim() ); + }, this ) + .filter( function( c ) { + // throw out any that are not relevant for whatever reason + return c.length; + } ); + + if ( ! this.set.length ) { + throw new TypeError( 'Invalid SemVer Range: ' + range ); + } + + this.format(); + } + + Range.prototype.format = function() { + this.range = this.set + .map( function( comps ) { + return comps.join( ' ' ).trim(); + } ) + .join( '||' ) + .trim(); + return this.range; + }; + + Range.prototype.toString = function() { + return this.range; + }; + + Range.prototype.parseRange = function( range ) { + var loose = this.loose; + range = range.trim(); + debug( 'range', range, loose ); + // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4` + var hr = loose ? re[ HYPHENRANGELOOSE ] : re[ HYPHENRANGE ]; + range = range.replace( hr, hyphenReplace ); + debug( 'hyphen replace', range ); + // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5` + range = range.replace( re[ COMPARATORTRIM ], comparatorTrimReplace ); + debug( 'comparator trim', range, re[ COMPARATORTRIM ] ); + + // `~ 1.2.3` => `~1.2.3` + range = range.replace( re[ TILDETRIM ], tildeTrimReplace ); + + // `^ 1.2.3` => `^1.2.3` + range = range.replace( re[ CARETTRIM ], caretTrimReplace ); + + // normalize spaces + range = range.split( /\s+/ ).join( ' ' ); + + // At this point, the range is completely trimmed and + // ready to be split into comparators. + + var compRe = loose ? re[ COMPARATORLOOSE ] : re[ COMPARATOR ]; + var set = range + .split( ' ' ) + .map( function( comp ) { + return parseComparator( comp, loose ); + } ) + .join( ' ' ) + .split( /\s+/ ); + if ( this.loose ) { + // in loose mode, throw out any that are not valid comparators + set = set.filter( function( comp ) { + return !! comp.match( compRe ); + } ); + } + set = set.map( function( comp ) { + return new Comparator( comp, loose ); + } ); + + return set; + }; + + Range.prototype.intersects = function( range, loose ) { + if ( ! ( range instanceof Range ) ) { + throw new TypeError( 'a Range is required' ); + } + + return this.set.some( function( thisComparators ) { + return thisComparators.every( function( thisComparator ) { + return range.set.some( function( rangeComparators ) { + return rangeComparators.every( function( rangeComparator ) { + return thisComparator.intersects( rangeComparator, loose ); + } ); + } ); + } ); + } ); + }; + + // Mostly just for testing and legacy API reasons + exports.toComparators = toComparators; + function toComparators( range, loose ) { + return new Range( range, loose ).set.map( function( comp ) { + return comp + .map( function( c ) { + return c.value; + } ) + .join( ' ' ) + .trim() + .split( ' ' ); + } ); + } + + // comprised of xranges, tildes, stars, and gtlt's at this point. + // already replaced the hyphen ranges + // turn into a set of JUST comparators. + function parseComparator( comp, loose ) { + debug( 'comp', comp ); + comp = replaceCarets( comp, loose ); + debug( 'caret', comp ); + comp = replaceTildes( comp, loose ); + debug( 'tildes', comp ); + comp = replaceXRanges( comp, loose ); + debug( 'xrange', comp ); + comp = replaceStars( comp, loose ); + debug( 'stars', comp ); + return comp; + } + + function isX( id ) { + return ! id || id.toLowerCase() === 'x' || id === '*'; + } + + // ~, ~> --> * (any, kinda silly) + // ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0 + // ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0 + // ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0 + // ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0 + // ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0 + function replaceTildes( comp, loose ) { + return comp + .trim() + .split( /\s+/ ) + .map( function( comp ) { + return replaceTilde( comp, loose ); + } ) + .join( ' ' ); + } + + function replaceTilde( comp, loose ) { + var r = loose ? re[ TILDELOOSE ] : re[ TILDE ]; + return comp.replace( r, function( _, M, m, p, pr ) { + debug( 'tilde', comp, _, M, m, p, pr ); + var ret; + + if ( isX( M ) ) ret = ''; + else if ( isX( m ) ) ret = '>=' + M + '.0.0 <' + ( +M + 1 ) + '.0.0'; + else if ( isX( p ) ) + // ~1.2 == >=1.2.0 <1.3.0 + ret = '>=' + M + '.' + m + '.0 <' + M + '.' + ( +m + 1 ) + '.0'; + else if ( pr ) { + debug( 'replaceTilde pr', pr ); + if ( pr.charAt( 0 ) !== '-' ) pr = '-' + pr; + ret = '>=' + M + '.' + m + '.' + p + pr + ' <' + M + '.' + ( +m + 1 ) + '.0'; + } + // ~1.2.3 == >=1.2.3 <1.3.0 + else ret = '>=' + M + '.' + m + '.' + p + ' <' + M + '.' + ( +m + 1 ) + '.0'; + + debug( 'tilde return', ret ); + return ret; + } ); + } + + // ^ --> * (any, kinda silly) + // ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0 + // ^2.0, ^2.0.x --> >=2.0.0 <3.0.0 + // ^1.2, ^1.2.x --> >=1.2.0 <2.0.0 + // ^1.2.3 --> >=1.2.3 <2.0.0 + // ^1.2.0 --> >=1.2.0 <2.0.0 + function replaceCarets( comp, loose ) { + return comp + .trim() + .split( /\s+/ ) + .map( function( comp ) { + return replaceCaret( comp, loose ); + } ) + .join( ' ' ); + } + + function replaceCaret( comp, loose ) { + debug( 'caret', comp, loose ); + var r = loose ? re[ CARETLOOSE ] : re[ CARET ]; + return comp.replace( r, function( _, M, m, p, pr ) { + debug( 'caret', comp, _, M, m, p, pr ); + var ret; + + if ( isX( M ) ) ret = ''; + else if ( isX( m ) ) ret = '>=' + M + '.0.0 <' + ( +M + 1 ) + '.0.0'; + else if ( isX( p ) ) { + if ( M === '0' ) ret = '>=' + M + '.' + m + '.0 <' + M + '.' + ( +m + 1 ) + '.0'; + else ret = '>=' + M + '.' + m + '.0 <' + ( +M + 1 ) + '.0.0'; + } else if ( pr ) { + debug( 'replaceCaret pr', pr ); + if ( pr.charAt( 0 ) !== '-' ) pr = '-' + pr; + if ( M === '0' ) { + if ( m === '0' ) + ret = '>=' + M + '.' + m + '.' + p + pr + ' <' + M + '.' + m + '.' + ( +p + 1 ); + else ret = '>=' + M + '.' + m + '.' + p + pr + ' <' + M + '.' + ( +m + 1 ) + '.0'; + } else ret = '>=' + M + '.' + m + '.' + p + pr + ' <' + ( +M + 1 ) + '.0.0'; + } else { + debug( 'no pr' ); + if ( M === '0' ) { + if ( m === '0' ) + ret = '>=' + M + '.' + m + '.' + p + ' <' + M + '.' + m + '.' + ( +p + 1 ); + else ret = '>=' + M + '.' + m + '.' + p + ' <' + M + '.' + ( +m + 1 ) + '.0'; + } else ret = '>=' + M + '.' + m + '.' + p + ' <' + ( +M + 1 ) + '.0.0'; + } + + debug( 'caret return', ret ); + return ret; + } ); + } + + function replaceXRanges( comp, loose ) { + debug( 'replaceXRanges', comp, loose ); + return comp + .split( /\s+/ ) + .map( function( comp ) { + return replaceXRange( comp, loose ); + } ) + .join( ' ' ); + } + + function replaceXRange( comp, loose ) { + comp = comp.trim(); + var r = loose ? re[ XRANGELOOSE ] : re[ XRANGE ]; + return comp.replace( r, function( ret, gtlt, M, m, p, pr ) { + debug( 'xRange', comp, ret, gtlt, M, m, p, pr ); + var xM = isX( M ); + var xm = xM || isX( m ); + var xp = xm || isX( p ); + var anyX = xp; + + if ( gtlt === '=' && anyX ) gtlt = ''; + + if ( xM ) { + if ( gtlt === '>' || gtlt === '<' ) { + // nothing is allowed + ret = '<0.0.0'; + } else { + // nothing is forbidden + ret = '*'; + } + } else if ( gtlt && anyX ) { + // replace X with 0 + if ( xm ) m = 0; + if ( xp ) p = 0; + + if ( gtlt === '>' ) { + // >1 => >=2.0.0 + // >1.2 => >=1.3.0 + // >1.2.3 => >= 1.2.4 + gtlt = '>='; + if ( xm ) { + M = +M + 1; + m = 0; + p = 0; + } else if ( xp ) { + m = +m + 1; + p = 0; + } + } else if ( gtlt === '<=' ) { + // <=0.7.x is actually <0.8.0, since any 0.7.x should + // pass. Similarly, <=7.x is actually <8.0.0, etc. + gtlt = '<'; + if ( xm ) M = +M + 1; + else m = +m + 1; + } + + ret = gtlt + M + '.' + m + '.' + p; + } else if ( xm ) { + ret = '>=' + M + '.0.0 <' + ( +M + 1 ) + '.0.0'; + } else if ( xp ) { + ret = '>=' + M + '.' + m + '.0 <' + M + '.' + ( +m + 1 ) + '.0'; + } + + debug( 'xRange return', ret ); + + return ret; + } ); + } + + // Because * is AND-ed with everything else in the comparator, + // and '' means "any version", just remove the *s entirely. + function replaceStars( comp, loose ) { + debug( 'replaceStars', comp, loose ); + // Looseness is ignored here. star is always as loose as it gets! + return comp.trim().replace( re[ STAR ], '' ); + } + + // This function is passed to string.replace(re[HYPHENRANGE]) + // M, m, patch, prerelease, build + // 1.2 - 3.4.5 => >=1.2.0 <=3.4.5 + // 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do + // 1.2 - 3.4 => >=1.2.0 <3.5.0 + function hyphenReplace( $0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb ) { + if ( isX( fM ) ) from = ''; + else if ( isX( fm ) ) from = '>=' + fM + '.0.0'; + else if ( isX( fp ) ) from = '>=' + fM + '.' + fm + '.0'; + else from = '>=' + from; + + if ( isX( tM ) ) to = ''; + else if ( isX( tm ) ) to = '<' + ( +tM + 1 ) + '.0.0'; + else if ( isX( tp ) ) to = '<' + tM + '.' + ( +tm + 1 ) + '.0'; + else if ( tpr ) to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr; + else to = '<=' + to; + + return ( from + ' ' + to ).trim(); + } + + // if ANY of the sets match ALL of its comparators, then pass + Range.prototype.test = function( version ) { + if ( ! version ) return false; + + if ( typeof version === 'string' ) version = new SemVer( version, this.loose ); + + for ( var i = 0; i < this.set.length; i++ ) { + if ( testSet( this.set[ i ], version ) ) return true; + } + return false; + }; + + function testSet( set, version ) { + for ( var i = 0; i < set.length; i++ ) { + if ( ! set[ i ].test( version ) ) return false; + } + + if ( version.prerelease.length ) { + // Find the set of versions that are allowed to have prereleases + // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0 + // That should allow `1.2.3-pr.2` to pass. + // However, `1.2.4-alpha.notready` should NOT be allowed, + // even though it's within the range set by the comparators. + for ( var i = 0; i < set.length; i++ ) { + debug( set[ i ].semver ); + if ( set[ i ].semver === ANY ) continue; + + if ( set[ i ].semver.prerelease.length > 0 ) { + var allowed = set[ i ].semver; + if ( + allowed.major === version.major && + allowed.minor === version.minor && + allowed.patch === version.patch + ) + return true; + } + } + + // Version has a -pre, but it's not one of the ones we like. + return false; + } + + return true; + } + + exports.satisfies = satisfies; + function satisfies( version, range, loose ) { + try { + range = new Range( range, loose ); + } catch ( er ) { + return false; + } + return range.test( version ); + } + + exports.maxSatisfying = maxSatisfying; + function maxSatisfying( versions, range, loose ) { + var max = null; + var maxSV = null; + try { + var rangeObj = new Range( range, loose ); + } catch ( er ) { + return null; + } + versions.forEach( function( v ) { + if ( rangeObj.test( v ) ) { + // satisfies(v, range, loose) + if ( ! max || maxSV.compare( v ) === -1 ) { + // compare(max, v, true) + max = v; + maxSV = new SemVer( max, loose ); + } + } + } ); + return max; + } + + exports.minSatisfying = minSatisfying; + function minSatisfying( versions, range, loose ) { + var min = null; + var minSV = null; + try { + var rangeObj = new Range( range, loose ); + } catch ( er ) { + return null; + } + versions.forEach( function( v ) { + if ( rangeObj.test( v ) ) { + // satisfies(v, range, loose) + if ( ! min || minSV.compare( v ) === 1 ) { + // compare(min, v, true) + min = v; + minSV = new SemVer( min, loose ); + } + } + } ); + return min; + } + + exports.validRange = validRange; + function validRange( range, loose ) { + try { + // Return '*' instead of '' so that truthiness works. + // This will throw if it's invalid anyway + return new Range( range, loose ).range || '*'; + } catch ( er ) { + return null; + } + } + + // Determine if version is less than all the versions possible in the range + exports.ltr = ltr; + function ltr( version, range, loose ) { + return outside( version, range, '<', loose ); + } + + // Determine if version is greater than all the versions possible in the range. + exports.gtr = gtr; + function gtr( version, range, loose ) { + return outside( version, range, '>', loose ); + } + + exports.outside = outside; + function outside( version, range, hilo, loose ) { + version = new SemVer( version, loose ); + range = new Range( range, loose ); + + var gtfn, ltefn, ltfn, comp, ecomp; + switch ( hilo ) { + case '>': + gtfn = gt; + ltefn = lte; + ltfn = lt; + comp = '>'; + ecomp = '>='; + break; + case '<': + gtfn = lt; + ltefn = gte; + ltfn = gt; + comp = '<'; + ecomp = '<='; + break; + default: + throw new TypeError( 'Must provide a hilo val of "<" or ">"' ); + } + + // If it satisifes the range it is not outside + if ( satisfies( version, range, loose ) ) { + return false; + } + + // From now on, variable terms are as if we're in "gtr" mode. + // but note that everything is flipped for the "ltr" function. + + for ( var i = 0; i < range.set.length; ++i ) { + var comparators = range.set[ i ]; + + var high = null; + var low = null; + + comparators.forEach( function( comparator ) { + if ( comparator.semver === ANY ) { + comparator = new Comparator( '>=0.0.0' ); + } + high = high || comparator; + low = low || comparator; + if ( gtfn( comparator.semver, high.semver, loose ) ) { + high = comparator; + } else if ( ltfn( comparator.semver, low.semver, loose ) ) { + low = comparator; + } + } ); + + // If the edge version comparator has a operator then our version + // isn't outside it + if ( high.operator === comp || high.operator === ecomp ) { + return false; + } + + // If the lowest version comparator has an operator and our version + // is less than it then it isn't higher than the range + if ( ( ! low.operator || low.operator === comp ) && ltefn( version, low.semver ) ) { + return false; + } else if ( low.operator === ecomp && ltfn( version, low.semver ) ) { + return false; + } + } + return true; + } + + exports.prerelease = prerelease; + function prerelease( version, loose ) { + var parsed = parse( version, loose ); + return parsed && parsed.prerelease.length ? parsed.prerelease : null; + } + + exports.intersects = intersects; + function intersects( r1, r2, loose ) { + r1 = new Range( r1, loose ); + r2 = new Range( r2, loose ); + return r1.intersects( r2 ); + } + + exports.coerce = coerce; + function coerce( version ) { + if ( version instanceof SemVer ) return version; + + if ( typeof version !== 'string' ) return null; + + var match = version.match( re[ COERCE ] ); + + if ( match == null ) return null; + + return parse( + ( match[ 1 ] || '0' ) + '.' + ( match[ 2 ] || '0' ) + '.' + ( match[ 3 ] || '0' ) + ); + } + + /***/ + }, + /* 23 */ + /***/ function( module, exports ) { + module.exports = require( 'stream' ); + + /***/ + }, + /* 24 */ + /***/ function( module, exports ) { + module.exports = require( 'url' ); + + /***/ + }, + /* 25 */ + /***/ function( module, __webpack_exports__, __webpack_require__ ) { + 'use strict'; + /* harmony export (binding) */ __webpack_require__.d( __webpack_exports__, 'a', function() { + return Subscription; + } ); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__util_isArray__ = __webpack_require__( + 41 + ); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__util_isObject__ = __webpack_require__( + 444 + ); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__util_isFunction__ = __webpack_require__( + 154 + ); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__util_tryCatch__ = __webpack_require__( + 56 + ); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__util_errorObject__ = __webpack_require__( + 48 + ); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__util_UnsubscriptionError__ = __webpack_require__( + 441 + ); + /** PURE_IMPORTS_START _util_isArray,_util_isObject,_util_isFunction,_util_tryCatch,_util_errorObject,_util_UnsubscriptionError PURE_IMPORTS_END */ + + var Subscription = /*@__PURE__*/ ( function() { + function Subscription( unsubscribe ) { + this.closed = false; + this._parent = null; + this._parents = null; + this._subscriptions = null; + if ( unsubscribe ) { + this._unsubscribe = unsubscribe; + } + } + Subscription.prototype.unsubscribe = function() { + var hasErrors = false; + var errors; + if ( this.closed ) { + return; + } + var _a = this, + _parent = _a._parent, + _parents = _a._parents, + _unsubscribe = _a._unsubscribe, + _subscriptions = _a._subscriptions; + this.closed = true; + this._parent = null; + this._parents = null; + this._subscriptions = null; + var index = -1; + var len = _parents ? _parents.length : 0; + while ( _parent ) { + _parent.remove( this ); + _parent = ( ++index < len && _parents[ index ] ) || null; + } + if ( + __webpack_require__.i( + __WEBPACK_IMPORTED_MODULE_2__util_isFunction__[ 'a' /* isFunction */ ] + )( _unsubscribe ) + ) { + var trial = __webpack_require__ + .i( __WEBPACK_IMPORTED_MODULE_3__util_tryCatch__[ 'a' /* tryCatch */ ] )( + _unsubscribe + ) + .call( this ); + if ( + trial === __WEBPACK_IMPORTED_MODULE_4__util_errorObject__[ 'a' /* errorObject */ ] + ) { + hasErrors = true; + errors = + errors || + ( __WEBPACK_IMPORTED_MODULE_4__util_errorObject__[ 'a' /* errorObject */ ] + .e instanceof + __WEBPACK_IMPORTED_MODULE_5__util_UnsubscriptionError__[ + 'a' /* UnsubscriptionError */ + ] + ? flattenUnsubscriptionErrors( + __WEBPACK_IMPORTED_MODULE_4__util_errorObject__[ 'a' /* errorObject */ ].e + .errors + ) + : [ + __WEBPACK_IMPORTED_MODULE_4__util_errorObject__[ 'a' /* errorObject */ ].e, + ] ); + } + } + if ( + __webpack_require__.i( + __WEBPACK_IMPORTED_MODULE_0__util_isArray__[ 'a' /* isArray */ ] + )( _subscriptions ) + ) { + index = -1; + len = _subscriptions.length; + while ( ++index < len ) { + var sub = _subscriptions[ index ]; + if ( + __webpack_require__.i( + __WEBPACK_IMPORTED_MODULE_1__util_isObject__[ 'a' /* isObject */ ] + )( sub ) + ) { + var trial = __webpack_require__ + .i( __WEBPACK_IMPORTED_MODULE_3__util_tryCatch__[ 'a' /* tryCatch */ ] )( + sub.unsubscribe + ) + .call( sub ); + if ( + trial === __WEBPACK_IMPORTED_MODULE_4__util_errorObject__[ 'a' /* errorObject */ ] + ) { + hasErrors = true; + errors = errors || []; + var err = + __WEBPACK_IMPORTED_MODULE_4__util_errorObject__[ 'a' /* errorObject */ ].e; + if ( + err instanceof + __WEBPACK_IMPORTED_MODULE_5__util_UnsubscriptionError__[ + 'a' /* UnsubscriptionError */ + ] + ) { + errors = errors.concat( flattenUnsubscriptionErrors( err.errors ) ); + } else { + errors.push( err ); + } + } + } + } + } + if ( hasErrors ) { + throw new __WEBPACK_IMPORTED_MODULE_5__util_UnsubscriptionError__[ + 'a' /* UnsubscriptionError */ + ]( errors ); + } + }; + Subscription.prototype.add = function( teardown ) { + if ( ! teardown || teardown === Subscription.EMPTY ) { + return Subscription.EMPTY; + } + if ( teardown === this ) { + return this; + } + var subscription = teardown; + switch ( typeof teardown ) { + case 'function': + subscription = new Subscription( teardown ); + case 'object': + if ( subscription.closed || typeof subscription.unsubscribe !== 'function' ) { + return subscription; + } else if ( this.closed ) { + subscription.unsubscribe(); + return subscription; + } else if ( typeof subscription._addParent !== 'function' ) { + var tmp = subscription; + subscription = new Subscription(); + subscription._subscriptions = [ tmp ]; + } + break; + default: + throw new Error( 'unrecognized teardown ' + teardown + ' added to Subscription.' ); + } + var subscriptions = this._subscriptions || ( this._subscriptions = [] ); + subscriptions.push( subscription ); + subscription._addParent( this ); + return subscription; + }; + Subscription.prototype.remove = function( subscription ) { + var subscriptions = this._subscriptions; + if ( subscriptions ) { + var subscriptionIndex = subscriptions.indexOf( subscription ); + if ( subscriptionIndex !== -1 ) { + subscriptions.splice( subscriptionIndex, 1 ); + } + } + }; + Subscription.prototype._addParent = function( parent ) { + var _a = this, + _parent = _a._parent, + _parents = _a._parents; + if ( ! _parent || _parent === parent ) { + this._parent = parent; + } else if ( ! _parents ) { + this._parents = [ parent ]; + } else if ( _parents.indexOf( parent ) === -1 ) { + _parents.push( parent ); + } + }; + Subscription.EMPTY = ( function( empty ) { + empty.closed = true; + return empty; + } )( new Subscription() ); + return Subscription; + } )(); + + function flattenUnsubscriptionErrors( errors ) { + return errors.reduce( function( errs, err ) { + return errs.concat( + err instanceof + __WEBPACK_IMPORTED_MODULE_5__util_UnsubscriptionError__[ + 'a' /* UnsubscriptionError */ + ] + ? err.errors + : err + ); + }, [] ); + } + //# sourceMappingURL=Subscription.js.map + + /***/ + }, + /* 26 */ + /***/ function( module, exports, __webpack_require__ ) { + // Copyright 2015 Joyent, Inc. + + module.exports = { + bufferSplit: bufferSplit, + addRSAMissing: addRSAMissing, + calculateDSAPublic: calculateDSAPublic, + calculateED25519Public: calculateED25519Public, + calculateX25519Public: calculateX25519Public, + mpNormalize: mpNormalize, + mpDenormalize: mpDenormalize, + ecNormalize: ecNormalize, + countZeros: countZeros, + assertCompatible: assertCompatible, + isCompatible: isCompatible, + opensslKeyDeriv: opensslKeyDeriv, + opensshCipherInfo: opensshCipherInfo, + publicFromPrivateECDSA: publicFromPrivateECDSA, + zeroPadToLength: zeroPadToLength, + writeBitString: writeBitString, + readBitString: readBitString, + }; + + var assert = __webpack_require__( 16 ); + var Buffer = __webpack_require__( 15 ).Buffer; + var PrivateKey = __webpack_require__( 33 ); + var Key = __webpack_require__( 27 ); + var crypto = __webpack_require__( 11 ); + var algs = __webpack_require__( 32 ); + var asn1 = __webpack_require__( 66 ); + + var ec, jsbn; + var nacl; + + var MAX_CLASS_DEPTH = 3; + + function isCompatible( obj, klass, needVer ) { + if ( obj === null || typeof obj !== 'object' ) return false; + if ( needVer === undefined ) needVer = klass.prototype._sshpkApiVersion; + if ( obj instanceof klass && klass.prototype._sshpkApiVersion[ 0 ] == needVer[ 0 ] ) + return true; + var proto = Object.getPrototypeOf( obj ); + var depth = 0; + while ( proto.constructor.name !== klass.name ) { + proto = Object.getPrototypeOf( proto ); + if ( ! proto || ++depth > MAX_CLASS_DEPTH ) return false; + } + if ( proto.constructor.name !== klass.name ) return false; + var ver = proto._sshpkApiVersion; + if ( ver === undefined ) ver = klass._oldVersionDetect( obj ); + if ( ver[ 0 ] != needVer[ 0 ] || ver[ 1 ] < needVer[ 1 ] ) return false; + return true; + } + + function assertCompatible( obj, klass, needVer, name ) { + if ( name === undefined ) name = 'object'; + assert.ok( obj, name + ' must not be null' ); + assert.object( obj, name + ' must be an object' ); + if ( needVer === undefined ) needVer = klass.prototype._sshpkApiVersion; + if ( obj instanceof klass && klass.prototype._sshpkApiVersion[ 0 ] == needVer[ 0 ] ) return; + var proto = Object.getPrototypeOf( obj ); + var depth = 0; + while ( proto.constructor.name !== klass.name ) { + proto = Object.getPrototypeOf( proto ); + assert.ok( + proto && ++depth <= MAX_CLASS_DEPTH, + name + ' must be a ' + klass.name + ' instance' + ); + } + assert.strictEqual( + proto.constructor.name, + klass.name, + name + ' must be a ' + klass.name + ' instance' + ); + var ver = proto._sshpkApiVersion; + if ( ver === undefined ) ver = klass._oldVersionDetect( obj ); + assert.ok( + ver[ 0 ] == needVer[ 0 ] && ver[ 1 ] >= needVer[ 1 ], + name + + ' must be compatible with ' + + klass.name + + ' klass ' + + 'version ' + + needVer[ 0 ] + + '.' + + needVer[ 1 ] + ); + } + + var CIPHER_LEN = { + 'des-ede3-cbc': { key: 7, iv: 8 }, + 'aes-128-cbc': { key: 16, iv: 16 }, + }; + var PKCS5_SALT_LEN = 8; + + function opensslKeyDeriv( cipher, salt, passphrase, count ) { + assert.buffer( salt, 'salt' ); + assert.buffer( passphrase, 'passphrase' ); + assert.number( count, 'iteration count' ); + + var clen = CIPHER_LEN[ cipher ]; + assert.object( clen, 'supported cipher' ); + + salt = salt.slice( 0, PKCS5_SALT_LEN ); + + var D, D_prev, bufs; + var material = Buffer.alloc( 0 ); + while ( material.length < clen.key + clen.iv ) { + bufs = []; + if ( D_prev ) bufs.push( D_prev ); + bufs.push( passphrase ); + bufs.push( salt ); + D = Buffer.concat( bufs ); + for ( var j = 0; j < count; ++j ) + D = crypto + .createHash( 'md5' ) + .update( D ) + .digest(); + material = Buffer.concat( [ material, D ] ); + D_prev = D; + } + + return { + key: material.slice( 0, clen.key ), + iv: material.slice( clen.key, clen.key + clen.iv ), + }; + } + + /* Count leading zero bits on a buffer */ + function countZeros( buf ) { + var o = 0, + obit = 8; + while ( o < buf.length ) { + var mask = 1 << obit; + if ( ( buf[ o ] & mask ) === mask ) break; + obit--; + if ( obit < 0 ) { + o++; + obit = 8; + } + } + return o * 8 + ( 8 - obit ) - 1; + } + + function bufferSplit( buf, chr ) { + assert.buffer( buf ); + assert.string( chr ); + + var parts = []; + var lastPart = 0; + var matches = 0; + for ( var i = 0; i < buf.length; ++i ) { + if ( buf[ i ] === chr.charCodeAt( matches ) ) ++matches; + else if ( buf[ i ] === chr.charCodeAt( 0 ) ) matches = 1; + else matches = 0; + + if ( matches >= chr.length ) { + var newPart = i + 1; + parts.push( buf.slice( lastPart, newPart - matches ) ); + lastPart = newPart; + matches = 0; + } + } + if ( lastPart <= buf.length ) parts.push( buf.slice( lastPart, buf.length ) ); + + return parts; + } + + function ecNormalize( buf, addZero ) { + assert.buffer( buf ); + if ( buf[ 0 ] === 0x00 && buf[ 1 ] === 0x04 ) { + if ( addZero ) return buf; + return buf.slice( 1 ); + } else if ( buf[ 0 ] === 0x04 ) { + if ( ! addZero ) return buf; + } else { + while ( buf[ 0 ] === 0x00 ) buf = buf.slice( 1 ); + if ( buf[ 0 ] === 0x02 || buf[ 0 ] === 0x03 ) + throw new Error( 'Compressed elliptic curve points ' + 'are not supported' ); + if ( buf[ 0 ] !== 0x04 ) throw new Error( 'Not a valid elliptic curve point' ); + if ( ! addZero ) return buf; + } + var b = Buffer.alloc( buf.length + 1 ); + b[ 0 ] = 0x0; + buf.copy( b, 1 ); + return b; + } + + function readBitString( der, tag ) { + if ( tag === undefined ) tag = asn1.Ber.BitString; + var buf = der.readString( tag, true ); + assert.strictEqual( + buf[ 0 ], + 0x00, + 'bit strings with unused bits are ' + 'not supported (0x' + buf[ 0 ].toString( 16 ) + ')' + ); + return buf.slice( 1 ); + } + + function writeBitString( der, buf, tag ) { + if ( tag === undefined ) tag = asn1.Ber.BitString; + var b = Buffer.alloc( buf.length + 1 ); + b[ 0 ] = 0x00; + buf.copy( b, 1 ); + der.writeBuffer( b, tag ); + } + + function mpNormalize( buf ) { + assert.buffer( buf ); + while ( buf.length > 1 && buf[ 0 ] === 0x00 && ( buf[ 1 ] & 0x80 ) === 0x00 ) + buf = buf.slice( 1 ); + if ( ( buf[ 0 ] & 0x80 ) === 0x80 ) { + var b = Buffer.alloc( buf.length + 1 ); + b[ 0 ] = 0x00; + buf.copy( b, 1 ); + buf = b; + } + return buf; + } + + function mpDenormalize( buf ) { + assert.buffer( buf ); + while ( buf.length > 1 && buf[ 0 ] === 0x00 ) buf = buf.slice( 1 ); + return buf; + } + + function zeroPadToLength( buf, len ) { + assert.buffer( buf ); + assert.number( len ); + while ( buf.length > len ) { + assert.equal( buf[ 0 ], 0x00 ); + buf = buf.slice( 1 ); + } + while ( buf.length < len ) { + var b = Buffer.alloc( buf.length + 1 ); + b[ 0 ] = 0x00; + buf.copy( b, 1 ); + buf = b; + } + return buf; + } + + function bigintToMpBuf( bigint ) { + var buf = Buffer.from( bigint.toByteArray() ); + buf = mpNormalize( buf ); + return buf; + } + + function calculateDSAPublic( g, p, x ) { + assert.buffer( g ); + assert.buffer( p ); + assert.buffer( x ); + try { + var bigInt = __webpack_require__( 81 ).BigInteger; + } catch ( e ) { + throw new Error( + 'To load a PKCS#8 format DSA private key, ' + 'the node jsbn library is required.' + ); + } + g = new bigInt( g ); + p = new bigInt( p ); + x = new bigInt( x ); + var y = g.modPow( x, p ); + var ybuf = bigintToMpBuf( y ); + return ybuf; + } + + function calculateED25519Public( k ) { + assert.buffer( k ); + + if ( nacl === undefined ) nacl = __webpack_require__( 76 ); + + var kp = nacl.sign.keyPair.fromSeed( new Uint8Array( k ) ); + return Buffer.from( kp.publicKey ); + } + + function calculateX25519Public( k ) { + assert.buffer( k ); + + if ( nacl === undefined ) nacl = __webpack_require__( 76 ); + + var kp = nacl.box.keyPair.fromSeed( new Uint8Array( k ) ); + return Buffer.from( kp.publicKey ); + } + + function addRSAMissing( key ) { + assert.object( key ); + assertCompatible( key, PrivateKey, [ 1, 1 ] ); + try { + var bigInt = __webpack_require__( 81 ).BigInteger; + } catch ( e ) { + throw new Error( + 'To write a PEM private key from ' + 'this source, the node jsbn lib is required.' + ); + } + + var d = new bigInt( key.part.d.data ); + var buf; + + if ( ! key.part.dmodp ) { + var p = new bigInt( key.part.p.data ); + var dmodp = d.mod( p.subtract( 1 ) ); + + buf = bigintToMpBuf( dmodp ); + key.part.dmodp = { name: 'dmodp', data: buf }; + key.parts.push( key.part.dmodp ); + } + if ( ! key.part.dmodq ) { + var q = new bigInt( key.part.q.data ); + var dmodq = d.mod( q.subtract( 1 ) ); + + buf = bigintToMpBuf( dmodq ); + key.part.dmodq = { name: 'dmodq', data: buf }; + key.parts.push( key.part.dmodq ); + } + } + + function publicFromPrivateECDSA( curveName, priv ) { + assert.string( curveName, 'curveName' ); + assert.buffer( priv ); + if ( ec === undefined ) ec = __webpack_require__( 139 ); + if ( jsbn === undefined ) jsbn = __webpack_require__( 81 ).BigInteger; + var params = algs.curves[ curveName ]; + var p = new jsbn( params.p ); + var a = new jsbn( params.a ); + var b = new jsbn( params.b ); + var curve = new ec.ECCurveFp( p, a, b ); + var G = curve.decodePointHex( params.G.toString( 'hex' ) ); + + var d = new jsbn( mpNormalize( priv ) ); + var pub = G.multiply( d ); + pub = Buffer.from( curve.encodePointHex( pub ), 'hex' ); + + var parts = []; + parts.push( { name: 'curve', data: Buffer.from( curveName ) } ); + parts.push( { name: 'Q', data: pub } ); + + var key = new Key( { type: 'ecdsa', curve: curve, parts: parts } ); + return key; + } + + function opensshCipherInfo( cipher ) { + var inf = {}; + switch ( cipher ) { + case '3des-cbc': + inf.keySize = 24; + inf.blockSize = 8; + inf.opensslName = 'des-ede3-cbc'; + break; + case 'blowfish-cbc': + inf.keySize = 16; + inf.blockSize = 8; + inf.opensslName = 'bf-cbc'; + break; + case 'aes128-cbc': + case 'aes128-ctr': + case 'aes128-gcm@openssh.com': + inf.keySize = 16; + inf.blockSize = 16; + inf.opensslName = 'aes-128-' + cipher.slice( 7, 10 ); + break; + case 'aes192-cbc': + case 'aes192-ctr': + case 'aes192-gcm@openssh.com': + inf.keySize = 24; + inf.blockSize = 16; + inf.opensslName = 'aes-192-' + cipher.slice( 7, 10 ); + break; + case 'aes256-cbc': + case 'aes256-ctr': + case 'aes256-gcm@openssh.com': + inf.keySize = 32; + inf.blockSize = 16; + inf.opensslName = 'aes-256-' + cipher.slice( 7, 10 ); + break; + default: + throw new Error( 'Unsupported openssl cipher "' + cipher + '"' ); + } + return inf; + } + + /***/ + }, + /* 27 */ + /***/ function( module, exports, __webpack_require__ ) { + // Copyright 2017 Joyent, Inc. + + module.exports = Key; + + var assert = __webpack_require__( 16 ); + var algs = __webpack_require__( 32 ); + var crypto = __webpack_require__( 11 ); + var Fingerprint = __webpack_require__( 156 ); + var Signature = __webpack_require__( 75 ); + var DiffieHellman = __webpack_require__( 325 ).DiffieHellman; + var errs = __webpack_require__( 74 ); + var utils = __webpack_require__( 26 ); + var PrivateKey = __webpack_require__( 33 ); + var edCompat; + + try { + edCompat = __webpack_require__( 454 ); + } catch ( e ) { + /* Just continue through, and bail out if we try to use it. */ + } + + var InvalidAlgorithmError = errs.InvalidAlgorithmError; + var KeyParseError = errs.KeyParseError; + + var formats = {}; + formats[ 'auto' ] = __webpack_require__( 455 ); + formats[ 'pem' ] = __webpack_require__( 86 ); + formats[ 'pkcs1' ] = __webpack_require__( 327 ); + formats[ 'pkcs8' ] = __webpack_require__( 157 ); + formats[ 'rfc4253' ] = __webpack_require__( 103 ); + formats[ 'ssh' ] = __webpack_require__( 456 ); + formats[ 'ssh-private' ] = __webpack_require__( 192 ); + formats[ 'openssh' ] = formats[ 'ssh-private' ]; + formats[ 'dnssec' ] = __webpack_require__( 326 ); + + function Key( opts ) { + assert.object( opts, 'options' ); + assert.arrayOfObject( opts.parts, 'options.parts' ); + assert.string( opts.type, 'options.type' ); + assert.optionalString( opts.comment, 'options.comment' ); + + var algInfo = algs.info[ opts.type ]; + if ( typeof algInfo !== 'object' ) throw new InvalidAlgorithmError( opts.type ); + + var partLookup = {}; + for ( var i = 0; i < opts.parts.length; ++i ) { + var part = opts.parts[ i ]; + partLookup[ part.name ] = part; + } + + this.type = opts.type; + this.parts = opts.parts; + this.part = partLookup; + this.comment = undefined; + this.source = opts.source; + + /* for speeding up hashing/fingerprint operations */ + this._rfc4253Cache = opts._rfc4253Cache; + this._hashCache = {}; + + var sz; + this.curve = undefined; + if ( this.type === 'ecdsa' ) { + var curve = this.part.curve.data.toString(); + this.curve = curve; + sz = algs.curves[ curve ].size; + } else if ( this.type === 'ed25519' || this.type === 'curve25519' ) { + sz = 256; + this.curve = 'curve25519'; + } else { + var szPart = this.part[ algInfo.sizePart ]; + sz = szPart.data.length; + sz = sz * 8 - utils.countZeros( szPart.data ); + } + this.size = sz; + } + + Key.formats = formats; + + Key.prototype.toBuffer = function( format, options ) { + if ( format === undefined ) format = 'ssh'; + assert.string( format, 'format' ); + assert.object( formats[ format ], 'formats[format]' ); + assert.optionalObject( options, 'options' ); + + if ( format === 'rfc4253' ) { + if ( this._rfc4253Cache === undefined ) + this._rfc4253Cache = formats[ 'rfc4253' ].write( this ); + return this._rfc4253Cache; + } + + return formats[ format ].write( this, options ); + }; + + Key.prototype.toString = function( format, options ) { + return this.toBuffer( format, options ).toString(); + }; + + Key.prototype.hash = function( algo ) { + assert.string( algo, 'algorithm' ); + algo = algo.toLowerCase(); + if ( algs.hashAlgs[ algo ] === undefined ) throw new InvalidAlgorithmError( algo ); + + if ( this._hashCache[ algo ] ) return this._hashCache[ algo ]; + var hash = crypto + .createHash( algo ) + .update( this.toBuffer( 'rfc4253' ) ) + .digest(); + this._hashCache[ algo ] = hash; + return hash; + }; + + Key.prototype.fingerprint = function( algo ) { + if ( algo === undefined ) algo = 'sha256'; + assert.string( algo, 'algorithm' ); + var opts = { + type: 'key', + hash: this.hash( algo ), + algorithm: algo, + }; + return new Fingerprint( opts ); + }; + + Key.prototype.defaultHashAlgorithm = function() { + var hashAlgo = 'sha1'; + if ( this.type === 'rsa' ) hashAlgo = 'sha256'; + if ( this.type === 'dsa' && this.size > 1024 ) hashAlgo = 'sha256'; + if ( this.type === 'ed25519' ) hashAlgo = 'sha512'; + if ( this.type === 'ecdsa' ) { + if ( this.size <= 256 ) hashAlgo = 'sha256'; + else if ( this.size <= 384 ) hashAlgo = 'sha384'; + else hashAlgo = 'sha512'; + } + return hashAlgo; + }; + + Key.prototype.createVerify = function( hashAlgo ) { + if ( hashAlgo === undefined ) hashAlgo = this.defaultHashAlgorithm(); + assert.string( hashAlgo, 'hash algorithm' ); + + /* ED25519 is not supported by OpenSSL, use a javascript impl. */ + if ( this.type === 'ed25519' && edCompat !== undefined ) + return new edCompat.Verifier( this, hashAlgo ); + if ( this.type === 'curve25519' ) + throw new Error( 'Curve25519 keys are not suitable for ' + 'signing or verification' ); + + var v, nm, err; + try { + nm = hashAlgo.toUpperCase(); + v = crypto.createVerify( nm ); + } catch ( e ) { + err = e; + } + if ( + v === undefined || + ( err instanceof Error && err.message.match( /Unknown message digest/ ) ) + ) { + nm = 'RSA-'; + nm += hashAlgo.toUpperCase(); + v = crypto.createVerify( nm ); + } + assert.ok( v, 'failed to create verifier' ); + var oldVerify = v.verify.bind( v ); + var key = this.toBuffer( 'pkcs8' ); + var curve = this.curve; + var self = this; + v.verify = function( signature, fmt ) { + if ( Signature.isSignature( signature, [ 2, 0 ] ) ) { + if ( signature.type !== self.type ) return false; + if ( signature.hashAlgorithm && signature.hashAlgorithm !== hashAlgo ) return false; + if ( signature.curve && self.type === 'ecdsa' && signature.curve !== curve ) + return false; + return oldVerify( key, signature.toBuffer( 'asn1' ) ); + } else if ( typeof signature === 'string' || Buffer.isBuffer( signature ) ) { + return oldVerify( key, signature, fmt ); + + /* + * Avoid doing this on valid arguments, walking the prototype + * chain can be quite slow. + */ + } else if ( Signature.isSignature( signature, [ 1, 0 ] ) ) { + throw new Error( + 'signature was created by too old ' + 'a version of sshpk and cannot be verified' + ); + } else { + throw new TypeError( 'signature must be a string, ' + 'Buffer, or Signature object' ); + } + }; + return v; + }; + + Key.prototype.createDiffieHellman = function() { + if ( this.type === 'rsa' ) throw new Error( 'RSA keys do not support Diffie-Hellman' ); + + return new DiffieHellman( this ); + }; + Key.prototype.createDH = Key.prototype.createDiffieHellman; + + Key.parse = function( data, format, options ) { + if ( typeof data !== 'string' ) assert.buffer( data, 'data' ); + if ( format === undefined ) format = 'auto'; + assert.string( format, 'format' ); + if ( typeof options === 'string' ) options = { filename: options }; + assert.optionalObject( options, 'options' ); + if ( options === undefined ) options = {}; + assert.optionalString( options.filename, 'options.filename' ); + if ( options.filename === undefined ) options.filename = '(unnamed)'; + + assert.object( formats[ format ], 'formats[format]' ); + + try { + var k = formats[ format ].read( data, options ); + if ( k instanceof PrivateKey ) k = k.toPublic(); + if ( ! k.comment ) k.comment = options.filename; + return k; + } catch ( e ) { + if ( e.name === 'KeyEncryptedError' ) throw e; + throw new KeyParseError( options.filename, format, e ); + } + }; + + Key.isKey = function( obj, ver ) { + return utils.isCompatible( obj, Key, ver ); + }; + + /* + * API versions for Key: + * [1,0] -- initial ver, may take Signature for createVerify or may not + * [1,1] -- added pkcs1, pkcs8 formats + * [1,2] -- added auto, ssh-private, openssh formats + * [1,3] -- added defaultHashAlgorithm + * [1,4] -- added ed support, createDH + * [1,5] -- first explicitly tagged version + * [1,6] -- changed ed25519 part names + */ + Key.prototype._sshpkApiVersion = [ 1, 6 ]; + + Key._oldVersionDetect = function( obj ) { + assert.func( obj.toBuffer ); + assert.func( obj.fingerprint ); + if ( obj.createDH ) return [ 1, 4 ]; + if ( obj.defaultHashAlgorithm ) return [ 1, 3 ]; + if ( obj.formats[ 'auto' ] ) return [ 1, 2 ]; + if ( obj.formats[ 'pkcs1' ] ) return [ 1, 1 ]; + return [ 1, 0 ]; + }; + + /***/ + }, + /* 28 */ + /***/ function( module, exports ) { + module.exports = require( 'assert' ); + + /***/ + }, + /* 29 */ + /***/ function( module, exports, __webpack_require__ ) { + 'use strict'; + + Object.defineProperty( exports, '__esModule', { + value: true, + } ); + exports.default = nullify; + function nullify( obj = {} ) { + if ( Array.isArray( obj ) ) { + for ( + var _iterator = obj, + _isArray = Array.isArray( _iterator ), + _i = 0, + _iterator = _isArray ? _iterator : _iterator[ Symbol.iterator ](); + ; + + ) { + var _ref; + + if ( _isArray ) { + if ( _i >= _iterator.length ) break; + _ref = _iterator[ _i++ ]; + } else { + _i = _iterator.next(); + if ( _i.done ) break; + _ref = _i.value; + } + + const item = _ref; + + nullify( item ); + } + } else if ( ( obj !== null && typeof obj === 'object' ) || typeof obj === 'function' ) { + Object.setPrototypeOf( obj, null ); + + // for..in can only be applied to 'object', not 'function' + if ( typeof obj === 'object' ) { + for ( const key in obj ) { + nullify( obj[ key ] ); + } + } + } + + return obj; + } + + /***/ + }, + /* 30 */ + /***/ function( module, exports, __webpack_require__ ) { + 'use strict'; + + const escapeStringRegexp = __webpack_require__( 388 ); + const ansiStyles = __webpack_require__( 506 ); + const stdoutColor = __webpack_require__( 598 ).stdout; + + const template = __webpack_require__( 599 ); + + const isSimpleWindowsTerm = + process.platform === 'win32' && + ! ( process.env.TERM || '' ).toLowerCase().startsWith( 'xterm' ); + + // `supportsColor.level` → `ansiStyles.color[name]` mapping + const levelMapping = [ 'ansi', 'ansi', 'ansi256', 'ansi16m' ]; + + // `color-convert` models to exclude from the Chalk API due to conflicts and such + const skipModels = new Set( [ 'gray' ] ); + + const styles = Object.create( null ); + + function applyOptions( obj, options ) { + options = options || {}; + + // Detect level if not set manually + const scLevel = stdoutColor ? stdoutColor.level : 0; + obj.level = options.level === undefined ? scLevel : options.level; + obj.enabled = 'enabled' in options ? options.enabled : obj.level > 0; + } + + function Chalk( options ) { + // We check for this.template here since calling `chalk.constructor()` + // by itself will have a `this` of a previously constructed chalk object + if ( ! this || ! ( this instanceof Chalk ) || this.template ) { + const chalk = {}; + applyOptions( chalk, options ); + + chalk.template = function() { + const args = [].slice.call( arguments ); + return chalkTag.apply( null, [ chalk.template ].concat( args ) ); + }; + + Object.setPrototypeOf( chalk, Chalk.prototype ); + Object.setPrototypeOf( chalk.template, chalk ); + + chalk.template.constructor = Chalk; + + return chalk.template; + } + + applyOptions( this, options ); + } + + // Use bright blue on Windows as the normal blue color is illegible + if ( isSimpleWindowsTerm ) { + ansiStyles.blue.open = '\u001B[94m'; + } + + for ( const key of Object.keys( ansiStyles ) ) { + ansiStyles[ key ].closeRe = new RegExp( + escapeStringRegexp( ansiStyles[ key ].close ), + 'g' + ); + + styles[ key ] = { + get() { + const codes = ansiStyles[ key ]; + return build.call( + this, + this._styles ? this._styles.concat( codes ) : [ codes ], + this._empty, + key + ); + }, + }; + } + + styles.visible = { + get() { + return build.call( this, this._styles || [], true, 'visible' ); + }, + }; + + ansiStyles.color.closeRe = new RegExp( escapeStringRegexp( ansiStyles.color.close ), 'g' ); + for ( const model of Object.keys( ansiStyles.color.ansi ) ) { + if ( skipModels.has( model ) ) { + continue; + } + + styles[ model ] = { + get() { + const level = this.level; + return function() { + const open = ansiStyles.color[ levelMapping[ level ] ][ model ].apply( + null, + arguments + ); + const codes = { + open, + close: ansiStyles.color.close, + closeRe: ansiStyles.color.closeRe, + }; + return build.call( + this, + this._styles ? this._styles.concat( codes ) : [ codes ], + this._empty, + model + ); + }; + }, + }; + } + + ansiStyles.bgColor.closeRe = new RegExp( + escapeStringRegexp( ansiStyles.bgColor.close ), + 'g' + ); + for ( const model of Object.keys( ansiStyles.bgColor.ansi ) ) { + if ( skipModels.has( model ) ) { + continue; + } + + const bgModel = 'bg' + model[ 0 ].toUpperCase() + model.slice( 1 ); + styles[ bgModel ] = { + get() { + const level = this.level; + return function() { + const open = ansiStyles.bgColor[ levelMapping[ level ] ][ model ].apply( + null, + arguments + ); + const codes = { + open, + close: ansiStyles.bgColor.close, + closeRe: ansiStyles.bgColor.closeRe, + }; + return build.call( + this, + this._styles ? this._styles.concat( codes ) : [ codes ], + this._empty, + model + ); + }; + }, + }; + } + + const proto = Object.defineProperties( () => {}, styles ); + + function build( _styles, _empty, key ) { + const builder = function() { + return applyStyle.apply( builder, arguments ); + }; + + builder._styles = _styles; + builder._empty = _empty; + + const self = this; + + Object.defineProperty( builder, 'level', { + enumerable: true, + get() { + return self.level; + }, + set( level ) { + self.level = level; + }, + } ); + + Object.defineProperty( builder, 'enabled', { + enumerable: true, + get() { + return self.enabled; + }, + set( enabled ) { + self.enabled = enabled; + }, + } ); + + // See below for fix regarding invisible grey/dim combination on Windows + builder.hasGrey = this.hasGrey || key === 'gray' || key === 'grey'; + + // `__proto__` is used because we must return a function, but there is + // no way to create a function with a different prototype + builder.__proto__ = proto; // eslint-disable-line no-proto + + return builder; + } + + function applyStyle() { + // Support varags, but simply cast to string in case there's only one arg + const args = arguments; + const argsLen = args.length; + let str = String( arguments[ 0 ] ); + + if ( argsLen === 0 ) { + return ''; + } + + if ( argsLen > 1 ) { + // Don't slice `arguments`, it prevents V8 optimizations + for ( let a = 1; a < argsLen; a++ ) { + str += ' ' + args[ a ]; + } + } + + if ( ! this.enabled || this.level <= 0 || ! str ) { + return this._empty ? '' : str; + } + + // Turns out that on Windows dimmed gray text becomes invisible in cmd.exe, + // see https://github.com/chalk/chalk/issues/58 + // If we're on Windows and we're dealing with a gray color, temporarily make 'dim' a noop. + const originalDim = ansiStyles.dim.open; + if ( isSimpleWindowsTerm && this.hasGrey ) { + ansiStyles.dim.open = ''; + } + + for ( const code of this._styles.slice().reverse() ) { + // Replace any instances already present with a re-opening code + // otherwise only the part of the string until said closing code + // will be colored, and the rest will simply be 'plain'. + str = code.open + str.replace( code.closeRe, code.open ) + code.close; + + // Close the styling before a linebreak and reopen + // after next line to fix a bleed issue on macOS + // https://github.com/chalk/chalk/pull/92 + str = str.replace( /\r?\n/g, `${ code.close }$&${ code.open }` ); + } + + // Reset the original `dim` if we changed it to work around the Windows dimmed gray issue + ansiStyles.dim.open = originalDim; + + return str; + } + + function chalkTag( chalk, strings ) { + if ( ! Array.isArray( strings ) ) { + // If chalk() was called by itself or with a string, + // return the string itself as a string. + return [].slice.call( arguments, 1 ).join( ' ' ); + } + + const args = [].slice.call( arguments, 2 ); + const parts = [ strings.raw[ 0 ] ]; + + for ( let i = 1; i < strings.length; i++ ) { + parts.push( String( args[ i - 1 ] ).replace( /[{}\\]/g, '\\$&' ) ); + parts.push( String( strings.raw[ i ] ) ); + } + + return template( chalk, parts.join( '' ) ); + } + + Object.defineProperties( Chalk.prototype, styles ); + + module.exports = Chalk(); // eslint-disable-line new-cap + module.exports.supportsColor = stdoutColor; + module.exports.default = module.exports; // For TypeScript + + /***/ + }, + /* 31 */ + /***/ function( module, exports ) { + var core = ( module.exports = { version: '2.5.7' } ); + if ( typeof __e == 'number' ) __e = core; // eslint-disable-line no-undef + + /***/ + }, + /* 32 */ + /***/ function( module, exports, __webpack_require__ ) { + // Copyright 2015 Joyent, Inc. + + var Buffer = __webpack_require__( 15 ).Buffer; + + var algInfo = { + dsa: { + parts: [ 'p', 'q', 'g', 'y' ], + sizePart: 'p', + }, + rsa: { + parts: [ 'e', 'n' ], + sizePart: 'n', + }, + ecdsa: { + parts: [ 'curve', 'Q' ], + sizePart: 'Q', + }, + ed25519: { + parts: [ 'A' ], + sizePart: 'A', + }, + }; + algInfo[ 'curve25519' ] = algInfo[ 'ed25519' ]; + + var algPrivInfo = { + dsa: { + parts: [ 'p', 'q', 'g', 'y', 'x' ], + }, + rsa: { + parts: [ 'n', 'e', 'd', 'iqmp', 'p', 'q' ], + }, + ecdsa: { + parts: [ 'curve', 'Q', 'd' ], + }, + ed25519: { + parts: [ 'A', 'k' ], + }, + }; + algPrivInfo[ 'curve25519' ] = algPrivInfo[ 'ed25519' ]; + + var hashAlgs = { + md5: true, + sha1: true, + sha256: true, + sha384: true, + sha512: true, + }; + + /* + * Taken from + * http://csrc.nist.gov/groups/ST/toolkit/documents/dss/NISTReCur.pdf + */ + var curves = { + nistp256: { + size: 256, + pkcs8oid: '1.2.840.10045.3.1.7', + p: Buffer.from( + ( + '00' + + 'ffffffff 00000001 00000000 00000000' + + '00000000 ffffffff ffffffff ffffffff' + ).replace( / /g, '' ), + 'hex' + ), + a: Buffer.from( + ( + '00' + + 'FFFFFFFF 00000001 00000000 00000000' + + '00000000 FFFFFFFF FFFFFFFF FFFFFFFC' + ).replace( / /g, '' ), + 'hex' + ), + b: Buffer.from( + ( + '5ac635d8 aa3a93e7 b3ebbd55 769886bc' + '651d06b0 cc53b0f6 3bce3c3e 27d2604b' + ).replace( / /g, '' ), + 'hex' + ), + s: Buffer.from( + ( '00' + 'c49d3608 86e70493 6a6678e1 139d26b7' + '819f7e90' ).replace( / /g, '' ), + 'hex' + ), + n: Buffer.from( + ( + '00' + + 'ffffffff 00000000 ffffffff ffffffff' + + 'bce6faad a7179e84 f3b9cac2 fc632551' + ).replace( / /g, '' ), + 'hex' + ), + G: Buffer.from( + ( + '04' + + '6b17d1f2 e12c4247 f8bce6e5 63a440f2' + + '77037d81 2deb33a0 f4a13945 d898c296' + + '4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16' + + '2bce3357 6b315ece cbb64068 37bf51f5' + ).replace( / /g, '' ), + 'hex' + ), + }, + nistp384: { + size: 384, + pkcs8oid: '1.3.132.0.34', + p: Buffer.from( + ( + '00' + + 'ffffffff ffffffff ffffffff ffffffff' + + 'ffffffff ffffffff ffffffff fffffffe' + + 'ffffffff 00000000 00000000 ffffffff' + ).replace( / /g, '' ), + 'hex' + ), + a: Buffer.from( + ( + '00' + + 'FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF' + + 'FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE' + + 'FFFFFFFF 00000000 00000000 FFFFFFFC' + ).replace( / /g, '' ), + 'hex' + ), + b: Buffer.from( + ( + 'b3312fa7 e23ee7e4 988e056b e3f82d19' + + '181d9c6e fe814112 0314088f 5013875a' + + 'c656398d 8a2ed19d 2a85c8ed d3ec2aef' + ).replace( / /g, '' ), + 'hex' + ), + s: Buffer.from( + ( '00' + 'a335926a a319a27a 1d00896a 6773a482' + '7acdac73' ).replace( / /g, '' ), + 'hex' + ), + n: Buffer.from( + ( + '00' + + 'ffffffff ffffffff ffffffff ffffffff' + + 'ffffffff ffffffff c7634d81 f4372ddf' + + '581a0db2 48b0a77a ecec196a ccc52973' + ).replace( / /g, '' ), + 'hex' + ), + G: Buffer.from( + ( + '04' + + 'aa87ca22 be8b0537 8eb1c71e f320ad74' + + '6e1d3b62 8ba79b98 59f741e0 82542a38' + + '5502f25d bf55296c 3a545e38 72760ab7' + + '3617de4a 96262c6f 5d9e98bf 9292dc29' + + 'f8f41dbd 289a147c e9da3113 b5f0b8c0' + + '0a60b1ce 1d7e819d 7a431d7c 90ea0e5f' + ).replace( / /g, '' ), + 'hex' + ), + }, + nistp521: { + size: 521, + pkcs8oid: '1.3.132.0.35', + p: Buffer.from( + ( + '01ffffff ffffffff ffffffff ffffffff' + + 'ffffffff ffffffff ffffffff ffffffff' + + 'ffffffff ffffffff ffffffff ffffffff' + + 'ffffffff ffffffff ffffffff ffffffff' + + 'ffff' + ).replace( / /g, '' ), + 'hex' + ), + a: Buffer.from( + ( + '01FF' + + 'FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF' + + 'FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF' + + 'FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF' + + 'FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFC' + ).replace( / /g, '' ), + 'hex' + ), + b: Buffer.from( + ( + '51' + + '953eb961 8e1c9a1f 929a21a0 b68540ee' + + 'a2da725b 99b315f3 b8b48991 8ef109e1' + + '56193951 ec7e937b 1652c0bd 3bb1bf07' + + '3573df88 3d2c34f1 ef451fd4 6b503f00' + ).replace( / /g, '' ), + 'hex' + ), + s: Buffer.from( + ( '00' + 'd09e8800 291cb853 96cc6717 393284aa' + 'a0da64ba' ).replace( / /g, '' ), + 'hex' + ), + n: Buffer.from( + ( + '01ff' + + 'ffffffff ffffffff ffffffff ffffffff' + + 'ffffffff ffffffff ffffffff fffffffa' + + '51868783 bf2f966b 7fcc0148 f709a5d0' + + '3bb5c9b8 899c47ae bb6fb71e 91386409' + ).replace( / /g, '' ), + 'hex' + ), + G: Buffer.from( + ( + '04' + + '00c6 858e06b7 0404e9cd 9e3ecb66 2395b442' + + '9c648139 053fb521 f828af60 6b4d3dba' + + 'a14b5e77 efe75928 fe1dc127 a2ffa8de' + + '3348b3c1 856a429b f97e7e31 c2e5bd66' + + '0118 39296a78 9a3bc004 5c8a5fb4 2c7d1bd9' + + '98f54449 579b4468 17afbd17 273e662c' + + '97ee7299 5ef42640 c550b901 3fad0761' + + '353c7086 a272c240 88be9476 9fd16650' + ).replace( / /g, '' ), + 'hex' + ), + }, + }; + + module.exports = { + info: algInfo, + privInfo: algPrivInfo, + hashAlgs: hashAlgs, + curves: curves, + }; + + /***/ + }, + /* 33 */ + /***/ function( module, exports, __webpack_require__ ) { + // Copyright 2017 Joyent, Inc. + + module.exports = PrivateKey; + + var assert = __webpack_require__( 16 ); + var Buffer = __webpack_require__( 15 ).Buffer; + var algs = __webpack_require__( 32 ); + var crypto = __webpack_require__( 11 ); + var Fingerprint = __webpack_require__( 156 ); + var Signature = __webpack_require__( 75 ); + var errs = __webpack_require__( 74 ); + var util = __webpack_require__( 3 ); + var utils = __webpack_require__( 26 ); + var dhe = __webpack_require__( 325 ); + var generateECDSA = dhe.generateECDSA; + var generateED25519 = dhe.generateED25519; + var edCompat; + var nacl; + + try { + edCompat = __webpack_require__( 454 ); + } catch ( e ) { + /* Just continue through, and bail out if we try to use it. */ + } + + var Key = __webpack_require__( 27 ); + + var InvalidAlgorithmError = errs.InvalidAlgorithmError; + var KeyParseError = errs.KeyParseError; + var KeyEncryptedError = errs.KeyEncryptedError; + + var formats = {}; + formats[ 'auto' ] = __webpack_require__( 455 ); + formats[ 'pem' ] = __webpack_require__( 86 ); + formats[ 'pkcs1' ] = __webpack_require__( 327 ); + formats[ 'pkcs8' ] = __webpack_require__( 157 ); + formats[ 'rfc4253' ] = __webpack_require__( 103 ); + formats[ 'ssh-private' ] = __webpack_require__( 192 ); + formats[ 'openssh' ] = formats[ 'ssh-private' ]; + formats[ 'ssh' ] = formats[ 'ssh-private' ]; + formats[ 'dnssec' ] = __webpack_require__( 326 ); + + function PrivateKey( opts ) { + assert.object( opts, 'options' ); + Key.call( this, opts ); + + this._pubCache = undefined; + } + util.inherits( PrivateKey, Key ); + + PrivateKey.formats = formats; + + PrivateKey.prototype.toBuffer = function( format, options ) { + if ( format === undefined ) format = 'pkcs1'; + assert.string( format, 'format' ); + assert.object( formats[ format ], 'formats[format]' ); + assert.optionalObject( options, 'options' ); + + return formats[ format ].write( this, options ); + }; + + PrivateKey.prototype.hash = function( algo ) { + return this.toPublic().hash( algo ); + }; + + PrivateKey.prototype.toPublic = function() { + if ( this._pubCache ) return this._pubCache; + + var algInfo = algs.info[ this.type ]; + var pubParts = []; + for ( var i = 0; i < algInfo.parts.length; ++i ) { + var p = algInfo.parts[ i ]; + pubParts.push( this.part[ p ] ); + } + + this._pubCache = new Key( { + type: this.type, + source: this, + parts: pubParts, + } ); + if ( this.comment ) this._pubCache.comment = this.comment; + return this._pubCache; + }; + + PrivateKey.prototype.derive = function( newType ) { + assert.string( newType, 'type' ); + var priv, pub, pair; + + if ( this.type === 'ed25519' && newType === 'curve25519' ) { + if ( nacl === undefined ) nacl = __webpack_require__( 76 ); + + priv = this.part.k.data; + if ( priv[ 0 ] === 0x00 ) priv = priv.slice( 1 ); + + pair = nacl.box.keyPair.fromSecretKey( new Uint8Array( priv ) ); + pub = Buffer.from( pair.publicKey ); + + return new PrivateKey( { + type: 'curve25519', + parts: [ + { name: 'A', data: utils.mpNormalize( pub ) }, + { name: 'k', data: utils.mpNormalize( priv ) }, + ], + } ); + } else if ( this.type === 'curve25519' && newType === 'ed25519' ) { + if ( nacl === undefined ) nacl = __webpack_require__( 76 ); + + priv = this.part.k.data; + if ( priv[ 0 ] === 0x00 ) priv = priv.slice( 1 ); + + pair = nacl.sign.keyPair.fromSeed( new Uint8Array( priv ) ); + pub = Buffer.from( pair.publicKey ); + + return new PrivateKey( { + type: 'ed25519', + parts: [ + { name: 'A', data: utils.mpNormalize( pub ) }, + { name: 'k', data: utils.mpNormalize( priv ) }, + ], + } ); + } + throw new Error( 'Key derivation not supported from ' + this.type + ' to ' + newType ); + }; + + PrivateKey.prototype.createVerify = function( hashAlgo ) { + return this.toPublic().createVerify( hashAlgo ); + }; + + PrivateKey.prototype.createSign = function( hashAlgo ) { + if ( hashAlgo === undefined ) hashAlgo = this.defaultHashAlgorithm(); + assert.string( hashAlgo, 'hash algorithm' ); + + /* ED25519 is not supported by OpenSSL, use a javascript impl. */ + if ( this.type === 'ed25519' && edCompat !== undefined ) + return new edCompat.Signer( this, hashAlgo ); + if ( this.type === 'curve25519' ) + throw new Error( 'Curve25519 keys are not suitable for ' + 'signing or verification' ); + + var v, nm, err; + try { + nm = hashAlgo.toUpperCase(); + v = crypto.createSign( nm ); + } catch ( e ) { + err = e; + } + if ( + v === undefined || + ( err instanceof Error && err.message.match( /Unknown message digest/ ) ) + ) { + nm = 'RSA-'; + nm += hashAlgo.toUpperCase(); + v = crypto.createSign( nm ); + } + assert.ok( v, 'failed to create verifier' ); + var oldSign = v.sign.bind( v ); + var key = this.toBuffer( 'pkcs1' ); + var type = this.type; + var curve = this.curve; + v.sign = function() { + var sig = oldSign( key ); + if ( typeof sig === 'string' ) sig = Buffer.from( sig, 'binary' ); + sig = Signature.parse( sig, type, 'asn1' ); + sig.hashAlgorithm = hashAlgo; + sig.curve = curve; + return sig; + }; + return v; + }; + + PrivateKey.parse = function( data, format, options ) { + if ( typeof data !== 'string' ) assert.buffer( data, 'data' ); + if ( format === undefined ) format = 'auto'; + assert.string( format, 'format' ); + if ( typeof options === 'string' ) options = { filename: options }; + assert.optionalObject( options, 'options' ); + if ( options === undefined ) options = {}; + assert.optionalString( options.filename, 'options.filename' ); + if ( options.filename === undefined ) options.filename = '(unnamed)'; + + assert.object( formats[ format ], 'formats[format]' ); + + try { + var k = formats[ format ].read( data, options ); + assert.ok( k instanceof PrivateKey, 'key is not a private key' ); + if ( ! k.comment ) k.comment = options.filename; + return k; + } catch ( e ) { + if ( e.name === 'KeyEncryptedError' ) throw e; + throw new KeyParseError( options.filename, format, e ); + } + }; + + PrivateKey.isPrivateKey = function( obj, ver ) { + return utils.isCompatible( obj, PrivateKey, ver ); + }; + + PrivateKey.generate = function( type, options ) { + if ( options === undefined ) options = {}; + assert.object( options, 'options' ); + + switch ( type ) { + case 'ecdsa': + if ( options.curve === undefined ) options.curve = 'nistp256'; + assert.string( options.curve, 'options.curve' ); + return generateECDSA( options.curve ); + case 'ed25519': + return generateED25519(); + default: + throw new Error( 'Key generation not supported with key ' + 'type "' + type + '"' ); + } + }; + + /* + * API versions for PrivateKey: + * [1,0] -- initial ver + * [1,1] -- added auto, pkcs[18], openssh/ssh-private formats + * [1,2] -- added defaultHashAlgorithm + * [1,3] -- added derive, ed, createDH + * [1,4] -- first tagged version + * [1,5] -- changed ed25519 part names and format + */ + PrivateKey.prototype._sshpkApiVersion = [ 1, 5 ]; + + PrivateKey._oldVersionDetect = function( obj ) { + assert.func( obj.toPublic ); + assert.func( obj.createSign ); + if ( obj.derive ) return [ 1, 3 ]; + if ( obj.defaultHashAlgorithm ) return [ 1, 2 ]; + if ( obj.formats[ 'auto' ] ) return [ 1, 1 ]; + return [ 1, 0 ]; + }; + + /***/ + }, + /* 34 */ + /***/ function( module, exports, __webpack_require__ ) { + 'use strict'; + + Object.defineProperty( exports, '__esModule', { + value: true, + } ); + exports.wrapLifecycle = exports.run = exports.install = exports.Install = undefined; + + var _extends2; + + function _load_extends() { + return ( _extends2 = _interopRequireDefault( __webpack_require__( 21 ) ) ); + } + + var _asyncToGenerator2; + + function _load_asyncToGenerator() { + return ( _asyncToGenerator2 = _interopRequireDefault( __webpack_require__( 2 ) ) ); + } + + let install = ( exports.install = ( () => { + var _ref29 = ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*( + config, + reporter, + flags, + lockfile + ) { + yield wrapLifecycle( + config, + flags, + ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*() { + const install = new Install( flags, config, reporter, lockfile ); + yield install.init(); + } ) + ); + } ); + + return function install( _x7, _x8, _x9, _x10 ) { + return _ref29.apply( this, arguments ); + }; + } )() ); + + let run = ( exports.run = ( () => { + var _ref31 = ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*( + config, + reporter, + flags, + args + ) { + let lockfile; + let error = 'installCommandRenamed'; + if ( flags.lockfile === false ) { + lockfile = new ( _lockfile || _load_lockfile() ).default(); + } else { + lockfile = yield ( _lockfile || _load_lockfile() ).default.fromDirectory( + config.lockfileFolder, + reporter + ); + } + + if ( args.length ) { + const exampleArgs = args.slice(); + + if ( flags.saveDev ) { + exampleArgs.push( '--dev' ); + } + if ( flags.savePeer ) { + exampleArgs.push( '--peer' ); + } + if ( flags.saveOptional ) { + exampleArgs.push( '--optional' ); + } + if ( flags.saveExact ) { + exampleArgs.push( '--exact' ); + } + if ( flags.saveTilde ) { + exampleArgs.push( '--tilde' ); + } + let command = 'add'; + if ( flags.global ) { + error = 'globalFlagRemoved'; + command = 'global add'; + } + throw new ( _errors || _load_errors() ).MessageError( + reporter.lang( error, `yarn ${ command } ${ exampleArgs.join( ' ' ) }` ) + ); + } + + yield install( config, reporter, flags, lockfile ); + } ); + + return function run( _x11, _x12, _x13, _x14 ) { + return _ref31.apply( this, arguments ); + }; + } )() ); + + let wrapLifecycle = ( exports.wrapLifecycle = ( () => { + var _ref32 = ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*( + config, + flags, + factory + ) { + yield config.executeLifecycleScript( 'preinstall' ); + + yield factory(); + + // npm behaviour, seems kinda funky but yay compatibility + yield config.executeLifecycleScript( 'install' ); + yield config.executeLifecycleScript( 'postinstall' ); + + if ( ! config.production ) { + if ( ! config.disablePrepublish ) { + yield config.executeLifecycleScript( 'prepublish' ); + } + yield config.executeLifecycleScript( 'prepare' ); + } + } ); + + return function wrapLifecycle( _x15, _x16, _x17 ) { + return _ref32.apply( this, arguments ); + }; + } )() ); + + exports.hasWrapper = hasWrapper; + exports.setFlags = setFlags; + + var _objectPath; + + function _load_objectPath() { + return ( _objectPath = _interopRequireDefault( __webpack_require__( 304 ) ) ); + } + + var _hooks; + + function _load_hooks() { + return ( _hooks = __webpack_require__( 374 ) ); + } + + var _index; + + function _load_index() { + return ( _index = _interopRequireDefault( __webpack_require__( 220 ) ) ); + } + + var _errors; + + function _load_errors() { + return ( _errors = __webpack_require__( 6 ) ); + } + + var _integrityChecker; + + function _load_integrityChecker() { + return ( _integrityChecker = _interopRequireDefault( __webpack_require__( 208 ) ) ); + } + + var _lockfile; + + function _load_lockfile() { + return ( _lockfile = _interopRequireDefault( __webpack_require__( 19 ) ) ); + } + + var _lockfile2; + + function _load_lockfile2() { + return ( _lockfile2 = __webpack_require__( 19 ) ); + } + + var _packageFetcher; + + function _load_packageFetcher() { + return ( _packageFetcher = _interopRequireWildcard( __webpack_require__( 210 ) ) ); + } + + var _packageInstallScripts; + + function _load_packageInstallScripts() { + return ( _packageInstallScripts = _interopRequireDefault( __webpack_require__( 557 ) ) ); + } + + var _packageCompatibility; + + function _load_packageCompatibility() { + return ( _packageCompatibility = _interopRequireWildcard( __webpack_require__( 209 ) ) ); + } + + var _packageResolver; + + function _load_packageResolver() { + return ( _packageResolver = _interopRequireDefault( __webpack_require__( 366 ) ) ); + } + + var _packageLinker; + + function _load_packageLinker() { + return ( _packageLinker = _interopRequireDefault( __webpack_require__( 211 ) ) ); + } + + var _index2; + + function _load_index2() { + return ( _index2 = __webpack_require__( 57 ) ); + } + + var _index3; + + function _load_index3() { + return ( _index3 = __webpack_require__( 78 ) ); + } + + var _autoclean; + + function _load_autoclean() { + return ( _autoclean = __webpack_require__( 354 ) ); + } + + var _constants; + + function _load_constants() { + return ( _constants = _interopRequireWildcard( __webpack_require__( 8 ) ) ); + } + + var _normalizePattern; + + function _load_normalizePattern() { + return ( _normalizePattern = __webpack_require__( 37 ) ); + } + + var _fs; + + function _load_fs() { + return ( _fs = _interopRequireWildcard( __webpack_require__( 4 ) ) ); + } + + var _map; + + function _load_map() { + return ( _map = _interopRequireDefault( __webpack_require__( 29 ) ) ); + } + + var _yarnVersion; + + function _load_yarnVersion() { + return ( _yarnVersion = __webpack_require__( 120 ) ); + } + + var _generatePnpMap; + + function _load_generatePnpMap() { + return ( _generatePnpMap = __webpack_require__( 579 ) ); + } + + var _workspaceLayout; + + function _load_workspaceLayout() { + return ( _workspaceLayout = _interopRequireDefault( __webpack_require__( 90 ) ) ); + } + + var _resolutionMap; + + function _load_resolutionMap() { + return ( _resolutionMap = _interopRequireDefault( __webpack_require__( 214 ) ) ); + } + + var _guessName; + + function _load_guessName() { + return ( _guessName = _interopRequireDefault( __webpack_require__( 169 ) ) ); + } + + var _audit; + + function _load_audit() { + return ( _audit = _interopRequireDefault( __webpack_require__( 353 ) ) ); + } + + function _interopRequireWildcard( obj ) { + if ( obj && obj.__esModule ) { + return obj; + } else { + var newObj = {}; + if ( obj != null ) { + for ( var key in obj ) { + if ( Object.prototype.hasOwnProperty.call( obj, key ) ) newObj[ key ] = obj[ key ]; + } + } + newObj.default = obj; + return newObj; + } + } + + function _interopRequireDefault( obj ) { + return obj && obj.__esModule ? obj : { default: obj }; + } + + const deepEqual = __webpack_require__( 631 ); + + const emoji = __webpack_require__( 302 ); + const invariant = __webpack_require__( 9 ); + const path = __webpack_require__( 0 ); + const semver = __webpack_require__( 22 ); + const uuid = __webpack_require__( 119 ); + const ssri = __webpack_require__( 65 ); + + const ONE_DAY = 1000 * 60 * 60 * 24; + + /** + * Try and detect the installation method for Yarn and provide a command to update it with. + */ + + function getUpdateCommand( installationMethod ) { + if ( installationMethod === 'tar' ) { + return `curl --compressed -o- -L ${ + ( _constants || _load_constants() ).YARN_INSTALLER_SH + } | bash`; + } + + if ( installationMethod === 'homebrew' ) { + return 'brew upgrade yarn'; + } + + if ( installationMethod === 'deb' ) { + return 'sudo apt-get update && sudo apt-get install yarn'; + } + + if ( installationMethod === 'rpm' ) { + return 'sudo yum install yarn'; + } + + if ( installationMethod === 'npm' ) { + return 'npm install --global yarn'; + } + + if ( installationMethod === 'chocolatey' ) { + return 'choco upgrade yarn'; + } + + if ( installationMethod === 'apk' ) { + return 'apk update && apk add -u yarn'; + } + + if ( installationMethod === 'portage' ) { + return 'sudo emerge --sync && sudo emerge -au sys-apps/yarn'; + } + + return null; + } + + function getUpdateInstaller( installationMethod ) { + // Windows + if ( installationMethod === 'msi' ) { + return ( _constants || _load_constants() ).YARN_INSTALLER_MSI; + } + + return null; + } + + function normalizeFlags( config, rawFlags ) { + const flags = { + // install + har: !! rawFlags.har, + ignorePlatform: !! rawFlags.ignorePlatform, + ignoreEngines: !! rawFlags.ignoreEngines, + ignoreScripts: !! rawFlags.ignoreScripts, + ignoreOptional: !! rawFlags.ignoreOptional, + force: !! rawFlags.force, + flat: !! rawFlags.flat, + lockfile: rawFlags.lockfile !== false, + pureLockfile: !! rawFlags.pureLockfile, + updateChecksums: !! rawFlags.updateChecksums, + skipIntegrityCheck: !! rawFlags.skipIntegrityCheck, + frozenLockfile: !! rawFlags.frozenLockfile, + linkDuplicates: !! rawFlags.linkDuplicates, + checkFiles: !! rawFlags.checkFiles, + audit: !! rawFlags.audit, + + // add + peer: !! rawFlags.peer, + dev: !! rawFlags.dev, + optional: !! rawFlags.optional, + exact: !! rawFlags.exact, + tilde: !! rawFlags.tilde, + ignoreWorkspaceRootCheck: !! rawFlags.ignoreWorkspaceRootCheck, + + // outdated, update-interactive + includeWorkspaceDeps: !! rawFlags.includeWorkspaceDeps, + + // add, remove, update + workspaceRootIsCwd: rawFlags.workspaceRootIsCwd !== false, + }; + + if ( config.getOption( 'ignore-scripts' ) ) { + flags.ignoreScripts = true; + } + + if ( config.getOption( 'ignore-platform' ) ) { + flags.ignorePlatform = true; + } + + if ( config.getOption( 'ignore-engines' ) ) { + flags.ignoreEngines = true; + } + + if ( config.getOption( 'ignore-optional' ) ) { + flags.ignoreOptional = true; + } + + if ( config.getOption( 'force' ) ) { + flags.force = true; + } + + return flags; + } + + class Install { + constructor( flags, config, reporter, lockfile ) { + this.rootManifestRegistries = []; + this.rootPatternsToOrigin = ( 0, ( _map || _load_map() ).default )(); + this.lockfile = lockfile; + this.reporter = reporter; + this.config = config; + this.flags = normalizeFlags( config, flags ); + this.resolutions = ( 0, ( _map || _load_map() ).default )(); // Legacy resolutions field used for flat install mode + this.resolutionMap = new ( _resolutionMap || _load_resolutionMap() ).default( config ); // Selective resolutions for nested dependencies + this.resolver = new ( _packageResolver || _load_packageResolver() ).default( + config, + lockfile, + this.resolutionMap + ); + this.integrityChecker = new ( _integrityChecker || _load_integrityChecker() ).default( + config + ); + this.linker = new ( _packageLinker || _load_packageLinker() ).default( + config, + this.resolver + ); + this.scripts = new ( _packageInstallScripts || _load_packageInstallScripts() ).default( + config, + this.resolver, + this.flags.force + ); + } + + /** + * Create a list of dependency requests from the current directories manifests. + */ + + fetchRequestFromCwd( excludePatterns = [], ignoreUnusedPatterns = false ) { + var _this = this; + + return ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*() { + const patterns = []; + const deps = []; + let resolutionDeps = []; + const manifest = {}; + + const ignorePatterns = []; + const usedPatterns = []; + let workspaceLayout; + + // some commands should always run in the context of the entire workspace + const cwd = + _this.flags.includeWorkspaceDeps || _this.flags.workspaceRootIsCwd + ? _this.config.lockfileFolder + : _this.config.cwd; + + // non-workspaces are always root, otherwise check for workspace root + const cwdIsRoot = + ! _this.config.workspaceRootFolder || _this.config.lockfileFolder === cwd; + + // exclude package names that are in install args + const excludeNames = []; + for ( + var _iterator = excludePatterns, + _isArray = Array.isArray( _iterator ), + _i = 0, + _iterator = _isArray ? _iterator : _iterator[ Symbol.iterator ](); + ; + + ) { + var _ref; + + if ( _isArray ) { + if ( _i >= _iterator.length ) break; + _ref = _iterator[ _i++ ]; + } else { + _i = _iterator.next(); + if ( _i.done ) break; + _ref = _i.value; + } + + const pattern = _ref; + + if ( ( 0, ( _index3 || _load_index3() ).getExoticResolver )( pattern ) ) { + excludeNames.push( ( 0, ( _guessName || _load_guessName() ).default )( pattern ) ); + } else { + // extract the name + const parts = ( 0, + ( _normalizePattern || _load_normalizePattern() ).normalizePattern )( pattern ); + excludeNames.push( parts.name ); + } + } + + const stripExcluded = function stripExcluded( manifest ) { + for ( + var _iterator2 = excludeNames, + _isArray2 = Array.isArray( _iterator2 ), + _i2 = 0, + _iterator2 = _isArray2 ? _iterator2 : _iterator2[ Symbol.iterator ](); + ; + + ) { + var _ref2; + + if ( _isArray2 ) { + if ( _i2 >= _iterator2.length ) break; + _ref2 = _iterator2[ _i2++ ]; + } else { + _i2 = _iterator2.next(); + if ( _i2.done ) break; + _ref2 = _i2.value; + } + + const exclude = _ref2; + + if ( manifest.dependencies && manifest.dependencies[ exclude ] ) { + delete manifest.dependencies[ exclude ]; + } + if ( manifest.devDependencies && manifest.devDependencies[ exclude ] ) { + delete manifest.devDependencies[ exclude ]; + } + if ( manifest.optionalDependencies && manifest.optionalDependencies[ exclude ] ) { + delete manifest.optionalDependencies[ exclude ]; + } + } + }; + + for ( + var _iterator3 = Object.keys( ( _index2 || _load_index2() ).registries ), + _isArray3 = Array.isArray( _iterator3 ), + _i3 = 0, + _iterator3 = _isArray3 ? _iterator3 : _iterator3[ Symbol.iterator ](); + ; + + ) { + var _ref3; + + if ( _isArray3 ) { + if ( _i3 >= _iterator3.length ) break; + _ref3 = _iterator3[ _i3++ ]; + } else { + _i3 = _iterator3.next(); + if ( _i3.done ) break; + _ref3 = _i3.value; + } + + const registry = _ref3; + + const filename = ( _index2 || _load_index2() ).registries[ registry ].filename; + + const loc = path.join( cwd, filename ); + if ( ! ( yield ( _fs || _load_fs() ).exists( loc ) ) ) { + continue; + } + + _this.rootManifestRegistries.push( registry ); + + const projectManifestJson = yield _this.config.readJson( loc ); + yield ( 0, ( _index || _load_index() ).default )( + projectManifestJson, + cwd, + _this.config, + cwdIsRoot + ); + + Object.assign( _this.resolutions, projectManifestJson.resolutions ); + Object.assign( manifest, projectManifestJson ); + + _this.resolutionMap.init( _this.resolutions ); + for ( + var _iterator4 = Object.keys( _this.resolutionMap.resolutionsByPackage ), + _isArray4 = Array.isArray( _iterator4 ), + _i4 = 0, + _iterator4 = _isArray4 ? _iterator4 : _iterator4[ Symbol.iterator ](); + ; + + ) { + var _ref4; + + if ( _isArray4 ) { + if ( _i4 >= _iterator4.length ) break; + _ref4 = _iterator4[ _i4++ ]; + } else { + _i4 = _iterator4.next(); + if ( _i4.done ) break; + _ref4 = _i4.value; + } + + const packageName = _ref4; + + const optional = + ( _objectPath || _load_objectPath() ).default.has( + manifest.optionalDependencies, + packageName + ) && _this.flags.ignoreOptional; + for ( + var _iterator8 = _this.resolutionMap.resolutionsByPackage[ packageName ], + _isArray8 = Array.isArray( _iterator8 ), + _i8 = 0, + _iterator8 = _isArray8 ? _iterator8 : _iterator8[ Symbol.iterator ](); + ; + + ) { + var _ref9; + + if ( _isArray8 ) { + if ( _i8 >= _iterator8.length ) break; + _ref9 = _iterator8[ _i8++ ]; + } else { + _i8 = _iterator8.next(); + if ( _i8.done ) break; + _ref9 = _i8.value; + } + + const _ref8 = _ref9; + const pattern = _ref8.pattern; + + resolutionDeps = [ + ...resolutionDeps, + { registry, pattern, optional, hint: 'resolution' }, + ]; + } + } + + const pushDeps = function pushDeps( depType, manifest, { hint, optional }, isUsed ) { + if ( ignoreUnusedPatterns && ! isUsed ) { + return; + } + // We only take unused dependencies into consideration to get deterministic hoisting. + // Since flat mode doesn't care about hoisting and everything is top level and specified then we can safely + // leave these out. + if ( _this.flags.flat && ! isUsed ) { + return; + } + const depMap = manifest[ depType ]; + for ( const name in depMap ) { + if ( excludeNames.indexOf( name ) >= 0 ) { + continue; + } + + let pattern = name; + if ( ! _this.lockfile.getLocked( pattern ) ) { + // when we use --save we save the dependency to the lockfile with just the name rather than the + // version combo + pattern += '@' + depMap[ name ]; + } + + // normalization made sure packages are mentioned only once + if ( isUsed ) { + usedPatterns.push( pattern ); + } else { + ignorePatterns.push( pattern ); + } + + _this.rootPatternsToOrigin[ pattern ] = depType; + patterns.push( pattern ); + deps.push( { + pattern, + registry, + hint, + optional, + workspaceName: manifest.name, + workspaceLoc: manifest._loc, + } ); + } + }; + + if ( cwdIsRoot ) { + pushDeps( + 'dependencies', + projectManifestJson, + { hint: null, optional: false }, + true + ); + pushDeps( + 'devDependencies', + projectManifestJson, + { hint: 'dev', optional: false }, + ! _this.config.production + ); + pushDeps( + 'optionalDependencies', + projectManifestJson, + { hint: 'optional', optional: true }, + true + ); + } + + if ( _this.config.workspaceRootFolder ) { + const workspaceLoc = cwdIsRoot + ? loc + : path.join( _this.config.lockfileFolder, filename ); + const workspacesRoot = path.dirname( workspaceLoc ); + + let workspaceManifestJson = projectManifestJson; + if ( ! cwdIsRoot ) { + // the manifest we read before was a child workspace, so get the root + workspaceManifestJson = yield _this.config.readJson( workspaceLoc ); + yield ( 0, ( _index || _load_index() ).default )( + workspaceManifestJson, + workspacesRoot, + _this.config, + true + ); + } + + const workspaces = yield _this.config.resolveWorkspaces( + workspacesRoot, + workspaceManifestJson + ); + workspaceLayout = new ( _workspaceLayout || _load_workspaceLayout() ).default( + workspaces, + _this.config + ); + + // add virtual manifest that depends on all workspaces, this way package hoisters and resolvers will work fine + const workspaceDependencies = ( 0, ( _extends2 || _load_extends() ).default )( + {}, + workspaceManifestJson.dependencies + ); + for ( + var _iterator5 = Object.keys( workspaces ), + _isArray5 = Array.isArray( _iterator5 ), + _i5 = 0, + _iterator5 = _isArray5 ? _iterator5 : _iterator5[ Symbol.iterator ](); + ; + + ) { + var _ref5; + + if ( _isArray5 ) { + if ( _i5 >= _iterator5.length ) break; + _ref5 = _iterator5[ _i5++ ]; + } else { + _i5 = _iterator5.next(); + if ( _i5.done ) break; + _ref5 = _i5.value; + } + + const workspaceName = _ref5; + + const workspaceManifest = workspaces[ workspaceName ].manifest; + workspaceDependencies[ workspaceName ] = workspaceManifest.version; + + // include dependencies from all workspaces + if ( _this.flags.includeWorkspaceDeps ) { + pushDeps( + 'dependencies', + workspaceManifest, + { hint: null, optional: false }, + true + ); + pushDeps( + 'devDependencies', + workspaceManifest, + { hint: 'dev', optional: false }, + ! _this.config.production + ); + pushDeps( + 'optionalDependencies', + workspaceManifest, + { hint: 'optional', optional: true }, + true + ); + } + } + const virtualDependencyManifest = { + _uid: '', + name: `workspace-aggregator-${ uuid.v4() }`, + version: '1.0.0', + _registry: 'npm', + _loc: workspacesRoot, + dependencies: workspaceDependencies, + devDependencies: ( 0, ( _extends2 || _load_extends() ).default )( + {}, + workspaceManifestJson.devDependencies + ), + optionalDependencies: ( 0, ( _extends2 || _load_extends() ).default )( + {}, + workspaceManifestJson.optionalDependencies + ), + private: workspaceManifestJson.private, + workspaces: workspaceManifestJson.workspaces, + }; + workspaceLayout.virtualManifestName = virtualDependencyManifest.name; + const virtualDep = {}; + virtualDep[ virtualDependencyManifest.name ] = virtualDependencyManifest.version; + workspaces[ virtualDependencyManifest.name ] = { + loc: workspacesRoot, + manifest: virtualDependencyManifest, + }; + + // ensure dependencies that should be excluded are stripped from the correct manifest + stripExcluded( + cwdIsRoot + ? virtualDependencyManifest + : workspaces[ projectManifestJson.name ].manifest + ); + + pushDeps( + 'workspaces', + { workspaces: virtualDep }, + { hint: 'workspaces', optional: false }, + true + ); + + const implicitWorkspaceDependencies = ( 0, + ( _extends2 || _load_extends() ).default )( {}, workspaceDependencies ); + + for ( + var _iterator6 = ( _constants || _load_constants() ).OWNED_DEPENDENCY_TYPES, + _isArray6 = Array.isArray( _iterator6 ), + _i6 = 0, + _iterator6 = _isArray6 ? _iterator6 : _iterator6[ Symbol.iterator ](); + ; + + ) { + var _ref6; + + if ( _isArray6 ) { + if ( _i6 >= _iterator6.length ) break; + _ref6 = _iterator6[ _i6++ ]; + } else { + _i6 = _iterator6.next(); + if ( _i6.done ) break; + _ref6 = _i6.value; + } + + const type = _ref6; + + for ( + var _iterator7 = Object.keys( projectManifestJson[ type ] || {} ), + _isArray7 = Array.isArray( _iterator7 ), + _i7 = 0, + _iterator7 = _isArray7 ? _iterator7 : _iterator7[ Symbol.iterator ](); + ; + + ) { + var _ref7; + + if ( _isArray7 ) { + if ( _i7 >= _iterator7.length ) break; + _ref7 = _iterator7[ _i7++ ]; + } else { + _i7 = _iterator7.next(); + if ( _i7.done ) break; + _ref7 = _i7.value; + } + + const dependencyName = _ref7; + + delete implicitWorkspaceDependencies[ dependencyName ]; + } + } + + pushDeps( + 'dependencies', + { dependencies: implicitWorkspaceDependencies }, + { hint: 'workspaces', optional: false }, + true + ); + } + + break; + } + + // inherit root flat flag + if ( manifest.flat ) { + _this.flags.flat = true; + } + + return { + requests: [ ...resolutionDeps, ...deps ], + patterns, + manifest, + usedPatterns, + ignorePatterns, + workspaceLayout, + }; + } )(); + } + + /** + * TODO description + */ + + prepareRequests( requests ) { + return requests; + } + + preparePatterns( patterns ) { + return patterns; + } + preparePatternsForLinking( patterns, cwdManifest, cwdIsRoot ) { + return patterns; + } + + prepareManifests() { + var _this2 = this; + + return ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*() { + const manifests = yield _this2.config.getRootManifests(); + return manifests; + } )(); + } + + bailout( patterns, workspaceLayout ) { + var _this3 = this; + + return ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*() { + // We don't want to skip the audit - it could yield important errors + if ( _this3.flags.audit ) { + return false; + } + // PNP is so fast that the integrity check isn't pertinent + if ( _this3.config.plugnplayEnabled ) { + return false; + } + if ( _this3.flags.skipIntegrityCheck || _this3.flags.force ) { + return false; + } + const lockfileCache = _this3.lockfile.cache; + if ( ! lockfileCache ) { + return false; + } + const lockfileClean = _this3.lockfile.parseResultType === 'success'; + const match = yield _this3.integrityChecker.check( + patterns, + lockfileCache, + _this3.flags, + workspaceLayout + ); + if ( + _this3.flags.frozenLockfile && + ( ! lockfileClean || match.missingPatterns.length > 0 ) + ) { + throw new ( _errors || _load_errors() ).MessageError( + _this3.reporter.lang( 'frozenLockfileError' ) + ); + } + + const haveLockfile = yield ( _fs || _load_fs() ).exists( + path.join( + _this3.config.lockfileFolder, + ( _constants || _load_constants() ).LOCKFILE_FILENAME + ) + ); + + const lockfileIntegrityPresent = ! _this3.lockfile.hasEntriesExistWithoutIntegrity(); + const integrityBailout = lockfileIntegrityPresent || ! _this3.config.autoAddIntegrity; + + if ( match.integrityMatches && haveLockfile && lockfileClean && integrityBailout ) { + _this3.reporter.success( _this3.reporter.lang( 'upToDate' ) ); + return true; + } + + if ( match.integrityFileMissing && haveLockfile ) { + // Integrity file missing, force script installations + _this3.scripts.setForce( true ); + return false; + } + + if ( match.hardRefreshRequired ) { + // e.g. node version doesn't match, force script installations + _this3.scripts.setForce( true ); + return false; + } + + if ( ! patterns.length && ! match.integrityFileMissing ) { + _this3.reporter.success( _this3.reporter.lang( 'nothingToInstall' ) ); + yield _this3.createEmptyManifestFolders(); + yield _this3.saveLockfileAndIntegrity( patterns, workspaceLayout ); + return true; + } + + return false; + } )(); + } + + /** + * Produce empty folders for all used root manifests. + */ + + createEmptyManifestFolders() { + var _this4 = this; + + return ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*() { + if ( _this4.config.modulesFolder ) { + // already created + return; + } + + for ( + var _iterator9 = _this4.rootManifestRegistries, + _isArray9 = Array.isArray( _iterator9 ), + _i9 = 0, + _iterator9 = _isArray9 ? _iterator9 : _iterator9[ Symbol.iterator ](); + ; + + ) { + var _ref10; + + if ( _isArray9 ) { + if ( _i9 >= _iterator9.length ) break; + _ref10 = _iterator9[ _i9++ ]; + } else { + _i9 = _iterator9.next(); + if ( _i9.done ) break; + _ref10 = _i9.value; + } + + const registryName = _ref10; + const folder = _this4.config.registries[ registryName ].folder; + + yield ( _fs || _load_fs() ).mkdirp( + path.join( _this4.config.lockfileFolder, folder ) + ); + } + } )(); + } + + /** + * TODO description + */ + + markIgnored( patterns ) { + for ( + var _iterator10 = patterns, + _isArray10 = Array.isArray( _iterator10 ), + _i10 = 0, + _iterator10 = _isArray10 ? _iterator10 : _iterator10[ Symbol.iterator ](); + ; + + ) { + var _ref11; + + if ( _isArray10 ) { + if ( _i10 >= _iterator10.length ) break; + _ref11 = _iterator10[ _i10++ ]; + } else { + _i10 = _iterator10.next(); + if ( _i10.done ) break; + _ref11 = _i10.value; + } + + const pattern = _ref11; + + const manifest = this.resolver.getStrictResolvedPattern( pattern ); + const ref = manifest._reference; + invariant( ref, 'expected package reference' ); + + // just mark the package as ignored. if the package is used by a required package, the hoister + // will take care of that. + ref.ignore = true; + } + } + + /** + * helper method that gets only recent manifests + * used by global.ls command + */ + getFlattenedDeps() { + var _this5 = this; + + return ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*() { + var _ref12 = yield _this5.fetchRequestFromCwd(); + + const depRequests = _ref12.requests, + rawPatterns = _ref12.patterns; + + yield _this5.resolver.init( depRequests, {} ); + + const manifests = yield ( _packageFetcher || _load_packageFetcher() ).fetch( + _this5.resolver.getManifests(), + _this5.config + ); + _this5.resolver.updateManifests( manifests ); + + return _this5.flatten( rawPatterns ); + } )(); + } + + /** + * TODO description + */ + + init() { + var _this6 = this; + + return ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*() { + _this6.checkUpdate(); + + // warn if we have a shrinkwrap + if ( + yield ( _fs || _load_fs() ).exists( + path.join( + _this6.config.lockfileFolder, + ( _constants || _load_constants() ).NPM_SHRINKWRAP_FILENAME + ) + ) + ) { + _this6.reporter.warn( _this6.reporter.lang( 'shrinkwrapWarning' ) ); + } + + // warn if we have an npm lockfile + if ( + yield ( _fs || _load_fs() ).exists( + path.join( + _this6.config.lockfileFolder, + ( _constants || _load_constants() ).NPM_LOCK_FILENAME + ) + ) + ) { + _this6.reporter.warn( _this6.reporter.lang( 'npmLockfileWarning' ) ); + } + + if ( _this6.config.plugnplayEnabled ) { + _this6.reporter.info( _this6.reporter.lang( 'plugnplaySuggestV2L1' ) ); + _this6.reporter.info( _this6.reporter.lang( 'plugnplaySuggestV2L2' ) ); + } + + let flattenedTopLevelPatterns = []; + const steps = []; + + var _ref13 = yield _this6.fetchRequestFromCwd(); + + const depRequests = _ref13.requests, + rawPatterns = _ref13.patterns, + ignorePatterns = _ref13.ignorePatterns, + workspaceLayout = _ref13.workspaceLayout, + manifest = _ref13.manifest; + + let topLevelPatterns = []; + + const artifacts = yield _this6.integrityChecker.getArtifacts(); + if ( artifacts ) { + _this6.linker.setArtifacts( artifacts ); + _this6.scripts.setArtifacts( artifacts ); + } + + if ( + ( _packageCompatibility || _load_packageCompatibility() ).shouldCheck( + manifest, + _this6.flags + ) + ) { + steps.push( + ( () => { + var _ref14 = ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( + function*( curr, total ) { + _this6.reporter.step( + curr, + total, + _this6.reporter.lang( 'checkingManifest' ), + emoji.get( 'mag' ) + ); + yield _this6.checkCompatibility(); + } + ); + + return function( _x, _x2 ) { + return _ref14.apply( this, arguments ); + }; + } )() + ); + } + + const audit = new ( _audit || _load_audit() ).default( _this6.config, _this6.reporter, { + groups: ( _constants || _load_constants() ).OWNED_DEPENDENCY_TYPES, + } ); + let auditFoundProblems = false; + + steps.push( function( curr, total ) { + return ( 0, ( _hooks || _load_hooks() ).callThroughHook )( + 'resolveStep', + ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*() { + _this6.reporter.step( + curr, + total, + _this6.reporter.lang( 'resolvingPackages' ), + emoji.get( 'mag' ) + ); + yield _this6.resolver.init( _this6.prepareRequests( depRequests ), { + isFlat: _this6.flags.flat, + isFrozen: _this6.flags.frozenLockfile, + workspaceLayout, + } ); + topLevelPatterns = _this6.preparePatterns( rawPatterns ); + flattenedTopLevelPatterns = yield _this6.flatten( topLevelPatterns ); + return { + bailout: + ! _this6.flags.audit && + ( yield _this6.bailout( topLevelPatterns, workspaceLayout ) ), + }; + } ) + ); + } ); + + if ( _this6.flags.audit ) { + steps.push( function( curr, total ) { + return ( 0, ( _hooks || _load_hooks() ).callThroughHook )( + 'auditStep', + ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*() { + _this6.reporter.step( + curr, + total, + _this6.reporter.lang( 'auditRunning' ), + emoji.get( 'mag' ) + ); + if ( _this6.flags.offline ) { + _this6.reporter.warn( _this6.reporter.lang( 'auditOffline' ) ); + return { bailout: false }; + } + const preparedManifests = yield _this6.prepareManifests(); + // $FlowFixMe - Flow considers `m` in the map operation to be "mixed", so does not recognize `m.object` + const mergedManifest = Object.assign( + {}, + ...Object.values( preparedManifests ).map( function( m ) { + return m.object; + } ) + ); + const auditVulnerabilityCounts = yield audit.performAudit( + mergedManifest, + _this6.lockfile, + _this6.resolver, + _this6.linker, + topLevelPatterns + ); + auditFoundProblems = + auditVulnerabilityCounts.info || + auditVulnerabilityCounts.low || + auditVulnerabilityCounts.moderate || + auditVulnerabilityCounts.high || + auditVulnerabilityCounts.critical; + return { bailout: yield _this6.bailout( topLevelPatterns, workspaceLayout ) }; + } ) + ); + } ); + } + + steps.push( function( curr, total ) { + return ( 0, ( _hooks || _load_hooks() ).callThroughHook )( + 'fetchStep', + ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*() { + _this6.markIgnored( ignorePatterns ); + _this6.reporter.step( + curr, + total, + _this6.reporter.lang( 'fetchingPackages' ), + emoji.get( 'truck' ) + ); + const manifests = yield ( _packageFetcher || _load_packageFetcher() ).fetch( + _this6.resolver.getManifests(), + _this6.config + ); + _this6.resolver.updateManifests( manifests ); + yield ( _packageCompatibility || _load_packageCompatibility() ).check( + _this6.resolver.getManifests(), + _this6.config, + _this6.flags.ignoreEngines + ); + } ) + ); + } ); + + steps.push( function( curr, total ) { + return ( 0, ( _hooks || _load_hooks() ).callThroughHook )( + 'linkStep', + ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*() { + // remove integrity hash to make this operation atomic + yield _this6.integrityChecker.removeIntegrityFile(); + _this6.reporter.step( + curr, + total, + _this6.reporter.lang( 'linkingDependencies' ), + emoji.get( 'link' ) + ); + flattenedTopLevelPatterns = _this6.preparePatternsForLinking( + flattenedTopLevelPatterns, + manifest, + _this6.config.lockfileFolder === _this6.config.cwd + ); + yield _this6.linker.init( flattenedTopLevelPatterns, workspaceLayout, { + linkDuplicates: _this6.flags.linkDuplicates, + ignoreOptional: _this6.flags.ignoreOptional, + } ); + } ) + ); + } ); + + if ( _this6.config.plugnplayEnabled ) { + steps.push( function( curr, total ) { + return ( 0, ( _hooks || _load_hooks() ).callThroughHook )( + 'pnpStep', + ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*() { + const pnpPath = `${ _this6.config.lockfileFolder }/${ + ( _constants || _load_constants() ).PNP_FILENAME + }`; + + const code = yield ( 0, + ( _generatePnpMap || _load_generatePnpMap() ).generatePnpMap )( + _this6.config, + flattenedTopLevelPatterns, + { + resolver: _this6.resolver, + reporter: _this6.reporter, + targetPath: pnpPath, + workspaceLayout, + } + ); + + try { + const file = yield ( _fs || _load_fs() ).readFile( pnpPath ); + if ( file === code ) { + return; + } + } catch ( error ) {} + + yield ( _fs || _load_fs() ).writeFile( pnpPath, code ); + yield ( _fs || _load_fs() ).chmod( pnpPath, 0o755 ); + } ) + ); + } ); + } + + steps.push( function( curr, total ) { + return ( 0, ( _hooks || _load_hooks() ).callThroughHook )( + 'buildStep', + ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*() { + _this6.reporter.step( + curr, + total, + _this6.flags.force + ? _this6.reporter.lang( 'rebuildingPackages' ) + : _this6.reporter.lang( 'buildingFreshPackages' ), + emoji.get( 'hammer' ) + ); + + if ( _this6.config.ignoreScripts ) { + _this6.reporter.warn( _this6.reporter.lang( 'ignoredScripts' ) ); + } else { + yield _this6.scripts.init( flattenedTopLevelPatterns ); + } + } ) + ); + } ); + + if ( _this6.flags.har ) { + steps.push( + ( () => { + var _ref21 = ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( + function*( curr, total ) { + const formattedDate = new Date().toISOString().replace( /:/g, '-' ); + const filename = `yarn-install_${ formattedDate }.har`; + _this6.reporter.step( + curr, + total, + _this6.reporter.lang( 'savingHar', filename ), + emoji.get( 'black_circle_for_record' ) + ); + yield _this6.config.requestManager.saveHar( filename ); + } + ); + + return function( _x3, _x4 ) { + return _ref21.apply( this, arguments ); + }; + } )() + ); + } + + if ( yield _this6.shouldClean() ) { + steps.push( + ( () => { + var _ref22 = ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( + function*( curr, total ) { + _this6.reporter.step( + curr, + total, + _this6.reporter.lang( 'cleaningModules' ), + emoji.get( 'recycle' ) + ); + yield ( 0, ( _autoclean || _load_autoclean() ).clean )( + _this6.config, + _this6.reporter + ); + } + ); + + return function( _x5, _x6 ) { + return _ref22.apply( this, arguments ); + }; + } )() + ); + } + + let currentStep = 0; + for ( + var _iterator11 = steps, + _isArray11 = Array.isArray( _iterator11 ), + _i11 = 0, + _iterator11 = _isArray11 ? _iterator11 : _iterator11[ Symbol.iterator ](); + ; + + ) { + var _ref23; + + if ( _isArray11 ) { + if ( _i11 >= _iterator11.length ) break; + _ref23 = _iterator11[ _i11++ ]; + } else { + _i11 = _iterator11.next(); + if ( _i11.done ) break; + _ref23 = _i11.value; + } + + const step = _ref23; + + const stepResult = yield step( ++currentStep, steps.length ); + if ( stepResult && stepResult.bailout ) { + if ( _this6.flags.audit ) { + audit.summary(); + } + if ( auditFoundProblems ) { + _this6.reporter.warn( _this6.reporter.lang( 'auditRunAuditForDetails' ) ); + } + _this6.maybeOutputUpdate(); + return flattenedTopLevelPatterns; + } + } + + // fin! + if ( _this6.flags.audit ) { + audit.summary(); + } + if ( auditFoundProblems ) { + _this6.reporter.warn( _this6.reporter.lang( 'auditRunAuditForDetails' ) ); + } + yield _this6.saveLockfileAndIntegrity( topLevelPatterns, workspaceLayout ); + yield _this6.persistChanges(); + _this6.maybeOutputUpdate(); + _this6.config.requestManager.clearCache(); + return flattenedTopLevelPatterns; + } )(); + } + + checkCompatibility() { + var _this7 = this; + + return ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*() { + var _ref24 = yield _this7.fetchRequestFromCwd(); + + const manifest = _ref24.manifest; + + yield ( _packageCompatibility || _load_packageCompatibility() ).checkOne( + manifest, + _this7.config, + _this7.flags.ignoreEngines + ); + } )(); + } + + persistChanges() { + var _this8 = this; + + return ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*() { + // get all the different registry manifests in this folder + const manifests = yield _this8.config.getRootManifests(); + + if ( yield _this8.applyChanges( manifests ) ) { + yield _this8.config.saveRootManifests( manifests ); + } + } )(); + } + + applyChanges( manifests ) { + let hasChanged = false; + + if ( this.config.plugnplayPersist ) { + const object = manifests.npm.object; + + if ( typeof object.installConfig !== 'object' ) { + object.installConfig = {}; + } + + if ( this.config.plugnplayEnabled && object.installConfig.pnp !== true ) { + object.installConfig.pnp = true; + hasChanged = true; + } else if ( + ! this.config.plugnplayEnabled && + typeof object.installConfig.pnp !== 'undefined' + ) { + delete object.installConfig.pnp; + hasChanged = true; + } + + if ( Object.keys( object.installConfig ).length === 0 ) { + delete object.installConfig; + } + } + + return Promise.resolve( hasChanged ); + } + + /** + * Check if we should run the cleaning step. + */ + + shouldClean() { + return ( _fs || _load_fs() ).exists( + path.join( + this.config.lockfileFolder, + ( _constants || _load_constants() ).CLEAN_FILENAME + ) + ); + } + + /** + * TODO + */ + + flatten( patterns ) { + var _this9 = this; + + return ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*() { + if ( ! _this9.flags.flat ) { + return patterns; + } + + const flattenedPatterns = []; + + for ( + var _iterator12 = _this9.resolver.getAllDependencyNamesByLevelOrder( patterns ), + _isArray12 = Array.isArray( _iterator12 ), + _i12 = 0, + _iterator12 = _isArray12 ? _iterator12 : _iterator12[ Symbol.iterator ](); + ; + + ) { + var _ref25; + + if ( _isArray12 ) { + if ( _i12 >= _iterator12.length ) break; + _ref25 = _iterator12[ _i12++ ]; + } else { + _i12 = _iterator12.next(); + if ( _i12.done ) break; + _ref25 = _i12.value; + } + + const name = _ref25; + + const infos = _this9.resolver + .getAllInfoForPackageName( name ) + .filter( function( manifest ) { + const ref = manifest._reference; + invariant( ref, 'expected package reference' ); + return ! ref.ignore; + } ); + + if ( infos.length === 0 ) { + continue; + } + + if ( infos.length === 1 ) { + // single version of this package + // take out a single pattern as multiple patterns may have resolved to this package + flattenedPatterns.push( _this9.resolver.patternsByPackage[ name ][ 0 ] ); + continue; + } + + const options = infos.map( function( info ) { + const ref = info._reference; + invariant( ref, 'expected reference' ); + return { + // TODO `and is required by {PARENT}`, + name: _this9.reporter.lang( + 'manualVersionResolutionOption', + ref.patterns.join( ', ' ), + info.version + ), + + value: info.version, + }; + } ); + const versions = infos.map( function( info ) { + return info.version; + } ); + let version; + + const resolutionVersion = _this9.resolutions[ name ]; + if ( resolutionVersion && versions.indexOf( resolutionVersion ) >= 0 ) { + // use json `resolution` version + version = resolutionVersion; + } else { + version = yield _this9.reporter.select( + _this9.reporter.lang( 'manualVersionResolution', name ), + _this9.reporter.lang( 'answer' ), + options + ); + _this9.resolutions[ name ] = version; + } + + flattenedPatterns.push( + _this9.resolver.collapseAllVersionsOfPackage( name, version ) + ); + } + + // save resolutions to their appropriate root manifest + if ( Object.keys( _this9.resolutions ).length ) { + const manifests = yield _this9.config.getRootManifests(); + + for ( const name in _this9.resolutions ) { + const version = _this9.resolutions[ name ]; + + const patterns = _this9.resolver.patternsByPackage[ name ]; + if ( ! patterns ) { + continue; + } + + let manifest; + for ( + var _iterator13 = patterns, + _isArray13 = Array.isArray( _iterator13 ), + _i13 = 0, + _iterator13 = _isArray13 ? _iterator13 : _iterator13[ Symbol.iterator ](); + ; + + ) { + var _ref26; + + if ( _isArray13 ) { + if ( _i13 >= _iterator13.length ) break; + _ref26 = _iterator13[ _i13++ ]; + } else { + _i13 = _iterator13.next(); + if ( _i13.done ) break; + _ref26 = _i13.value; + } + + const pattern = _ref26; + + manifest = _this9.resolver.getResolvedPattern( pattern ); + if ( manifest ) { + break; + } + } + invariant( manifest, 'expected manifest' ); + + const ref = manifest._reference; + invariant( ref, 'expected reference' ); + + const object = manifests[ ref.registry ].object; + object.resolutions = object.resolutions || {}; + object.resolutions[ name ] = version; + } + + yield _this9.config.saveRootManifests( manifests ); + } + + return flattenedPatterns; + } )(); + } + + /** + * Remove offline tarballs that are no longer required + */ + + pruneOfflineMirror( lockfile ) { + var _this10 = this; + + return ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*() { + const mirror = _this10.config.getOfflineMirrorPath(); + if ( ! mirror ) { + return; + } + + const requiredTarballs = new Set(); + for ( const dependency in lockfile ) { + const resolved = lockfile[ dependency ].resolved; + if ( resolved ) { + const basename = path.basename( resolved.split( '#' )[ 0 ] ); + if ( dependency[ 0 ] === '@' && basename[ 0 ] !== '@' ) { + requiredTarballs.add( `${ dependency.split( '/' )[ 0 ] }-${ basename }` ); + } + requiredTarballs.add( basename ); + } + } + + const mirrorFiles = yield ( _fs || _load_fs() ).walk( mirror ); + for ( + var _iterator14 = mirrorFiles, + _isArray14 = Array.isArray( _iterator14 ), + _i14 = 0, + _iterator14 = _isArray14 ? _iterator14 : _iterator14[ Symbol.iterator ](); + ; + + ) { + var _ref27; + + if ( _isArray14 ) { + if ( _i14 >= _iterator14.length ) break; + _ref27 = _iterator14[ _i14++ ]; + } else { + _i14 = _iterator14.next(); + if ( _i14.done ) break; + _ref27 = _i14.value; + } + + const file = _ref27; + + const isTarball = path.extname( file.basename ) === '.tgz'; + // if using experimental-pack-script-packages-in-mirror flag, don't unlink prebuilt packages + const hasPrebuiltPackage = file.relative.startsWith( 'prebuilt/' ); + if ( isTarball && ! hasPrebuiltPackage && ! requiredTarballs.has( file.basename ) ) { + yield ( _fs || _load_fs() ).unlink( file.absolute ); + } + } + } )(); + } + + /** + * Save updated integrity and lockfiles. + */ + + saveLockfileAndIntegrity( patterns, workspaceLayout ) { + var _this11 = this; + + return ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*() { + const resolvedPatterns = {}; + Object.keys( _this11.resolver.patterns ).forEach( function( pattern ) { + if ( ! workspaceLayout || ! workspaceLayout.getManifestByPattern( pattern ) ) { + resolvedPatterns[ pattern ] = _this11.resolver.patterns[ pattern ]; + } + } ); + + // TODO this code is duplicated in a few places, need a common way to filter out workspace patterns from lockfile + patterns = patterns.filter( function( p ) { + return ! workspaceLayout || ! workspaceLayout.getManifestByPattern( p ); + } ); + + const lockfileBasedOnResolver = _this11.lockfile.getLockfile( resolvedPatterns ); + + if ( _this11.config.pruneOfflineMirror ) { + yield _this11.pruneOfflineMirror( lockfileBasedOnResolver ); + } + + // write integrity hash + if ( ! _this11.config.plugnplayEnabled ) { + yield _this11.integrityChecker.save( + patterns, + lockfileBasedOnResolver, + _this11.flags, + workspaceLayout, + _this11.scripts.getArtifacts() + ); + } + + // --no-lockfile or --pure-lockfile or --frozen-lockfile + if ( + _this11.flags.lockfile === false || + _this11.flags.pureLockfile || + _this11.flags.frozenLockfile + ) { + return; + } + + const lockFileHasAllPatterns = patterns.every( function( p ) { + return _this11.lockfile.getLocked( p ); + } ); + const lockfilePatternsMatch = Object.keys( _this11.lockfile.cache || {} ).every( + function( p ) { + return lockfileBasedOnResolver[ p ]; + } + ); + const resolverPatternsAreSameAsInLockfile = Object.keys( + lockfileBasedOnResolver + ).every( function( pattern ) { + const manifest = _this11.lockfile.getLocked( pattern ); + return ( + manifest && + manifest.resolved === lockfileBasedOnResolver[ pattern ].resolved && + deepEqual( + manifest.prebuiltVariants, + lockfileBasedOnResolver[ pattern ].prebuiltVariants + ) + ); + } ); + const integrityPatternsAreSameAsInLockfile = Object.keys( + lockfileBasedOnResolver + ).every( function( pattern ) { + const existingIntegrityInfo = lockfileBasedOnResolver[ pattern ].integrity; + if ( ! existingIntegrityInfo ) { + // if this entry does not have an integrity, no need to re-write the lockfile because of it + return true; + } + const manifest = _this11.lockfile.getLocked( pattern ); + if ( manifest && manifest.integrity ) { + const manifestIntegrity = ssri.stringify( manifest.integrity ); + return manifestIntegrity === existingIntegrityInfo; + } + return false; + } ); + + // remove command is followed by install with force, lockfile will be rewritten in any case then + if ( + ! _this11.flags.force && + _this11.lockfile.parseResultType === 'success' && + lockFileHasAllPatterns && + lockfilePatternsMatch && + resolverPatternsAreSameAsInLockfile && + integrityPatternsAreSameAsInLockfile && + patterns.length + ) { + return; + } + + // build lockfile location + const loc = path.join( + _this11.config.lockfileFolder, + ( _constants || _load_constants() ).LOCKFILE_FILENAME + ); + + // write lockfile + const lockSource = ( 0, ( _lockfile2 || _load_lockfile2() ).stringify )( + lockfileBasedOnResolver, + false, + _this11.config.enableLockfileVersions + ); + yield ( _fs || _load_fs() ).writeFilePreservingEol( loc, lockSource ); + + _this11._logSuccessSaveLockfile(); + } )(); + } + + _logSuccessSaveLockfile() { + this.reporter.success( this.reporter.lang( 'savedLockfile' ) ); + } + + /** + * Load the dependency graph of the current install. Only does package resolving and wont write to the cwd. + */ + hydrate( ignoreUnusedPatterns ) { + var _this12 = this; + + return ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*() { + const request = yield _this12.fetchRequestFromCwd( [], ignoreUnusedPatterns ); + const depRequests = request.requests, + rawPatterns = request.patterns, + ignorePatterns = request.ignorePatterns, + workspaceLayout = request.workspaceLayout; + + yield _this12.resolver.init( depRequests, { + isFlat: _this12.flags.flat, + isFrozen: _this12.flags.frozenLockfile, + workspaceLayout, + } ); + yield _this12.flatten( rawPatterns ); + _this12.markIgnored( ignorePatterns ); + + // fetch packages, should hit cache most of the time + const manifests = yield ( _packageFetcher || _load_packageFetcher() ).fetch( + _this12.resolver.getManifests(), + _this12.config + ); + _this12.resolver.updateManifests( manifests ); + yield ( _packageCompatibility || _load_packageCompatibility() ).check( + _this12.resolver.getManifests(), + _this12.config, + _this12.flags.ignoreEngines + ); + + // expand minimal manifests + for ( + var _iterator15 = _this12.resolver.getManifests(), + _isArray15 = Array.isArray( _iterator15 ), + _i15 = 0, + _iterator15 = _isArray15 ? _iterator15 : _iterator15[ Symbol.iterator ](); + ; + + ) { + var _ref28; + + if ( _isArray15 ) { + if ( _i15 >= _iterator15.length ) break; + _ref28 = _iterator15[ _i15++ ]; + } else { + _i15 = _iterator15.next(); + if ( _i15.done ) break; + _ref28 = _i15.value; + } + + const manifest = _ref28; + + const ref = manifest._reference; + invariant( ref, 'expected reference' ); + const type = ref.remote.type; + // link specifier won't ever hit cache + + let loc = ''; + if ( type === 'link' ) { + continue; + } else if ( type === 'workspace' ) { + if ( ! ref.remote.reference ) { + continue; + } + loc = ref.remote.reference; + } else { + loc = _this12.config.generateModuleCachePath( ref ); + } + const newPkg = yield _this12.config.readManifest( loc ); + yield _this12.resolver.updateManifest( ref, newPkg ); + } + + return request; + } )(); + } + + /** + * Check for updates every day and output a nag message if there's a newer version. + */ + + checkUpdate() { + if ( this.config.nonInteractive ) { + // don't show upgrade dialog on CI or non-TTY terminals + return; + } + + // don't check if disabled + if ( this.config.getOption( 'disable-self-update-check' ) ) { + return; + } + + // only check for updates once a day + const lastUpdateCheck = Number( this.config.getOption( 'lastUpdateCheck' ) ) || 0; + if ( lastUpdateCheck && Date.now() - lastUpdateCheck < ONE_DAY ) { + return; + } + + // don't bug for updates on tagged releases + if ( ( _yarnVersion || _load_yarnVersion() ).version.indexOf( '-' ) >= 0 ) { + return; + } + + this._checkUpdate().catch( () => { + // swallow errors + } ); + } + + _checkUpdate() { + var _this13 = this; + + return ( 0, ( _asyncToGenerator2 || _load_asyncToGenerator() ).default )( function*() { + let latestVersion = yield _this13.config.requestManager.request( { + url: ( _constants || _load_constants() ).SELF_UPDATE_VERSION_URL, + } ); + invariant( typeof latestVersion === 'string', 'expected string' ); + latestVersion = latestVersion.trim(); + if ( ! semver.valid( latestVersion ) ) { + return; + } + + // ensure we only check for updates periodically + _this13.config.registries.yarn.saveHomeConfig( { + lastUpdateCheck: Date.now(), + } ); + + if ( semver.gt( latestVersion, ( _yarnVersion || _load_yarnVersion() ).version ) ) { + const installationMethod = yield ( 0, + ( _yarnVersion || _load_yarnVersion() ).getInstallationMethod )(); + _this13.maybeOutputUpdate = function() { + _this13.reporter.warn( + _this13.reporter.lang( + 'yarnOutdated', + latestVersion, + ( _yarnVersion || _load_yarnVersion() ).version + ) + ); + + const command = getUpdateCommand( installationMethod ); + if ( command ) { + _this13.reporter.info( _this13.reporter.lang( 'yarnOutdatedCommand' ) ); + _this13.reporter.command( command ); + } else { + const installer = getUpdateInstaller( installationMethod ); + if ( installer ) { + _this13.reporter.info( + _this13.reporter.lang( 'yarnOutdatedInstaller', installer ) + ); + } + } + }; + } + } )(); + } + + /** + * Method to override with a possible upgrade message. + */ + + maybeOutputUpdate() {} + } + + exports.Install = Install; + function hasWrapper( commander, args ) { + return true; + } + + function setFlags( commander ) { + commander.description( 'Yarn install is used to install all dependencies for a project.' ); + commander.usage( 'install [flags]' ); + commander.option( '-A, --audit', 'Run vulnerability audit on installed packages' ); + commander.option( '-g, --global', 'DEPRECATED' ); + commander.option( '-S, --save', 'DEPRECATED - save package to your `dependencies`' ); + commander.option( '-D, --save-dev', 'DEPRECATED - save package to your `devDependencies`' ); + commander.option( + '-P, --save-peer', + 'DEPRECATED - save package to your `peerDependencies`' + ); + commander.option( + '-O, --save-optional', + 'DEPRECATED - save package to your `optionalDependencies`' + ); + commander.option( '-E, --save-exact', 'DEPRECATED' ); + commander.option( '-T, --save-tilde', 'DEPRECATED' ); + } + + /***/ + }, + /* 35 */ + /***/ function( module, exports, __webpack_require__ ) { + var isObject = __webpack_require__( 52 ); + module.exports = function( it ) { + if ( ! isObject( it ) ) throw TypeError( it + ' is not an object!' ); + return it; + }; + + /***/ + }, + /* 36 */ + /***/ function( module, __webpack_exports__, __webpack_require__ ) { + 'use strict'; + /* harmony export (binding) */ __webpack_require__.d( __webpack_exports__, 'b', function() { + return SubjectSubscriber; + } ); + /* harmony export (binding) */ __webpack_require__.d( __webpack_exports__, 'a', function() { + return Subject; + } ); + /* unused harmony export AnonymousSubject */ + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__( 1 ); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__Observable__ = __webpack_require__( + 12 + ); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__Subscriber__ = __webpack_require__( 7 ); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__Subscription__ = __webpack_require__( + 25 + ); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__util_ObjectUnsubscribedError__ = __webpack_require__( + 189 + ); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__SubjectSubscription__ = __webpack_require__( + 422 + ); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__internal_symbol_rxSubscriber__ = __webpack_require__( + 321 + ); + /** PURE_IMPORTS_START tslib,_Observable,_Subscriber,_Subscription,_util_ObjectUnsubscribedError,_SubjectSubscription,_internal_symbol_rxSubscriber PURE_IMPORTS_END */ + + var SubjectSubscriber = /*@__PURE__*/ ( function( _super ) { + __WEBPACK_IMPORTED_MODULE_0_tslib__[ 'a' /* __extends */ ]( SubjectSubscriber, _super ); + function SubjectSubscriber( destination ) { + var _this = _super.call( this, destination ) || this; + _this.destination = destination; + return _this; + } + return SubjectSubscriber; + } )( __WEBPACK_IMPORTED_MODULE_2__Subscriber__[ 'a' /* Subscriber */ ] ); + + var Subject = /*@__PURE__*/ ( function( _super ) { + __WEBPACK_IMPORTED_MODULE_0_tslib__[ 'a' /* __extends */ ]( Subject, _super ); + function Subject() { + var _this = _super.call( this ) || this; + _this.observers = []; + _this.closed = false; + _this.isStopped = false; + _this.hasError = false; + _this.thrownError = null; + return _this; + } + Subject.prototype[ + __WEBPACK_IMPORTED_MODULE_6__internal_symbol_rxSubscriber__[ 'a' /* rxSubscriber */ ] + ] = function() { + return new SubjectSubscriber( this ); + }; + Subject.prototype.lift = function( operator ) { + var subject = new AnonymousSubject( this, this ); + subject.operator = operator; + return subject; + }; + Subject.prototype.next = function( value ) { + if ( this.closed ) { + throw new __WEBPACK_IMPORTED_MODULE_4__util_ObjectUnsubscribedError__[ + 'a' /* ObjectUnsubscribedError */ + ](); + } + if ( ! this.isStopped ) { + var observers = this.observers; + var len = observers.length; + var copy = observers.slice(); + for ( var i = 0; i < len; i++ ) { + copy[ i ].next( value ); + } + } + }; + Subject.prototype.error = function( err ) { + if ( this.closed ) { + throw new __WEBPACK_IMPORTED_MODULE_4__util_ObjectUnsubscribedError__[ + 'a' /* ObjectUnsubscribedError */ + ](); + } + this.hasError = true; + this.thrownError = err; + this.isStopped = true; + var observers = this.observers; + var len = observers.length; + var copy = observers.slice(); + for ( var i = 0; i < len; i++ ) { + copy[ i ].error( err ); + } + this.observers.length = 0; + }; + Subject.prototype.complete = function() { + if ( this.closed ) { + throw new __WEBPACK_IMPORTED_MODULE_4__util_ObjectUnsubscribedError__[ + 'a' /* ObjectUnsubscribedError */ + ](); + } + this.isStopped = true; + var observers = this.observers; + var len = observers.length; + var copy = observers.slice(); + for ( var i = 0; i < len; i++ ) { + copy[ i ].complete(); + } + this.observers.length = 0; + }; + Subject.prototype.unsubscribe = function() { + this.isStopped = true; + this.closed = true; + this.observers = null; + }; + Subject.prototype._trySubscribe = function( subscriber ) { + if ( this.closed ) { + throw new __WEBPACK_IMPORTED_MODULE_4__util_ObjectUnsubscribedError__[ + 'a' /* ObjectUnsubscribedError */ + ](); + } else { + return _super.prototype._trySubscribe.call( this, subscriber ); + } + }; + Subject.prototype._subscribe = function( subscriber ) { + if ( this.closed ) { + throw new __WEBPACK_IMPORTED_MODULE_4__util_ObjectUnsubscribedError__[ + 'a' /* ObjectUnsubscribedError */ + ](); + } else if ( this.hasError ) { + subscriber.error( this.thrownError ); + return __WEBPACK_IMPORTED_MODULE_3__Subscription__[ 'a' /* Subscription */ ].EMPTY; + } else if ( this.isStopped ) { + subscriber.complete(); + return __WEBPACK_IMPORTED_MODULE_3__Subscription__[ 'a' /* Subscription */ ].EMPTY; + } else { + this.observers.push( subscriber ); + return new __WEBPACK_IMPORTED_MODULE_5__SubjectSubscription__[ + 'a' /* SubjectSubscription */ + ]( this, subscriber ); + } + }; + Subject.prototype.asObservable = function() { + var observable = new __WEBPACK_IMPORTED_MODULE_1__Observable__[ 'a' /* Observable */ ](); + observable.source = this; + return observable; + }; + Subject.create = function( destination, source ) { + return new AnonymousSubject( destination, source ); + }; + return Subject; + } )( __WEBPACK_IMPORTED_MODULE_1__Observable__[ 'a' /* Observable */ ] ); + + var AnonymousSubject = /*@__PURE__*/ ( function( _super ) { + __WEBPACK_IMPORTED_MODULE_0_tslib__[ 'a' /* __extends */ ]( AnonymousSubject, _super ); + function AnonymousSubject( destination, source ) { + var _this = _super.call( this ) || this; + _this.destination = destination; + _this.source = source; + return _this; + } + AnonymousSubject.prototype.next = function( value ) { + var destination = this.destination; + if ( destination && destination.next ) { + destination.next( value ); + } + }; + AnonymousSubject.prototype.error = function( err ) { + var destination = this.destination; + if ( destination && destination.error ) { + this.destination.error( err ); + } + }; + AnonymousSubject.prototype.complete = function() { + var destination = this.destination; + if ( destination && destination.complete ) { + this.destination.complete(); + } + }; + AnonymousSubject.prototype._subscribe = function( subscriber ) { + var source = this.source; + if ( source ) { + return this.source.subscribe( subscriber ); + } else { + return __WEBPACK_IMPORTED_MODULE_3__Subscription__[ 'a' /* Subscription */ ].EMPTY; + } + }; + return AnonymousSubject; + } )( Subject ); + + //# sourceMappingURL=Subject.js.map + + /***/ + }, + /* 37 */ + /***/ function( module, exports, __webpack_require__ ) { + 'use strict'; + + Object.defineProperty( exports, '__esModule', { + value: true, + } ); + exports.normalizePattern = normalizePattern; + + /** + * Explode and normalize a pattern into its name and range. + */ + + function normalizePattern( pattern ) { + let hasVersion = false; + let range = 'latest'; + let name = pattern; + + // if we're a scope then remove the @ and add it back later + let isScoped = false; + if ( name[ 0 ] === '@' ) { + isScoped = true; + name = name.slice( 1 ); + } + + // take first part as the name + const parts = name.split( '@' ); + if ( parts.length > 1 ) { + name = parts.shift(); + range = parts.join( '@' ); + + if ( range ) { + hasVersion = true; + } else { + range = '*'; + } + } + + // add back @ scope suffix + if ( isScoped ) { + name = `@${ name }`; + } + + return { name, range, hasVersion }; + } + + /***/ + }, + /* 38 */ + /***/ function( module, exports, __webpack_require__ ) { + /* WEBPACK VAR INJECTION */ ( function( module ) { + var __WEBPACK_AMD_DEFINE_RESULT__; + /** + * @license + * Lodash + * Copyright JS 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. */ + var undefined; + + /** Used as the semantic version number. */ + var VERSION = '4.17.10'; + + /** 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'; + + /** 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.7976931348623157e308, + 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 ], + ]; + + /** `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 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 match template delimiters. */ + var reEscape = /<%-([\s\S]+?)%>/g, + reEvaluate = /<%([\s\S]+?)%>/g, + reInterpolate = /<%=([\s\S]+?)%>/g; + + /** Used to match property names within property paths. */ + var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, + reIsPlainProp = /^\w*$/, + rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; + + /** + * 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 match leading and trailing whitespace. */ + var reTrim = /^\s+|\s+$/g, + reTrimStart = /^\s+/, + reTrimEnd = /\s+$/; + + /** Used to match wrap detail comments. */ + var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/, + reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/, + reSplitDetails = /,? & /; + + /** Used to match words composed of alphanumeric characters. */ + var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g; + + /** Used to match backslashes in property paths. */ + var reEscapeChar = /\\(\\)?/g; + + /** + * 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. */ + var reFlags = /\w*$/; + + /** Used to detect bad signed hexadecimal string values. */ + var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; + + /** Used to detect binary string values. */ + var reIsBinary = /^0b[01]+$/i; + + /** Used to detect host constructors (Safari). */ + var reIsHostCtor = /^\[object .+?Constructor\]$/; + + /** Used to detect octal string values. */ + var reIsOctal = /^0o[0-7]+$/i; + + /** Used to detect unsigned integer values. */ + var reIsUint = /^(?:0|[1-9]\d*)$/; + + /** Used to match Latin Unicode letters (excluding mathematical operators). */ + var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g; + + /** Used to ensure capturing order of template delimiters. */ + var reNoMatch = /($^)/; + + /** 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 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 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. + À: 'A', + Á: 'A', + Â: 'A', + Ã: 'A', + Ä: 'A', + Å: 'A', + à: 'a', + á: 'a', + â: 'a', + ã: 'a', + ä: 'a', + å: 'a', + Ç: 'C', + ç: 'c', + Ð: 'D', + ð: 'd', + È: 'E', + É: 'E', + Ê: 'E', + Ë: 'E', + è: 'e', + é: 'e', + ê: 'e', + ë: 'e', + Ì: 'I', + Í: 'I', + Î: 'I', + Ï: 'I', + ì: 'i', + í: 'i', + î: 'i', + ï: 'i', + Ñ: 'N', + ñ: 'n', + Ò: 'O', + Ó: 'O', + Ô: 'O', + Õ: 'O', + Ö: 'O', + Ø: 'O', + ò: 'o', + ó: 'o', + ô: 'o', + õ: 'o', + ö: 'o', + ø: 'o', + Ù: 'U', + Ú: 'U', + Û: 'U', + Ü: 'U', + ù: 'u', + ú: 'u', + û: 'u', + ü: 'u', + Ý: 'Y', + ý: 'y', + ÿ: 'y', + Æ: 'Ae', + æ: 'ae', + Þ: 'Th', + þ: 'th', + ß: 'ss', + // Latin Extended-A block. + Ā: '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', + Ĵ: 'J', + ĵ: 'j', + Ķ: 'K', + ķ: 'k', + ĸ: 'k', + Ĺ: 'L', + Ļ: 'L', + Ľ: 'L', + Ŀ: 'L', + Ł: 'L', + ĺ: 'l', + ļ: 'l', + ľ: 'l', + ŀ: 'l', + ł: 'l', + Ń: 'N', + Ņ: 'N', + Ň: 'N', + Ŋ: 'N', + ń: 'n', + ņ: 'n', + ň: 'n', + ŋ: 'n', + Ō: 'O', + Ŏ: 'O', + Ő: 'O', + ō: 'o', + ŏ: 'o', + ő: 'o', + Ŕ: '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', + IJ: 'IJ', + ij: 'ij', + Œ: 'Oe', + œ: 'oe', + ʼn: "'n", + ſ: 's', + }; + + /** Used to map characters to HTML entities. */ + var htmlEscapes = { + '&': '&', + '<': '<', + '>': '>', + '"': '"', + "'": ''', + }; + + /** Used to map HTML entities to characters. */ + var htmlUnescapes = { + '&': '&', + '<': '<', + '>': '>', + '"': '"', + ''': "'", + }; + + /** Used to escape characters for inclusion in compiled string literals. */ + var stringEscapes = { + '\\': '\\', + "'": "'", + '\n': 'n', + '\r': 'r', + '\u2028': 'u2028', + '\u2029': 'u2029', + }; + + /** Built-in method references without a dependency on `root`. */ + var freeParseFloat = parseFloat, + freeParseInt = parseInt; + + /** Detect free variable `global` from Node.js. */ + var freeGlobal = + typeof global == 'object' && global && global.Object === Object && global; + + /** Detect free variable `self`. */ + var freeSelf = typeof self == 'object' && self && self.Object === Object && self; + + /** Used as a reference to the global object. */ + var root = freeGlobal || freeSelf || Function( 'return this' )(); + + /** 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; + + /*--------------------------------------------------------------------------*/ + + /** + * A faster alternative to `Function#apply`, this function invokes `func` + * with the `this` binding of `thisArg` and the arguments of `args`. + * + * @private + * @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 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 ) { + var value = array[ index ]; + setter( accumulator, value, iteratee( value ), array ); + } + return accumulator; + } + + /** + * A specialized version of `_.forEach` 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 arrayEach( array, iteratee ) { + var index = -1, + length = array == null ? 0 : array.length; + + while ( ++index < length ) { + if ( iteratee( array[ index ], index, array ) === false ) { + break; + } + } + 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; + + while ( length-- ) { + if ( iteratee( array[ length ], length, array ) === false ) { + break; + } + } + return array; + } + + /** + * A specialized version of `_.every` 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 {boolean} Returns `true` if all elements pass the predicate check, + * else `false`. + */ + function arrayEvery( array, predicate ) { + var index = -1, + length = array == null ? 0 : array.length; + + while ( ++index < length ) { + if ( ! predicate( array[ index ], index, array ) ) { + return false; + } + } + return 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; + } + + /** + * A specialized version of `_.includes` for arrays without support for + * specifying an index to search from. + * + * @private + * @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 arrayIncludes( array, value ) { + var length = array == null ? 0 : array.length; + return !! length && baseIndexOf( array, value, 0 ) > -1; + } + + /** + * This function is like `arrayIncludes` except that it accepts a comparator. + * + * @private + * @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 arrayIncludesWith( array, value, comparator ) { + var index = -1, + length = array == null ? 0 : array.length; + + while ( ++index < length ) { + if ( comparator( value, array[ index ] ) ) { + return true; + } + } + return false; + } + + /** + * A specialized version of `_.map` 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 the new mapped array. + */ + function arrayMap( array, iteratee ) { + var index = -1, + length = array == null ? 0 : array.length, + result = Array( length ); + + while ( ++index < length ) { + result[ index ] = iteratee( array[ index ], index, array ); + } + return result; + } + + /** + * 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 ) { + array[ offset + index ] = values[ index ]; + } + return array; + } + + /** + * A specialized version of `_.reduce` 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 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 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; + } + + /** + * A specialized version of `_.some` 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 {boolean} Returns `true` if any element passes the predicate check, + * else `false`. + */ + 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 the size of an ASCII `string`. + * + * @private + * @param {string} string The string inspect. + * @returns {number} Returns the string size. + */ + 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( '' ); + } + + /** + * Splits an ASCII `string` into an array of its words. + * + * @private + * @param {string} The string to inspect. + * @returns {Array} Returns the words of `string`. + */ + function asciiWords( string ) { + return string.match( reAsciiWord ) || []; + } + + /** + * The base implementation of methods like `_.findKey` and `_.findLastKey`, + * without support for iteratee shorthands, which iterates over `collection` + * using `eachFunc`. + * + * @private + * @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 baseFindKey( collection, predicate, eachFunc ) { + var result; + eachFunc( collection, function( value, key, collection ) { + if ( predicate( value, key, collection ) ) { + result = key; + return false; + } + } ); + return result; + } + + /** + * The base implementation of `_.findIndex` and `_.findLastIndex` without + * support for iteratee shorthands. + * + * @private + * @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 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; + } + + /** + * The base implementation of `_.indexOf` without `fromIndex` bounds checks. + * + * @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} 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 baseIndexOfWith( array, value, fromIndex, comparator ) { + var index = fromIndex - 1, + length = array.length; + + while ( ++index < length ) { + if ( comparator( array[ index ], value ) ) { + return index; + } + } + return -1; + } + + /** + * The base implementation of `_.isNaN` without support for number objects. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`. + */ + function baseIsNaN( value ) { + return value !== value; + } + + /** + * 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; + } + + /** + * 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 ]; + }; + } + + /** + * 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 ]; + }; + } + + /** + * 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; + } + + /** + * 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; + + array.sort( comparer ); + while ( length-- ) { + array[ length ] = array[ length ].value; + } + return array; + } + + /** + * 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; + + 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 ); + + while ( ++index < n ) { + result[ index ] = iteratee( index ); + } + return result; + } + + /** + * 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 `_.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; + } + + /** + * Gets the value at `key`, unless `key` is "__proto__". + * + * @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 ) { + return key == '__proto__' ? undefined : object[ key ]; + } + + /** + * 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 `_.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 ) ); + } ); + + return result; + } + + if ( isMap( value ) ) { + value.forEach( function( subValue, key ) { + result.set( key, baseClone( subValue, bitmask, customizer, key, value, stack ) ); + } ); + + return result; + } + + 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 ) { + if ( isObject( srcValue ) ) { + stack || ( stack = new Stack() ); + 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 ) || ( srcIndex && 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 ) { + var index = -1; + iteratees = arrayMap( + iteratees.length ? iteratees : [ identity ], + 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 ( 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 ) { + value = iteratee( value ); + + var low = 0, + high = array == null ? 0 : array.length, + 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 ) { + // 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; + } + // Assume cyclic values are equal. + var stacked = stack.get( array ); + if ( stacked && stack.get( other ) ) { + return stacked == other; + } + 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; + } + } + // Assume cyclic values are equal. + var stacked = stack.get( object ); + if ( stacked && stack.get( other ) ) { + return stacked == other; + } + 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; + } + + /** + * 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'] + */ + 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': 40 }, + * { 'user': 'barney', 'age': 34 } + * ]; + * + * _.sortBy(users, [function(o) { return o.user; }]); + * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]] + * + * _.sortBy(users, ['user', 'age']); + * // => objects for [['barney', 34], ['barney', 36], ['fred', 40], ['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. + 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 ); + } + + /** + * Creates a function that invokes `func` with its arguments transformed. + * + * @static + * @since 4.0.0 + * @memberOf _ + * @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 overArgs = castRest( function( func, transforms ) { + transforms = + transforms.length == 1 && isArray( transforms[ 0 ] ) + ? arrayMap( transforms[ 0 ], baseUnary( getIteratee() ) ) + : arrayMap( baseFlatten( transforms, 1 ), baseUnary( getIteratee() ) ); + + var funcsLength = transforms.length; + return baseRest( function( args ) { + var index = -1, + length = nativeMin( args.length, funcsLength ); + + while ( ++index < length ) { + args[ index ] = transforms[ index ].call( this, args[ index ] ); + } + return apply( func, this, args ); + } ); + } ); + + /** + * 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 ); + } ); + + /** + * 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 ); + } ); + + /** + * 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 ); + } ); + + /** + * 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 ); + } + + /** + * 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 ); + + if ( array ) { + arrayPush( otherArgs, array ); + } + return apply( func, this, otherArgs ); + } ); + } + + /** + * 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; + + 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, + } ); + } + + /** + * 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 ); + } + + /** + * 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 ); + } + + /*------------------------------------------------------------------------*/ + + /** + * 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 []; + } + 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 ); + } + + /** + * 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 _ + * @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 + */ + function conformsTo( object, source ) { + return source == null || baseConformsTo( object, source, keys( source ) ); + } + + /** + * Performs a + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * comparison between two values to determine if they are equivalent. + * + * @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 eq( value, other ) { + return value === other || ( value !== value && other !== other ); + } + + /** + * Checks if `value` is greater than `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 `other`, + * else `false`. + * @see _.lt + * @example + * + * _.gt(3, 1); + * // => true + * + * _.gt(3, 3); + * // => false + * + * _.gt(1, 3); + * // => false + */ + var gt = createRelationalOperation( baseGt ); + + /** + * 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; + } ); + + /** + * 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' ) + ); + }; + + /** + * 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; + + /** + * 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; + + /** + * 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`. + * + * @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 isArrayLike( value ) { + return value != null && isLength( value.length ) && ! isFunction( value ); + } + + /** + * This method is like `_.isArrayLike` except that it also checks if `value` + * is an object. + * + * @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 isArrayLikeObject( value ) { + return isObjectLike( value ) && isArrayLike( value ); + } + + /** + * Checks if `value` is classified as a boolean primitive or object. + * + * @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 isBoolean( value ) { + return ( + value === true || + value === false || + ( isObjectLike( value ) && baseGetTag( value ) == boolTag ) + ); + } + + /** + * 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. + * + * @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 + */ + var isDate = nodeIsDate ? baseUnary( nodeIsDate ) : baseIsDate; + + /** + * Checks if `value` is likely a DOM element. + * + * @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 ); + } + + /** + * Checks if `value` is an empty object, collection, map, or set. + * + * 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 isEmpty( value ) { + if ( value == null ) { + return true; + } + if ( + isArrayLike( value ) && + ( isArray( value ) || + typeof value == 'string' || + typeof value.splice == 'function' || + isBuffer( value ) || + isTypedArray( value ) || + isArguments( value ) ) + ) { + return ! value.length; + } + var tag = getTag( value ); + if ( tag == mapTag || tag == setTag ) { + return ! value.size; + } + if ( isPrototype( value ) ) { + return ! baseKeys( value ).length; + } + for ( var key in value ) { + if ( hasOwnProperty.call( value, key ) ) { + return false; + } + } + return true; + } + + /** + * Performs a deep comparison between two values to determine if they are + * equivalent. + * + * **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. `===`. + * + * @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 + * + * var object = { 'a': 1 }; + * var other = { 'a': 1 }; + * + * _.isEqual(object, other); + * // => true + * + * object === other; + * // => false + */ + function isEqual( value, other ) { + return baseIsEqual( value, other ); + } + + /** + * 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]). + * + * @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 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; + } + + /** + * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`, + * `SyntaxError`, `TypeError`, or `URIError` object. + * + * @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 isError( value ) { + if ( ! isObjectLike( value ) ) { + return false; + } + var tag = baseGetTag( value ); + return ( + tag == errorTag || + tag == domExcTag || + ( typeof value.message == 'string' && + typeof value.name == 'string' && + ! isPlainObject( value ) ) + ); + } + + /** + * Checks if `value` is a finite primitive number. + * + * **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 isFinite( value ) { + return typeof value == 'number' && nativeIsFinite( value ); + } + + /** + * Checks if `value` is classified as a `Function` object. + * + * @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 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; + } + + /** + * 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 + * + * _.isInteger(Infinity); + * // => false + * + * _.isInteger('3'); + * // => false + */ + function isInteger( value ) { + return typeof value == 'number' && value == toInteger( value ); + } + + /** + * Checks if `value` is a valid array-like length. + * + * **Note:** This method is loosely based on + * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @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 isLength( value ) { + return ( + typeof value == 'number' && + value > -1 && + value % 1 == 0 && + value <= MAX_SAFE_INTEGER + ); + } + + /** + * 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('')`) + * + * @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 isObject( value ) { + var type = typeof value; + return value != null && ( type == 'object' || type == 'function' ); + } + + /** + * 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 _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + * @example + * + * _.isObjectLike({}); + * // => true + * + * _.isObjectLike([1, 2, 3]); + * // => true + * + * _.isObjectLike(_.noop); + * // => false + * + * _.isObjectLike(null); + * // => false + */ + function isObjectLike( value ) { + return value != null && typeof value == 'object'; + } + + /** + * Checks if `value` is classified as a `Map` object. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a map, else `false`. + * @example + * + * _.isMap(new Map); + * // => true + * + * _.isMap(new WeakMap); + * // => false + */ + var isMap = nodeIsMap ? baseUnary( nodeIsMap ) : baseIsMap; + + /** + * Performs a partial deep comparison between `object` and `source` to + * determine if `object` contains equivalent property values. + * + * **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. + * @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 + */ + function isMatch( object, source ) { + return object === source || baseIsMatch( object, source, getMatchData( source ) ); + } + + /** + * 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 _ + * @since 4.0.0 + * @category Lang + * @param {Object} object The object to inspect. + * @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 + * + * 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 + */ + function isMatchWith( object, source, customizer ) { + customizer = typeof customizer == 'function' ? customizer : undefined; + return baseIsMatch( object, source, getMatchData( source ), customizer ); + } + + /** + * 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 + * + * isNaN(undefined); + * // => true + * + * _.isNaN(undefined); + * // => false + */ + 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; + } + + /** + * Checks if `value` is a pristine native function. + * + * **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 + */ + function isNative( value ) { + if ( isMaskable( value ) ) { + throw new Error( CORE_ERROR_TEXT ); + } + return baseIsNative( value ); + } + + /** + * Checks if `value` is `null`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is `null`, else `false`. + * @example + * + * _.isNull(null); + * // => true + * + * _.isNull(void 0); + * // => false + */ + function isNull( value ) { + return value === null; + } + + /** + * Checks if `value` is `null` or `undefined`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is nullish, else `false`. + * @example + * + * _.isNil(null); + * // => true + * + * _.isNil(void 0); + * // => true + * + * _.isNil(NaN); + * // => false + */ + function isNil( value ) { + return value == null; + } + + /** + * Checks if `value` is classified as a `Number` primitive or object. + * + * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are + * classified as numbers, use the `_.isFinite` method. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a number, else `false`. + * @example + * + * _.isNumber(3); + * // => true + * + * _.isNumber(Number.MIN_VALUE); + * // => true + * + * _.isNumber(Infinity); + * // => true + * + * _.isNumber('3'); + * // => false + */ + function isNumber( value ) { + return ( + typeof value == 'number' || + ( isObjectLike( value ) && baseGetTag( value ) == numberTag ) + ); + } + + /** + * 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 _ + * @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 Foo() { + * this.a = 1; + * } + * + * _.isPlainObject(new Foo); + * // => false + * + * _.isPlainObject([1, 2, 3]); + * // => false + * + * _.isPlainObject({ 'x': 0, 'y': 0 }); + * // => true + * + * _.isPlainObject(Object.create(null)); + * // => true + */ + 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 + ); + } + + /** + * Checks if `value` is classified as a `RegExp` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a regexp, else `false`. + * @example + * + * _.isRegExp(/abc/); + * // => true + * + * _.isRegExp('/abc/'); + * // => false + */ + var isRegExp = nodeIsRegExp ? baseUnary( nodeIsRegExp ) : baseIsRegExp; + + /** + * 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. + * + * **Note:** This method is based on + * [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger). + * + * @static + * @memberOf _ + * @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 + * + * _.isSafeInteger(3); + * // => true + * + * _.isSafeInteger(Number.MIN_VALUE); + * // => false + * + * _.isSafeInteger(Infinity); + * // => false + * + * _.isSafeInteger('3'); + * // => false + */ + function isSafeInteger( value ) { + return isInteger( value ) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER; + } + + /** + * 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 + * + * _.isSet(new Set); + * // => true + * + * _.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 Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a string, else `false`. + * @example + * + * _.isString('abc'); + * // => true + * + * _.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. + * + * @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 + * + * _.isSymbol(Symbol.iterator); + * // => true + * + * _.isSymbol('abc'); + * // => false + */ + function isSymbol( value ) { + return ( + typeof value == 'symbol' || + ( isObjectLike( value ) && baseGetTag( value ) == symbolTag ) + ); + } + + /** + * Checks if `value` is classified as a typed array. + * + * @static + * @memberOf _ + * @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 + * + * _.isTypedArray(new Uint8Array); + * // => true + * + * _.isTypedArray([]); + * // => false + */ + var isTypedArray = nodeIsTypedArray ? baseUnary( nodeIsTypedArray ) : baseIsTypedArray; + + /** + * Checks if `value` is `undefined`. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`. + * @example + * + * _.isUndefined(void 0); + * // => true + * + * _.isUndefined(null); + * // => false + */ + function isUndefined( value ) { + return value === undefined; + } + + /** + * Checks if `value` is classified as a `WeakMap` object. + * + * @static + * @memberOf _ + * @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 + * + * _.isWeakMap(new WeakMap); + * // => true + * + * _.isWeakMap(new Map); + * // => false + */ + function isWeakMap( value ) { + return isObjectLike( value ) && getTag( value ) == weakMapTag; + } + + /** + * Checks if `value` is classified as a `WeakSet` object. + * + * @static + * @memberOf _ + * @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 + * + * _.isWeakSet(new WeakSet); + * // => true + * + * _.isWeakSet(new Set); + * // => false + */ + function isWeakSet( value ) { + return isObjectLike( value ) && baseGetTag( value ) == weakSetTag; + } + + /** + * Checks if `value` is less than `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 less than `other`, + * else `false`. + * @see _.gt + * @example + * + * _.lt(1, 3); + * // => true + * + * _.lt(3, 3); + * // => false + * + * _.lt(3, 1); + * // => false + */ + var lt = createRelationalOperation( baseLt ); + + /** + * Checks if `value` is less 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 less than or equal to + * `other`, else `false`. + * @see _.gte + * @example + * + * _.lte(1, 3); + * // => true + * + * _.lte(3, 3); + * // => true + * + * _.lte(3, 1); + * // => false + */ + var lte = createRelationalOperation( function( value, other ) { + return value <= other; + } ); + + /** + * Converts `value` to an array. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Lang + * @param {*} value The value to convert. + * @returns {Array} Returns the converted array. + * @example + * + * _.toArray({ 'a': 1, 'b': 2 }); + * // => [1, 2] + * + * _.toArray('abc'); + * // => ['a', 'b', 'c'] + * + * _.toArray(1); + * // => [] + * + * _.toArray(null); + * // => [] + */ + function toArray( value ) { + if ( ! value ) { + return []; + } + 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 ); + } + + /** + * Converts `value` to a finite number. + * + * @static + * @memberOf _ + * @since 4.12.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {number} Returns the converted number. + * @example + * + * _.toFinite(3.2); + * // => 3.2 + * + * _.toFinite(Number.MIN_VALUE); + * // => 5e-324 + * + * _.toFinite(Infinity); + * // => 1.7976931348623157e+308 + * + * _.toFinite('3.2'); + * // => 3.2 + */ + 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; + } + + /** + * 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 _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {number} Returns the converted integer. + * @example + * + * _.toInteger(3.2); + * // => 3 + * + * _.toInteger(Number.MIN_VALUE); + * // => 0 + * + * _.toInteger(Infinity); + * // => 1.7976931348623157e+308 + * + * _.toInteger('3.2'); + * // => 3 + */ + function toInteger( value ) { + var result = toFinite( value ), + remainder = result % 1; + + return result === result ? ( remainder ? result - remainder : result ) : 0; + } + + /** + * 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 _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {number} Returns the converted integer. + * @example + * + * _.toLength(3.2); + * // => 3 + * + * _.toLength(Number.MIN_VALUE); + * // => 0 + * + * _.toLength(Infinity); + * // => 4294967295 + * + * _.toLength('3.2'); + * // => 3 + */ + function toLength( value ) { + return value ? baseClamp( toInteger( value ), 0, MAX_ARRAY_LENGTH ) : 0; + } + + /** + * Converts `value` to a number. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to process. + * @returns {number} Returns the number. + * @example + * + * _.toNumber(3.2); + * // => 3.2 + * + * _.toNumber(Number.MIN_VALUE); + * // => 5e-324 + * + * _.toNumber(Infinity); + * // => Infinity + * + * _.toNumber('3.2'); + * // => 3.2 + */ + function toNumber( value ) { + if ( typeof value == 'number' ) { + return value; + } + if ( isSymbol( value ) ) { + return NAN; + } + 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 = value.replace( reTrim, '' ); + var isBinary = reIsBinary.test( value ); + return isBinary || reIsOctal.test( value ) + ? freeParseInt( value.slice( 2 ), isBinary ? 2 : 8 ) + : reIsBadHex.test( value ) + ? NAN + : +value; + } + + /** + * Converts `value` to a plain object flattening inherited enumerable string + * keyed properties of `value` to own properties of the plain object. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {Object} Returns the converted plain object. + * @example + * + * function Foo() { + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.assign({ 'a': 1 }, new Foo); + * // => { 'a': 1, 'b': 2 } + * + * _.assign({ 'a': 1 }, _.toPlainObject(new Foo)); + * // => { 'a': 1, 'b': 2, 'c': 3 } + */ + function toPlainObject( value ) { + return copyObject( value, keysIn( value ) ); + } + + /** + * Converts `value` to a safe integer. A safe integer can be compared and + * represented correctly. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {number} Returns the converted integer. + * @example + * + * _.toSafeInteger(3.2); + * // => 3 + * + * _.toSafeInteger(Number.MIN_VALUE); + * // => 0 + * + * _.toSafeInteger(Infinity); + * // => 9007199254740991 + * + * _.toSafeInteger('3.2'); + * // => 3 + */ + function toSafeInteger( value ) { + return value + ? baseClamp( toInteger( value ), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER ) + : value === 0 + ? value + : 0; + } + + /** + * Converts `value` to a string. An empty string is returned for `null` + * and `undefined` values. The sign of `-0` is preserved. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {string} Returns the converted string. + * @example + * + * _.toString(null); + * // => '' + * + * _.toString(-0); + * // => '-0' + * + * _.toString([1, 2, 3]); + * // => '1,2,3' + */ + function toString( value ) { + return value == null ? '' : baseToString( value ); + } + + /*------------------------------------------------------------------------*/ + + /** + * 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 _ + * @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 + * + * function Foo() { + * this.a = 1; + * } + * + * function Bar() { + * this.c = 3; + * } + * + * Foo.prototype.b = 2; + * Bar.prototype.d = 4; + * + * _.assign({ 'a': 0 }, new Foo, new Bar); + * // => { 'a': 1, 'c': 3 } + */ + 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 ] ); + } + } + } ); + + /** + * This method is like `_.assign` except that it iterates over own and + * inherited source properties. + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @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 + * + * function Foo() { + * this.a = 1; + * } + * + * function Bar() { + * this.c = 3; + * } + * + * Foo.prototype.b = 2; + * Bar.prototype.d = 4; + * + * _.assignIn({ 'a': 0 }, new Foo, new Bar); + * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 } + */ + var assignIn = createAssigner( function( object, source ) { + copyObject( source, keysIn( source ), object ); + } ); + + /** + * 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 _ + * @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 + * + * function customizer(objValue, srcValue) { + * return _.isUndefined(objValue) ? srcValue : objValue; + * } + * + * var defaults = _.partialRight(_.assignInWith, customizer); + * + * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); + * // => { 'a': 1, 'b': 2 } + */ + var assignInWith = createAssigner( function( object, source, srcIndex, customizer ) { + copyObject( source, keysIn( source ), object, customizer ); + } ); + + /** + * 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:** This method mutates `object`. + * + * @static + * @memberOf _ + * @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 + * + * 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 } + */ + 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 ); + + /** + * 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 _ + * @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() { + * 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 == null ? result : baseAssign( result, properties ); + } + + /** + * 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 Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. + * @see _.defaultsDeep + * @example + * + * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); + * // => { 'a': 1, 'b': 2 } + */ + 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; + } ); + + /** + * This method is like `_.defaults` except that it recursively assigns + * default properties. + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @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 + * + * _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } }); + * // => { 'a': { 'b': 2, 'c': 3 } } + */ + var defaultsDeep = baseRest( function( args ) { + args.push( undefined, customDefaultsMerge ); + return apply( mergeWith, undefined, args ); + } ); + + /** + * 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 _ + * @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 + * + * 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 findKey( object, predicate ) { + return baseFindKey( object, getIteratee( predicate, 3 ), baseForOwn ); + } + + /** + * This method is like `_.findKey` except that it iterates over elements of + * a collection in the opposite order. + * + * @static + * @memberOf _ + * @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 + * + * var users = { + * 'barney': { 'age': 36, 'active': true }, + * 'fred': { 'age': 40, 'active': false }, + * 'pebbles': { 'age': 1, 'active': true } + * }; + * + * _.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 findLastKey( object, predicate ) { + return baseFindKey( object, getIteratee( predicate, 3 ), baseForOwnRight ); + } + + /** + * 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 _ + * @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 + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.forIn(new Foo, function(value, key) { + * console.log(key); + * }); + * // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed). + */ + function forIn( object, iteratee ) { + return object == null + ? object + : baseFor( object, getIteratee( iteratee, 3 ), keysIn ); + } + + /** + * This method is like `_.forIn` except that it iterates over properties of + * `object` in the opposite order. + * + * @static + * @memberOf _ + * @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 + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.forInRight(new Foo, function(value, key) { + * console.log(key); + * }); + * // => Logs 'c', 'b', then 'a' assuming `_.forIn` logs 'a', 'b', then 'c'. + */ + function forInRight( object, iteratee ) { + return object == null + ? object + : baseForRight( object, getIteratee( iteratee, 3 ), keysIn ); + } + + /** + * 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 _ + * @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 + * + * 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 forOwn( object, iteratee ) { + return object && baseForOwn( object, getIteratee( iteratee, 3 ) ); + } + + /** + * This method is like `_.forOwn` except that it iterates over properties of + * `object` in the opposite order. + * + * @static + * @memberOf _ + * @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 + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.forOwnRight(new Foo, function(value, key) { + * console.log(key); + * }); + * // => Logs 'b' then 'a' assuming `_.forOwn` logs 'a' then 'b'. + */ + function forOwnRight( object, iteratee ) { + return object && baseForOwnRight( object, getIteratee( iteratee, 3 ) ); + } + + /** + * Creates an array of function property names from own enumerable properties + * of `object`. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to inspect. + * @returns {Array} Returns the function names. + * @see _.functionsIn + * @example + * + * function Foo() { + * this.a = _.constant('a'); + * this.b = _.constant('b'); + * } + * + * Foo.prototype.c = _.constant('c'); + * + * _.functions(new Foo); + * // => ['a', 'b'] + */ + function functions( object ) { + return object == null ? [] : baseFunctions( object, keys( object ) ); + } + + /** + * Creates an array of function property names from own and inherited + * enumerable properties of `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The object to inspect. + * @returns {Array} Returns the function names. + * @see _.functions + * @example + * + * function Foo() { + * this.a = _.constant('a'); + * this.b = _.constant('b'); + * } + * + * Foo.prototype.c = _.constant('c'); + * + * _.functionsIn(new Foo); + * // => ['a', 'b', 'c'] + */ + function functionsIn( object ) { + return object == null ? [] : baseFunctions( object, keysIn( object ) ); + } + + /** + * Gets the value at `path` of `object`. If the resolved value is + * `undefined`, the `defaultValue` is returned in its place. + * + * @static + * @memberOf _ + * @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 + * + * var object = { 'a': [{ 'b': { 'c': 3 } }] }; + * + * _.get(object, 'a[0].b.c'); + * // => 3 + * + * _.get(object, ['a', '0', 'b', 'c']); + * // => 3 + * + * _.get(object, 'a.b.c', 'default'); + * // => 'default' + */ + function get( object, path, defaultValue ) { + var result = object == null ? undefined : baseGet( object, path ); + return result === undefined ? defaultValue : result; + } + + /** + * Checks if `path` is a direct property of `object`. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @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 + * + * 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 + * + * _.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 + * + * var object = _.create({ 'a': _.create({ 'b': 2 }) }); + * + * _.hasIn(object, 'a'); + * // => true + * + * _.hasIn(object, 'a.b'); + * // => true + * + * _.hasIn(object, ['a', 'b']); + * // => true + * + * _.hasIn(object, 'b'); + * // => false + */ + function hasIn( object, path ) { + return object != null && hasPath( object, path, baseHasIn ); + } + + /** + * 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 + * + * var object = { 'a': 1, 'b': 2, 'c': 1 }; + * + * _.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 _ + * @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 + * + * var object = { 'a': 1, 'b': 2, 'c': 1 }; + * + * _.invertBy(object); + * // => { '1': ['a', 'c'], '2': ['b'] } + * + * _.invertBy(object, function(value) { + * return 'group' + value; + * }); + * // => { 'group1': ['a', 'c'], 'group2': ['b'] } + */ + 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 ); + + /** + * Invokes the method at `path` of `object`. + * + * @static + * @memberOf _ + * @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 + * + * var object = { 'a': [{ 'b': { 'c': [1, 2, 3, 4] } }] }; + * + * _.invoke(object, 'a[0].b.c.slice', 1, 3); + * // => [2, 3] + */ + var invoke = baseRest( baseInvoke ); + + /** + * Creates an array of the own enumerable property names of `object`. + * + * **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 _ + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.keys(new Foo); + * // => ['a', 'b'] (iteration order is not guaranteed) + * + * _.keys('hi'); + * // => ['0', '1'] + */ + function keys( object ) { + return isArrayLike( object ) ? arrayLikeKeys( object ) : baseKeys( object ); + } + + /** + * Creates an array of the own and inherited enumerable property names of `object`. + * + * **Note:** Non-object values are coerced to objects. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.keysIn(new Foo); + * // => ['a', 'b', 'c'] (iteration order is not guaranteed) + */ + function keysIn( object ) { + return isArrayLike( object ) ? arrayLikeKeys( object, true ) : baseKeysIn( object ); + } + + /** + * 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 _ + * @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 + * + * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) { + * return key + value; + * }); + * // => { 'a1': 1, 'b2': 2 } + */ + 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; + } + + /** + * 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 _ + * @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 + * + * 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) + * + * // The `_.property` iteratee shorthand. + * _.mapValues(users, 'age'); + * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed) + */ + function mapValues( object, iteratee ) { + var result = {}; + iteratee = getIteratee( iteratee, 3 ); + + baseForOwn( object, function( value, key, object ) { + baseAssignValue( result, key, iteratee( value, key, object ) ); + } ); + return result; + } + + /** + * 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 _ + * @since 0.5.0 + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. + * @example + * + * 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 }] } + */ + var merge = createAssigner( function( object, source, srcIndex ) { + baseMerge( object, source, srcIndex ); + } ); + + /** + * 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). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @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 + * + * function customizer(objValue, srcValue) { + * if (_.isArray(objValue)) { + * return objValue.concat(srcValue); + * } + * } + * + * var object = { 'a': [1], 'b': [2] }; + * var other = { 'a': [3], 'b': [4] }; + * + * _.mergeWith(object, other, customizer); + * // => { 'a': [1, 3], 'b': [2, 4] } + */ + var mergeWith = createAssigner( function( object, source, srcIndex, customizer ) { + baseMerge( object, source, srcIndex, customizer ); + } ); + + /** + * The opposite of `_.pick`; this method creates an object composed of the + * own and inherited enumerable property paths of `object` that are not omitted. + * + * **Note:** This method is considerably slower than `_.pick`. + * + * @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 _ + * @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 object = { 'a': 1, 'b': '2', 'c': 3 }; + * + * _.omitBy(object, _.isNumber); + * // => { 'b': '2' } + */ + function omitBy( object, predicate ) { + return pickBy( object, negate( getIteratee( predicate ) ) ); + } + + /** + * Creates an object composed of the picked `object` properties. + * + * @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 + * + * var object = { 'a': 1, 'b': '2', 'c': 3 }; + * + * _.pick(object, ['a', 'c']); + * // => { 'a': 1, 'c': 3 } + */ + var pick = flatRest( function( object, paths ) { + return object == null ? {} : basePick( object, paths ); + } ); + + /** + * Creates an object composed of the `object` properties `predicate` returns + * truthy for. The predicate is invoked with two arguments: (value, key). + * + * @static + * @memberOf _ + * @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 object = { 'a': 1, 'b': '2', 'c': 3 }; + * + * _.pickBy(object, _.isNumber); + * // => { 'a': 1, 'c': 3 } + */ + 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 ] ); + } ); + } + + /** + * 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 _ + * @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 + * + * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] }; + * + * _.result(object, 'a[0].b.c1'); + * // => 3 + * + * _.result(object, 'a[0].b.c2'); + * // => 4 + * + * _.result(object, 'a[0].b.c3', 'default'); + * // => 'default' + * + * _.result(object, 'a[0].b.c3', _.constant('default')); + * // => 'default' + */ + function result( object, path, defaultValue ) { + path = castPath( path, object ); + + var index = -1, + length = path.length; + + // 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; + } + object = isFunction( value ) ? value.call( object ) : value; + } + return object; + } + + /** + * 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. + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @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 + * + * var object = { 'a': [{ 'b': { 'c': 3 } }] }; + * + * _.set(object, 'a[0].b.c', 4); + * console.log(object.a[0].b.c); + * // => 4 + * + * _.set(object, ['x', '0', 'y', 'z'], 5); + * console.log(object.x[0].y.z); + * // => 5 + */ + function set( object, path, value ) { + return object == null ? object : baseSet( object, path, value ); + } + + /** + * 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). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @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 + * + * var object = {}; + * + * _.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; + * } + * + * Foo.prototype.c = 3; + * + * _.toPairs(new Foo); + * // => [['a', 1], ['b', 2]] (iteration order is not guaranteed) + */ + var toPairs = createToPairs( keys ); + + /** + * 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 _ + * @since 4.0.0 + * @alias entriesIn + * @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; + * } + * + * Foo.prototype.c = 3; + * + * _.toPairsIn(new Foo); + * // => [['a', 1], ['b', 2], ['c', 3]] (iteration order is not guaranteed) + */ + var toPairsIn = createToPairs( keysIn ); + + /** + * 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 _ + * @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 + * + * _.transform([2, 3, 4], function(result, n) { + * result.push(n *= n); + * return n % 2 == 0; + * }, []); + * // => [4, 9] + * + * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) { + * (result[value] || (result[value] = [])).push(key); + * }, {}); + * // => { '1': ['a', 'c'], '2': ['b'] } + */ + function transform( object, iteratee, accumulator ) { + var isArr = isArray( object ), + isArrLike = isArr || isBuffer( object ) || isTypedArray( object ); + + iteratee = getIteratee( iteratee, 4 ); + if ( accumulator == null ) { + var Ctor = object && object.constructor; + if ( isArrLike ) { + accumulator = isArr ? new Ctor() : []; + } else if ( isObject( object ) ) { + accumulator = isFunction( Ctor ) ? baseCreate( getPrototype( object ) ) : {}; + } else { + accumulator = {}; + } + } + ( isArrLike ? arrayEach : baseForOwn )( object, function( value, index, object ) { + return iteratee( accumulator, value, index, object ); + } ); + return accumulator; + } + + /** + * Removes the property at `path` of `object`. + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @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 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 ); + } + + /** + * 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). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @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 object = { 'a': [{ 'b': { 'c': 3 } }] }; + * + * _.update(object, 'a[0].b.c', function(n) { return n * n; }); + * console.log(object.a[0].b.c); + * // => 9 + * + * _.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; }); + * console.log(object.x[0].y.z); + * // => 0 + */ + function update( object, path, updater ) { + return object == null ? object : baseUpdate( object, path, castFunction( updater ) ); + } + + /** + * 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 _ + * @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 + * + * var object = {}; + * + * _.updateWith(object, '[0][1]', _.constant('a'), Object); + * // => { '0': { '1': 'a' } } + */ + 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 the own enumerable string keyed property values of `object`. + * + * **Note:** Non-object values are coerced to objects. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property values. + * @example + * + * 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 values( object ) { + return object == null ? [] : baseValues( object, keys( object ) ); + } + + /** + * 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 _ + * @since 3.0.0 + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property values. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.valuesIn(new Foo); + * // => [1, 2, 3] (iteration order is not guaranteed) + */ + function valuesIn( object ) { + return object == null ? [] : baseValues( object, keysIn( object ) ); + } + + /*------------------------------------------------------------------------*/ + + /** + * 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 + * + * _.clamp(-10, -5, 5); + * // => -5 + * + * _.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 _ + * @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 + * + * _.inRange(3, 2, 4); + * // => true + * + * _.inRange(4, 8); + * // => true + * + * _.inRange(4, 2); + * // => false + * + * _.inRange(2, 2); + * // => false + * + * _.inRange(1.2, 2); + * // => true + * + * _.inRange(5.2, 4); + * // => false + * + * _.inRange(-3, -2, -6); + * // => true + */ + function inRange( number, start, end ) { + start = toFinite( start ); + if ( end === undefined ) { + end = start; + start = 0; + } else { + end = toFinite( end ); + } + number = toNumber( number ); + return baseInRange( number, start, end ); + } + + /** + * 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. + * + * **Note:** JavaScript follows the IEEE-754 standard for resolving + * floating-point values which can produce unexpected results. + * + * @static + * @memberOf _ + * @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 + * + * _.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( lower, upper, floating ) { + if ( + floating && + typeof floating != 'boolean' && + isIterateeCall( lower, upper, floating ) + ) { + upper = floating = undefined; + } + if ( floating === undefined ) { + if ( typeof upper == 'boolean' ) { + floating = upper; + upper = undefined; + } else if ( typeof lower == 'boolean' ) { + floating = lower; + lower = undefined; + } + } + if ( lower === undefined && upper === undefined ) { + lower = 0; + upper = 1; + } else { + lower = toFinite( lower ); + if ( upper === undefined ) { + upper = lower; + lower = 0; + } else { + upper = toFinite( upper ); + } + } + 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 ); + } + + /*------------------------------------------------------------------------*/ + + /** + * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the camel cased string. + * @example + * + * _.camelCase('Foo Bar'); + * // => 'fooBar' + * + * _.camelCase('--foo-bar--'); + * // => 'fooBar' + * + * _.camelCase('__FOO_BAR__'); + * // => 'fooBar' + */ + var camelCase = createCompounder( function( result, word, index ) { + word = word.toLowerCase(); + return result + ( index ? capitalize( word ) : word ); + } ); + + /** + * Converts the first character of `string` to upper case and the remaining + * to lower case. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to capitalize. + * @returns {string} Returns the capitalized string. + * @example + * + * _.capitalize('FRED'); + * // => 'Fred' + */ + function capitalize( string ) { + return upperFirst( toString( string ).toLowerCase() ); + } + + /** + * 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 _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to deburr. + * @returns {string} Returns the deburred string. + * @example + * + * _.deburr('déjà vu'); + * // => 'deja vu' + */ + function deburr( string ) { + string = toString( string ); + return string && string.replace( reLatin, deburrLetter ).replace( reComboMark, '' ); + } + + /** + * Checks if `string` ends with the given target string. + * + * @static + * @memberOf _ + * @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 + * + * _.endsWith('abc', 'c'); + * // => true + * + * _.endsWith('abc', 'b'); + * // => false + * + * _.endsWith('abc', 'b', 2); + * // => true + */ + 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; + } + + /** + * Converts the characters "&", "<", ">", '"', and "'" in `string` to their + * corresponding HTML entities. + * + * **Note:** No other characters are escaped. To escape additional + * characters use a third-party library like [_he_](https://mths.be/he). + * + * 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. + * + * 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 _ + * @category String + * @param {string} [string=''] The string to escape. + * @returns {string} Returns the escaped string. + * @example + * + * _.escape('fred, barney, & pebbles'); + * // => 'fred, barney, & pebbles' + */ + function escape( string ) { + string = toString( string ); + return string && reHasUnescapedHtml.test( string ) + ? string.replace( reUnescapedHtml, escapeHtmlChar ) + : string; + } + + /** + * Escapes the `RegExp` special characters "^", "$", "\", ".", "*", "+", + * "?", "(", ")", "[", "]", "{", "}", and "|" in `string`. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to escape. + * @returns {string} Returns the escaped string. + * @example + * + * _.escapeRegExp('[lodash](https://lodash.com/)'); + * // => '\[lodash\]\(https://lodash\.com/\)' + */ + function escapeRegExp( string ) { + string = toString( string ); + return string && reHasRegExpChar.test( string ) + ? string.replace( reRegExpChar, '\\$&' ) + : string; + } + + /** + * Converts `string` to + * [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the kebab cased string. + * @example + * + * _.kebabCase('Foo Bar'); + * // => 'foo-bar' + * + * _.kebabCase('fooBar'); + * // => 'foo-bar' + * + * _.kebabCase('__FOO_BAR__'); + * // => 'foo-bar' + */ + var kebabCase = createCompounder( function( result, word, index ) { + return result + ( index ? '-' : '' ) + word.toLowerCase(); + } ); + + /** + * Converts `string`, as space separated words, to lower case. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the lower cased string. + * @example + * + * _.lowerCase('--Foo-Bar--'); + * // => 'foo bar' + * + * _.lowerCase('fooBar'); + * // => 'foo bar' + * + * _.lowerCase('__FOO_BAR__'); + * // => 'foo bar' + */ + var lowerCase = createCompounder( function( result, word, index ) { + return result + ( index ? ' ' : '' ) + word.toLowerCase(); + } ); + + /** + * Converts the first character of `string` to lower case. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the converted string. + * @example + * + * _.lowerFirst('Fred'); + * // => 'fred' + * + * _.lowerFirst('FRED'); + * // => 'fRED' + */ + var lowerFirst = createCaseFirst( 'toLowerCase' ); + + /** + * 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 _ + * @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 + * + * _.pad('abc', 8); + * // => ' abc ' + * + * _.pad('abc', 8, '_-'); + * // => '_-abc_-_' + * + * _.pad('abc', 3); + * // => 'abc' + */ + function pad( string, length, chars ) { + string = toString( string ); + length = toInteger( length ); + + var strLength = length ? stringSize( string ) : 0; + if ( ! length || strLength >= length ) { + return string; + } + var mid = ( length - strLength ) / 2; + return ( + createPadding( nativeFloor( mid ), chars ) + + string + + createPadding( nativeCeil( mid ), chars ) + ); + } + + /** + * Pads `string` on the right side if it's shorter than `length`. Padding + * characters are truncated if they exceed `length`. + * + * @static + * @memberOf _ + * @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 + * + * _.padEnd('abc', 6); + * // => 'abc ' + * + * _.padEnd('abc', 6, '_-'); + * // => 'abc_-_' + * + * _.padEnd('abc', 3); + * // => 'abc' + */ + 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; + } + + /** + * Pads `string` on the left side if it's shorter than `length`. Padding + * characters are truncated if they exceed `length`. + * + * @static + * @memberOf _ + * @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 + * + * _.padStart('abc', 6); + * // => ' abc' + * + * _.padStart('abc', 6, '_-'); + * // => '_-_abc' + * + * _.padStart('abc', 3); + * // => 'abc' + */ + 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; + } + + /** + * 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 _ + * @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 + * + * _.parseInt('08'); + * // => 8 + * + * _.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. + * + * @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 + * + * _.repeat('*', 3); + * // => '***' + * + * _.repeat('abc', 2); + * // => 'abcabc' + * + * _.repeat('abc', 0); + * // => '' + */ + function repeat( string, n, guard ) { + if ( guard ? isIterateeCall( string, n, guard ) : n === undefined ) { + n = 1; + } else { + n = toInteger( n ); + } + return baseRepeat( toString( string ), n ); + } + + /** + * Replaces matches for `pattern` in `string` with `replacement`. + * + * **Note:** This method is based on + * [`String#replace`](https://mdn.io/String/replace). + * + * @static + * @memberOf _ + * @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 + * + * _.replace('Hi Fred', 'Fred', 'Barney'); + * // => 'Hi Barney' + */ + function replace() { + var args = arguments, + string = toString( args[ 0 ] ); + + return args.length < 3 ? string : string.replace( args[ 1 ], args[ 2 ] ); + } + + /** + * Converts `string` to + * [snake case](https://en.wikipedia.org/wiki/Snake_case). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the snake cased string. + * @example + * + * _.snakeCase('Foo Bar'); + * // => 'foo_bar' + * + * _.snakeCase('fooBar'); + * // => 'foo_bar' + * + * _.snakeCase('--FOO-BAR--'); + * // => 'foo_bar' + */ + var snakeCase = createCompounder( function( result, word, index ) { + return result + ( index ? '_' : '' ) + word.toLowerCase(); + } ); + + /** + * Splits `string` by `separator`. + * + * **Note:** This method is based on + * [`String#split`](https://mdn.io/String/split). + * + * @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 + * + * _.split('a-b-c', '-', 2); + * // => ['a', 'b'] + */ + 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 ); + } + } + return string.split( separator, limit ); + } + + /** + * Converts `string` to + * [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage). + * + * @static + * @memberOf _ + * @since 3.1.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the start cased string. + * @example + * + * _.startCase('--foo-bar--'); + * // => 'Foo Bar' + * + * _.startCase('fooBar'); + * // => 'Foo Bar' + * + * _.startCase('__FOO_BAR__'); + * // => 'FOO BAR' + */ + var startCase = createCompounder( function( result, word, index ) { + return result + ( index ? ' ' : '' ) + upperFirst( word ); + } ); + + /** + * Checks if `string` starts with the given target string. + * + * @static + * @memberOf _ + * @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 + * + * _.startsWith('abc', 'a'); + * // => true + * + * _.startsWith('abc', 'b'); + * // => false + * + * _.startsWith('abc', 'b', 1); + * // => 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 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. + * + * For more information on precompiling templates see + * [lodash's custom builds documentation](https://lodash.com/custom-builds). + * + * For more information on Chrome extension sandboxes see + * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval). + * + * @static + * @since 0.1.0 + * @memberOf _ + * @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 + * + * // Use the "interpolate" delimiter to create a compiled template. + * var compiled = _.template('hello <%= user %>!'); + * compiled({ 'user': 'fred' }); + * // => 'hello fred!' + * + * // Use the HTML "escape" delimiter to escape data property values. + * var compiled = _.template('<%- value %>'); + * compiled({ 'value': '