Repository: cssinjs/jss
Branch: master
Commit: 901882a894c7
Files: 530
Total size: 7.2 MB
Directory structure:
gitextract__rapluzz/
├── .bithoundrc
├── .eslintignore
├── .eslintrc.js
├── .flowconfig
├── .gitattributes
├── .github/
│ ├── CODEOWNERS
│ ├── FUNDING.yml
│ ├── ISSUE_TEMPLATE/
│ │ ├── ---bug-report.md
│ │ └── ---feature-request.md
│ └── PULL_REQUEST_TEMPLATE.md
├── .gitignore
├── .nvmrc
├── .prettierignore
├── .prettierrc
├── .travis.yml
├── .yarn/
│ └── releases/
│ └── yarn-1.15.2.js
├── .yarnrc
├── CODE_OF_CONDUCT.md
├── LICENSE
├── babelOptions.js
├── browsers.json
├── changelog.md
├── contributing.md
├── docs/
│ ├── articles.md
│ ├── cdn.md
│ ├── csp.md
│ ├── environment-requirements.md
│ ├── examples.md
│ ├── faq.md
│ ├── features.md
│ ├── intro.md
│ ├── jss-api.md
│ ├── jss-plugin-cache.md
│ ├── jss-plugin-camel-case.md
│ ├── jss-plugin-compose.md
│ ├── jss-plugin-default-unit.md
│ ├── jss-plugin-expand.md
│ ├── jss-plugin-extend.md
│ ├── jss-plugin-global.md
│ ├── jss-plugin-isolate.md
│ ├── jss-plugin-nested.md
│ ├── jss-plugin-props-sort.md
│ ├── jss-plugin-rule-value-function.md
│ ├── jss-plugin-rule-value-observable.md
│ ├── jss-plugin-template.md
│ ├── jss-plugin-vendor-prefixer.md
│ ├── jss-preset-default.md
│ ├── jss-syntax.md
│ ├── migrations.md
│ ├── performance.md
│ ├── plugins.md
│ ├── projects.md
│ ├── react-jss-hoc.md
│ ├── react-jss-ts.md
│ ├── react-jss.md
│ ├── setup.md
│ ├── ssr.md
│ └── users.md
├── examples/
│ ├── angular/
│ │ ├── app.js
│ │ ├── index.html
│ │ └── package.json
│ ├── angular5/
│ │ ├── app/
│ │ │ ├── app.component.ts
│ │ │ ├── app.module.ts
│ │ │ └── main.ts
│ │ ├── index.html
│ │ └── package.json
│ ├── bootstrap/
│ │ ├── app.js
│ │ ├── bootstrap-theme.js
│ │ ├── bootstrap.js
│ │ ├── index.html
│ │ └── package.json
│ ├── calendar/
│ │ ├── components/
│ │ │ ├── calendar/
│ │ │ │ ├── index.js
│ │ │ │ └── style.js
│ │ │ ├── canvas/
│ │ │ │ ├── index.js
│ │ │ │ └── style.js
│ │ │ ├── conf/
│ │ │ │ └── index.js
│ │ │ ├── event/
│ │ │ │ ├── content-tpl.js
│ │ │ │ ├── index.js
│ │ │ │ └── style.js
│ │ │ ├── events-manager/
│ │ │ │ ├── distribute.js
│ │ │ │ └── index.js
│ │ │ ├── jss.js
│ │ │ ├── timeline/
│ │ │ │ ├── index.js
│ │ │ │ ├── marker-tpl.js
│ │ │ │ └── style.js
│ │ │ └── utils/
│ │ │ └── index.js
│ │ ├── index.html
│ │ ├── index.js
│ │ └── package.json
│ ├── composition/
│ │ ├── app.js
│ │ ├── component-a-style.js
│ │ ├── component-b-style.js
│ │ ├── index.html
│ │ └── package.json
│ ├── dynamic-props/
│ │ ├── app.js
│ │ ├── index.html
│ │ └── package.json
│ ├── function-values/
│ │ ├── .babelrc
│ │ ├── Controls.js
│ │ ├── JssAnimation.js
│ │ ├── ReactAnimation.js
│ │ ├── app.js
│ │ ├── index.html
│ │ ├── index.js
│ │ ├── jssRenderer.js
│ │ ├── package.json
│ │ ├── reactInlineRenderer.js
│ │ ├── reactJssRenderer.js
│ │ └── utils.js
│ ├── inline/
│ │ ├── app.js
│ │ ├── index.html
│ │ └── package.json
│ ├── observables/
│ │ ├── index.html
│ │ ├── index.js
│ │ └── package.json
│ ├── perdido/
│ │ ├── app.js
│ │ ├── index.html
│ │ ├── package.json
│ │ └── styles.js
│ ├── plugins/
│ │ ├── jss-plugin-camel-case/
│ │ │ ├── app.js
│ │ │ ├── index.html
│ │ │ └── package.json
│ │ ├── jss-plugin-compose/
│ │ │ ├── app.js
│ │ │ ├── index.html
│ │ │ └── package.json
│ │ ├── jss-plugin-default-unit/
│ │ │ ├── app.js
│ │ │ ├── index.html
│ │ │ └── package.json
│ │ ├── jss-plugin-expand/
│ │ │ ├── app.js
│ │ │ ├── index.html
│ │ │ └── package.json
│ │ ├── jss-plugin-extend/
│ │ │ ├── app.js
│ │ │ ├── index.html
│ │ │ └── package.json
│ │ ├── jss-plugin-global/
│ │ │ ├── app.js
│ │ │ ├── index.html
│ │ │ └── package.json
│ │ ├── jss-plugin-isolate/
│ │ │ ├── app.js
│ │ │ ├── index.html
│ │ │ └── package.json
│ │ ├── jss-plugin-nested/
│ │ │ ├── app.js
│ │ │ ├── index.html
│ │ │ └── package.json
│ │ ├── jss-plugin-props-sort/
│ │ │ ├── app.js
│ │ │ ├── index.html
│ │ │ └── package.json
│ │ ├── jss-plugin-rule-value-function/
│ │ │ ├── app.js
│ │ │ ├── index.html
│ │ │ └── package.json
│ │ ├── jss-plugin-rule-value-observable/
│ │ │ ├── app.js
│ │ │ ├── index.html
│ │ │ └── package.json
│ │ ├── jss-plugin-template/
│ │ │ ├── app.js
│ │ │ ├── index.html
│ │ │ └── package.json
│ │ └── jss-plugin-vendor-prefixer/
│ │ ├── app.js
│ │ ├── index.html
│ │ └── package.json
│ ├── react-ssr/
│ │ ├── client.js
│ │ ├── package.json
│ │ ├── sandbox.config.json
│ │ ├── server.js
│ │ ├── src/
│ │ │ └── Button.js
│ │ ├── ssr.js
│ │ └── static/
│ │ └── client.js
│ ├── swinging-cat/
│ │ ├── index.html
│ │ ├── index.js
│ │ ├── package.json
│ │ └── src/
│ │ ├── ear.js
│ │ ├── face.js
│ │ ├── globalStyles.js
│ │ ├── hand.js
│ │ ├── jss.js
│ │ ├── keyframes.js
│ │ ├── leg.js
│ │ ├── lowerBody.js
│ │ ├── scene.js
│ │ ├── tail.js
│ │ ├── theme.js
│ │ ├── upperBody.js
│ │ └── yarn.js
│ └── swinging-cat-rx/
│ ├── index.html
│ ├── index.js
│ ├── package.json
│ └── src/
│ ├── animation.js
│ ├── ear.js
│ ├── face.js
│ ├── globalStyles.js
│ ├── hand.js
│ ├── jss.js
│ ├── leg.js
│ ├── lowerBody.js
│ ├── scene.js
│ ├── tail.js
│ ├── theme.js
│ ├── upperBody.js
│ └── yarn.js
├── flow-typed/
│ ├── css.js
│ └── mocha.js
├── karma.conf.js
├── lerna.json
├── package.json
├── packages/
│ ├── css-jss/
│ │ ├── .size-snapshot.json
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── readme.md
│ │ └── src/
│ │ ├── createCss.js
│ │ ├── createCss.js.flow
│ │ ├── createCss.test.js
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── index.js.flow
│ │ ├── index.test.js
│ │ └── types.js.flow
│ ├── jss/
│ │ ├── .size-snapshot.json
│ │ ├── LICENSE
│ │ ├── benchmark/
│ │ │ ├── fixtures/
│ │ │ │ ├── bootstrap.json
│ │ │ │ ├── conditional.json
│ │ │ │ └── regular.json
│ │ │ └── tests/
│ │ │ ├── add-rule.js
│ │ │ ├── batching.js
│ │ │ ├── bootstrap.js
│ │ │ ├── cloning.js
│ │ │ ├── conditional-regular.js
│ │ │ ├── create-instance.js
│ │ │ ├── is-object.js
│ │ │ ├── linked-sheet.js
│ │ │ ├── render-rule.js
│ │ │ ├── to-css-value.js
│ │ │ └── update.js
│ │ ├── package.json
│ │ ├── readme.md
│ │ ├── src/
│ │ │ ├── DomRenderer.js
│ │ │ ├── Jss.js
│ │ │ ├── Jss.js.flow
│ │ │ ├── PluginsRegistry.js
│ │ │ ├── PluginsRegistry.js.flow
│ │ │ ├── RuleList.js
│ │ │ ├── RuleList.js.flow
│ │ │ ├── SheetsManager.js
│ │ │ ├── SheetsManager.js.flow
│ │ │ ├── SheetsRegistry.js
│ │ │ ├── SheetsRegistry.js.flow
│ │ │ ├── StyleSheet.js
│ │ │ ├── StyleSheet.js.flow
│ │ │ ├── flow-types/
│ │ │ │ ├── cssom.js
│ │ │ │ ├── dom.js
│ │ │ │ ├── index.js
│ │ │ │ └── jss.js
│ │ │ ├── index.d.ts
│ │ │ ├── index.js
│ │ │ ├── index.js.flow
│ │ │ ├── plugins/
│ │ │ │ ├── conditionalRule.js
│ │ │ │ ├── conditionalRule.js.flow
│ │ │ │ ├── fontFaceRule.js
│ │ │ │ ├── fontFaceRule.js.flow
│ │ │ │ ├── index.js
│ │ │ │ ├── index.js.flow
│ │ │ │ ├── keyframeRule.js
│ │ │ │ ├── keyframeRule.js.flow
│ │ │ │ ├── keyframesRule.js
│ │ │ │ ├── keyframesRule.js.flow
│ │ │ │ ├── simpleRule.js
│ │ │ │ ├── simpleRule.js.flow
│ │ │ │ ├── styleRule.js
│ │ │ │ ├── styleRule.js.flow
│ │ │ │ ├── viewportRule.js
│ │ │ │ └── viewportRule.js.flow
│ │ │ ├── sheets.js
│ │ │ └── utils/
│ │ │ ├── cloneStyle.js
│ │ │ ├── cloneStyle.js.flow
│ │ │ ├── createGenerateId.js
│ │ │ ├── createGenerateId.js.flow
│ │ │ ├── createJss.js
│ │ │ ├── createJss.js.flow
│ │ │ ├── createRule.js
│ │ │ ├── createRule.js.flow
│ │ │ ├── escape.js
│ │ │ ├── escape.js.flow
│ │ │ ├── getDynamicStyles.js
│ │ │ ├── getDynamicStyles.js.flow
│ │ │ ├── getWhitespaceSymbols.js
│ │ │ ├── globalThis.js
│ │ │ ├── hasCSSTOMSupport.js
│ │ │ ├── hasCSSTOMSupport.js.flow
│ │ │ ├── moduleId.js
│ │ │ ├── moduleId.js.flow
│ │ │ ├── toCss.js
│ │ │ ├── toCss.js.flow
│ │ │ ├── toCssValue.js
│ │ │ └── toCssValue.js.flow
│ │ └── tests/
│ │ ├── functional/
│ │ │ ├── houdini.js
│ │ │ ├── priority.js
│ │ │ ├── rules.js
│ │ │ └── sheet.js
│ │ ├── integration/
│ │ │ ├── houdini.js
│ │ │ ├── plugins.js
│ │ │ ├── rules.js
│ │ │ ├── sheet.js
│ │ │ └── sheetsRegistry.js
│ │ ├── jss-tests.ts
│ │ ├── types/
│ │ │ └── Styles.ts
│ │ └── unit/
│ │ ├── Jss.js
│ │ ├── SheetsManager.js
│ │ ├── cloneStyle.js
│ │ ├── createGenerateId.js
│ │ ├── escape.js
│ │ ├── getDynamicStyles.js
│ │ └── plugins.js
│ ├── jss-plugin-cache/
│ │ ├── .size-snapshot.json
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── readme.md
│ │ └── src/
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── index.js.flow
│ │ └── index.test.js
│ ├── jss-plugin-camel-case/
│ │ ├── .size-snapshot.json
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── readme.md
│ │ └── src/
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── index.js.flow
│ │ └── index.test.js
│ ├── jss-plugin-compose/
│ │ ├── .size-snapshot.json
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── readme.md
│ │ └── src/
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── index.js.flow
│ │ └── index.test.js
│ ├── jss-plugin-default-unit/
│ │ ├── .size-snapshot.json
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── readme.md
│ │ └── src/
│ │ ├── defaultUnits.js
│ │ ├── defaultUnits.js.flow
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── index.js.flow
│ │ └── index.test.js
│ ├── jss-plugin-expand/
│ │ ├── .size-snapshot.json
│ │ ├── LICENSE
│ │ ├── benchmark/
│ │ │ ├── fixtures/
│ │ │ │ ├── arrays-with-plugin.json
│ │ │ │ ├── arrays-without-plugin.json
│ │ │ │ ├── bootstrap.json
│ │ │ │ ├── sheet-with-plugin.json
│ │ │ │ └── sheet-without-plugin.json
│ │ │ └── integration/
│ │ │ ├── arrays.js
│ │ │ ├── bootstrap.js
│ │ │ └── sheet.js
│ │ ├── package.json
│ │ ├── readme.md
│ │ └── src/
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── index.js.flow
│ │ ├── index.test.js
│ │ └── props.js
│ ├── jss-plugin-extend/
│ │ ├── .size-snapshot.json
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── readme.md
│ │ └── src/
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── index.js.flow
│ │ └── index.test.js
│ ├── jss-plugin-global/
│ │ ├── .size-snapshot.json
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── readme.md
│ │ └── src/
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── index.js.flow
│ │ └── index.test.js
│ ├── jss-plugin-isolate/
│ │ ├── .size-snapshot.json
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── readme.md
│ │ └── src/
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── index.js.flow
│ │ └── index.test.js
│ ├── jss-plugin-nested/
│ │ ├── .size-snapshot.json
│ │ ├── LICENSE
│ │ ├── benchmark/
│ │ │ ├── fixtures/
│ │ │ │ └── modified-bootstrap.json
│ │ │ └── tests/
│ │ │ ├── bootstrap.js
│ │ │ └── deep-nesting.js
│ │ ├── package.json
│ │ ├── readme.md
│ │ └── src/
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── index.js.flow
│ │ └── index.test.js
│ ├── jss-plugin-props-sort/
│ │ ├── .size-snapshot.json
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── readme.md
│ │ └── src/
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── index.js.flow
│ │ └── index.test.js
│ ├── jss-plugin-rule-value-function/
│ │ ├── .size-snapshot.json
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── readme.md
│ │ └── src/
│ │ ├── function-rules.test.js
│ │ ├── function-values.test.js
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── index.js.flow
│ │ ├── index.test.js
│ │ ├── plugin-compose.test.js
│ │ ├── plugin-expand.test.js
│ │ ├── plugin-global.test.js
│ │ └── plugin-nested.test.js
│ ├── jss-plugin-rule-value-observable/
│ │ ├── .size-snapshot.json
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── readme.md
│ │ └── src/
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── index.js.flow
│ │ ├── index.test.js
│ │ ├── observable-rules.test.js
│ │ └── observable-values.test.js
│ ├── jss-plugin-template/
│ │ ├── .size-snapshot.json
│ │ ├── LICENSE
│ │ ├── benchmark/
│ │ │ └── tests/
│ │ │ ├── createSheet.js
│ │ │ └── parse.js
│ │ ├── package.json
│ │ ├── readme.md
│ │ └── src/
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── index.js.flow
│ │ ├── index.test.js
│ │ └── parse.js
│ ├── jss-plugin-vendor-prefixer/
│ │ ├── .size-snapshot.json
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── readme.md
│ │ └── src/
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── index.js.flow
│ │ └── index.test.js
│ ├── jss-preset-default/
│ │ ├── .size-snapshot.json
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── readme.md
│ │ └── src/
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ └── index.js.flow
│ ├── jss-starter-kit/
│ │ ├── .size-snapshot.json
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── readme.md
│ │ └── src/
│ │ └── index.js
│ └── react-jss/
│ ├── .size-snapshot.json
│ ├── LICENSE
│ ├── package.json
│ ├── readme.md
│ ├── src/
│ │ ├── JssContext.js
│ │ ├── JssContext.js.flow
│ │ ├── JssProvider.js
│ │ ├── JssProvider.js.flow
│ │ ├── JssProvider.test.js
│ │ ├── createUseStyles.js
│ │ ├── createUseStyles.js.flow
│ │ ├── createUseStyles.test.js
│ │ ├── flow-types.js
│ │ ├── getDisplayName.js
│ │ ├── getDisplayName.js.flow
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── index.js.flow
│ │ ├── index.test.js
│ │ ├── index.test.tsx
│ │ ├── jss.js
│ │ ├── jss.js.flow
│ │ ├── jsx.js
│ │ ├── jsx.js.flow
│ │ ├── jsx.test.js
│ │ ├── styled-props-filter.test.js
│ │ ├── styled.js
│ │ ├── styled.js.flow
│ │ ├── styled.test.js
│ │ ├── utils/
│ │ │ ├── getSheetClasses.js
│ │ │ ├── getSheetClasses.js.flow
│ │ │ ├── getSheetIndex.js
│ │ │ ├── getSheetIndex.js.flow
│ │ │ ├── managers.js
│ │ │ ├── managers.js.flow
│ │ │ ├── memoizeOne.js
│ │ │ ├── memoizeOne.js.flow
│ │ │ ├── mergeClasses.js
│ │ │ ├── mergeClasses.js.flow
│ │ │ ├── mergeClasses.test.js
│ │ │ ├── sheets.js
│ │ │ ├── sheets.js.flow
│ │ │ ├── sheetsMeta.js
│ │ │ └── sheetsMeta.js.flow
│ │ ├── withStyles.js
│ │ ├── withStyles.js.flow
│ │ └── withStyles.test.js
│ ├── test-utils/
│ │ ├── createCommonBaseTests.js
│ │ └── createCommonDynamicStylesTests.js
│ └── tests/
│ ├── dynamicStyles.js
│ ├── styledSystem.js
│ ├── types/
│ │ ├── createUseStyles.ts
│ │ ├── docs.tsx
│ │ └── withStyles.tsx
│ ├── useStylesTheming.js
│ └── withStylesTheming.js
├── polyfills.js
├── readme.md
├── rollup.config.js
├── scripts/
│ ├── add-git-files.js
│ ├── build.js
│ ├── constants.js
│ ├── create-github-release.js
│ ├── create-readme.js
│ ├── get-package-json.js
│ ├── match-snapshot.js
│ └── update-changelog.js
├── sponsors.md
├── tests/
│ ├── setup.js
│ └── utils.js
├── tsconfig.json
└── webpack.config.js
================================================
FILE CONTENTS
================================================
================================================
FILE: .bithoundrc
================================================
{
"ignore": [
"benchmark/**",
"docs/**",
"dist/**",
"test/**",
"node_modules/**"
],
"tests": [
"/tests"
]
}
================================================
FILE: .eslintignore
================================================
flow-typed/
**/node_modules/**
packages/**/dist/
examples/**/static/
*.ts
*.tsx
================================================
FILE: .eslintrc.js
================================================
module.exports = {
extends: ['jss', 'prettier', 'prettier/react'],
parser: 'babel-eslint',
env: {
mocha: true,
browser: true
},
globals: {
benchmark: true,
__VERSION__: true,
CSS: true
},
overrides: [
{
files: ['docs/*.md', 'docs/**/*.md'],
rules: {
'no-console': 'off'
}
},
{
files: ['examples/**/*.js'],
rules: {
'import/no-unresolved': 'off',
'react/prop-types': 'off',
'no-console': 'off',
'import/extensions': 'off',
'import/prefer-default-export': 'off',
'jsx-a11y/label-has-for': 'off',
'jsx-a11y/label-has-associated-control': 'off'
}
}
]
}
================================================
FILE: .flowconfig
================================================
[ignore]
[include]
[libs]
[options]
include_warnings=true
================================================
FILE: .gitattributes
================================================
package-lock.json binary
================================================
FILE: .github/CODEOWNERS
================================================
* @kof
================================================
FILE: .github/FUNDING.yml
================================================
# These are supported funding model platforms
open_collective: jss
================================================
FILE: .github/ISSUE_TEMPLATE/---bug-report.md
================================================
---
name: "\U0001F41B Bug report"
about: "If something isn't working as expected \U0001F914."
---
__Expected behavior:__
A clear and concise description of what you expected to happen.
__Describe the bug:__
A clear and concise description of what happened instead of the expected behavior.
__Reproduction:__
Add a failing test to the suite and submit a PR. A test is even better than a fix.
Alternatively create a [codesandbox.io](https://codesandbox.io/) with the issue. Make it as minimal as possible as this will help us find the bug quicker.
__Versions (please complete the following information):__
- jss:
- Browser [e.g. chrome, safari]:
- OS [e.g. Windows, macOS]:
Feel free to add any additional versions which you may think are relevant to the bug.
__Managing expectations:__
Maintainers will not be fixing the problem you have unless they have it too, if you want it to get fixed:
1. Submit a PR with a failing test
2. Discuss a solution
3. Implement it
You can also do the first step only and wait for someone else to work on a fix. Anything is much better than nothing.
================================================
FILE: .github/ISSUE_TEMPLATE/---feature-request.md
================================================
---
name: "\U0001F680 Feature request"
about: "I have a suggestion (and may want to implement it \U0001F642)!"
---
__Is your feature request related to a problem? Please describe.__
__Describe the solution you'd like__
A clear and concise description of what you want to happen.
__Are you willing to implement it?__
Yes/No
__Managing expectations:__
Maintainers will not be implementing something they don't need, so if you want a feature, you will have to:
1. Explain the problem in a way that makes sense to everyone
2. Discuss a solution
3. Implement it
You can also do the first step only and wait for someone else to work on the implementation. Anything is much better than nothing.
================================================
FILE: .github/PULL_REQUEST_TEMPLATE.md
================================================
## Corresponding Issue(s):
## What Would You Like to Add/Fix?
## Todo
- [ ] Add test(s) that verify the modified behavior
- [ ] Add documentation if it changes public API
## Expectations on Changes
## Changelog
================================================
FILE: .gitignore
================================================
node_modules
.DS_Store
npm-debug.log
tmp
*~
dist
.env
coverage
lerna-debug.log
yarn-error.log
.idea
.vscode
================================================
FILE: .nvmrc
================================================
10
================================================
FILE: .prettierignore
================================================
node_modules/
coverage/
dist/
tmp/
*.html
# npm install does it's own formatting, which can conflict with prettier
package.json
!packages/**/package.json
================================================
FILE: .prettierrc
================================================
{
"semi": false,
"singleQuote": true,
"trailingComma": "none",
"bracketSpacing": false,
"printWidth": 100
}
================================================
FILE: .travis.yml
================================================
language: node_js
node_js:
- '10'
branches:
only:
- master
sudo: required
before_install:
- npm i yarn@latest -g
cache:
yarn: true
after_success:
- bash <(curl -s https://codecov.io/bash)
script:
- yarn format:ci
- yarn check:snapshots
- yarn build
- yarn check:all
- yarn test
env:
global:
secure: IaLnA8heZU8OMLiA8REbZeF1F5uXJE5XmX7L0cmtNYtHNDs+p4ufVOOGbrfZW2fDEbDpXryT3lTNsFLPPmHT0sdwH/eNeO+VNvqcJW4kHe6UReVU6fObsdEvGbX4V8V08x7V4rbJjHgERq9e8O0DDp32ykxuu1XbUlb01NEu1Qg=
================================================
FILE: .yarn/releases/yarn-1.15.2.js
================================================
#!/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 = 517))
/******/
})(
/************************************************************************/
/******/ [
/* 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__(217)
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) {
module.exports = require('fs')
/***/
},
/* 5 */
/***/ 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
/***/
},
/* 6 */
/***/ 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__(4)))
}
var _glob
function _load_glob() {
return (_glob = _interopRequireDefault(__webpack_require__(93)))
}
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__(103)))
}
var _promise
function _load_promise() {
return (_promise = _interopRequireWildcard(__webpack_require__(47)))
}
var _promise2
function _load_promise2() {
return (_promise2 = __webpack_require__(47))
}
var _map
function _load_map() {
return (_map = _interopRequireDefault(__webpack_require__(28)))
}
var _fsNormalized
function _load_fsNormalized() {
return (_fsNormalized = __webpack_require__(208))
}
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__(136)
))
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__(8)
const stripBOM = __webpack_require__(151)
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)
/***/
},
/* 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__(
145
)
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__Observer__ = __webpack_require__(388)
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__Subscription__ = __webpack_require__(24)
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__internal_symbol_rxSubscriber__ = __webpack_require__(
288
)
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__config__ = __webpack_require__(176)
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__util_hostReportError__ = __webpack_require__(
290
)
/** 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'
/**
* 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
/***/
},
/* 9 */
/***/ 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__(60).default
var _require = __webpack_require__(215)
const getCacheDir = _require.getCacheDir,
getConfigDir = _require.getConfigDir,
getDataDir = _require.getDataDir
const isWebpackBundle = __webpack_require__(267)
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 = 4)
// 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'
})
/***/
},
/* 10 */
/***/ 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__(
289
)
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__util_toSubscriber__ = __webpack_require__(
901
)
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__internal_symbol_observable__ = __webpack_require__(
109
)
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__util_pipe__ = __webpack_require__(291)
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__config__ = __webpack_require__(176)
/** 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
/***/
},
/* 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 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
/***/
},
/* 13 */
/***/ 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__(
77
)
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__subscribeTo__ = __webpack_require__(414)
/** 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
/***/
},
/* 14 */
/***/ function(module, exports, __webpack_require__) {
'use strict'
/* eslint-disable node/no-deprecated-api */
var buffer = __webpack_require__(80)
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
/***/
},
/* 15 */
/***/ function(module, exports, __webpack_require__) {
// Copyright (c) 2012, Mark Cavage. All rights reserved.
// Copyright 2015 Joyent, Inc.
var assert = __webpack_require__(27)
var Stream = __webpack_require__(22).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)
/***/
},
/* 16 */
/***/ 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
/***/
},
/* 17 */
/***/ 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__(220)
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)
})
}
/***/
},
/* 18 */
/***/ 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__(98))
}
Object.defineProperty(exports, 'parse', {
enumerable: true,
get: function get() {
return _interopRequireDefault(_parse || _load_parse()).default
}
})
var _stringify
function _load_stringify() {
return (_stringify = __webpack_require__(190))
}
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__(17))
}
var _normalizePattern
function _load_normalizePattern() {
return (_normalizePattern = __webpack_require__(36))
}
var _parse2
function _load_parse2() {
return (_parse2 = _interopRequireDefault(__webpack_require__(98)))
}
var _constants
function _load_constants() {
return (_constants = __webpack_require__(9))
}
var _fs
function _load_fs() {
return (_fs = _interopRequireWildcard(__webpack_require__(6)))
}
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__(8)
const path = __webpack_require__(0)
const ssri = __webpack_require__(70)
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'))
}
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
/***/
},
/* 19 */
/***/ function(module, exports, __webpack_require__) {
var store = __webpack_require__(126)('wks')
var uid = __webpack_require__(130)
var Symbol = __webpack_require__(16).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
/***/
},
/* 20 */
/***/ 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'))
}
/***/
},
/* 21 */
/***/ function(module, exports, __webpack_require__) {
'use strict'
exports.__esModule = true
var _assign = __webpack_require__(560)
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) {
module.exports = require('stream')
/***/
},
/* 23 */
/***/ function(module, exports) {
module.exports = require('url')
/***/
},
/* 24 */
/***/ 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__(40)
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__util_isObject__ = __webpack_require__(
412
)
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__util_isFunction__ = __webpack_require__(
145
)
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__util_tryCatch__ = __webpack_require__(
51
)
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__util_errorObject__ = __webpack_require__(
44
)
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__util_UnsubscriptionError__ = __webpack_require__(
409
)
/** 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
/***/
},
/* 25 */
/***/ 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__(15)
var Buffer = __webpack_require__(14).Buffer
var PrivateKey = __webpack_require__(32)
var Key = __webpack_require__(26)
var crypto = __webpack_require__(11)
var algs = __webpack_require__(31)
var asn1 = __webpack_require__(59)
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__(74).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__(68)
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__(68)
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__(74).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__(132)
if (jsbn === undefined) jsbn = __webpack_require__(74).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
}
/***/
},
/* 26 */
/***/ function(module, exports, __webpack_require__) {
// Copyright 2017 Joyent, Inc.
module.exports = Key
var assert = __webpack_require__(15)
var algs = __webpack_require__(31)
var crypto = __webpack_require__(11)
var Fingerprint = __webpack_require__(147)
var Signature = __webpack_require__(67)
var DiffieHellman = __webpack_require__(292).DiffieHellman
var errs = __webpack_require__(66)
var utils = __webpack_require__(25)
var PrivateKey = __webpack_require__(32)
var edCompat
try {
edCompat = __webpack_require__(422)
} 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__(423)
formats['pem'] = __webpack_require__(79)
formats['pkcs1'] = __webpack_require__(294)
formats['pkcs8'] = __webpack_require__(148)
formats['rfc4253'] = __webpack_require__(96)
formats['ssh'] = __webpack_require__(424)
formats['ssh-private'] = __webpack_require__(183)
formats['openssh'] = formats['ssh-private']
formats['dnssec'] = __webpack_require__(293)
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]
}
/***/
},
/* 27 */
/***/ function(module, exports) {
module.exports = require('assert')
/***/
},
/* 28 */
/***/ 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
}
/***/
},
/* 29 */
/***/ function(module, exports, __webpack_require__) {
'use strict'
const escapeStringRegexp = __webpack_require__(355)
const ansiStyles = __webpack_require__(474)
const stdoutColor = __webpack_require__(567).stdout
const template = __webpack_require__(568)
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
/***/
},
/* 30 */
/***/ function(module, exports) {
var core = (module.exports = {version: '2.5.7'})
if (typeof __e == 'number') __e = core // eslint-disable-line no-undef
/***/
},
/* 31 */
/***/ function(module, exports, __webpack_require__) {
// Copyright 2015 Joyent, Inc.
var Buffer = __webpack_require__(14).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
}
/***/
},
/* 32 */
/***/ function(module, exports, __webpack_require__) {
// Copyright 2017 Joyent, Inc.
module.exports = PrivateKey
var assert = __webpack_require__(15)
var Buffer = __webpack_require__(14).Buffer
var algs = __webpack_require__(31)
var crypto = __webpack_require__(11)
var Fingerprint = __webpack_require__(147)
var Signature = __webpack_require__(67)
var errs = __webpack_require__(66)
var util = __webpack_require__(3)
var utils = __webpack_require__(25)
var dhe = __webpack_require__(292)
var generateECDSA = dhe.generateECDSA
var generateED25519 = dhe.generateED25519
var edCompat
var nacl
try {
edCompat = __webpack_require__(422)
} catch (e) {
/* Just continue through, and bail out if we try to use it. */
}
var Key = __webpack_require__(26)
var InvalidAlgorithmError = errs.InvalidAlgorithmError
var KeyParseError = errs.KeyParseError
var KeyEncryptedError = errs.KeyEncryptedError
var formats = {}
formats['auto'] = __webpack_require__(423)
formats['pem'] = __webpack_require__(79)
formats['pkcs1'] = __webpack_require__(294)
formats['pkcs8'] = __webpack_require__(148)
formats['rfc4253'] = __webpack_require__(96)
formats['ssh-private'] = __webpack_require__(183)
formats['openssh'] = formats['ssh-private']
formats['ssh'] = formats['ssh-private']
formats['dnssec'] = __webpack_require__(293)
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__(68)
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__(68)
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]
}
/***/
},
/* 33 */
/***/ 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 _hooks
function _load_hooks() {
return (_hooks = __webpack_require__(550))
}
var _index
function _load_index() {
return (_index = _interopRequireDefault(__webpack_require__(210)))
}
var _errors
function _load_errors() {
return (_errors = __webpack_require__(5))
}
var _integrityChecker
function _load_integrityChecker() {
return (_integrityChecker = _interopRequireDefault(__webpack_require__(199)))
}
var _lockfile
function _load_lockfile() {
return (_lockfile = _interopRequireDefault(__webpack_require__(18)))
}
var _lockfile2
function _load_lockfile2() {
return (_lockfile2 = __webpack_require__(18))
}
var _packageFetcher
function _load_packageFetcher() {
return (_packageFetcher = _interopRequireWildcard(__webpack_require__(200)))
}
var _packageInstallScripts
function _load_packageInstallScripts() {
return (_packageInstallScripts = _interopRequireDefault(__webpack_require__(525)))
}
var _packageCompatibility
function _load_packageCompatibility() {
return (_packageCompatibility = _interopRequireWildcard(__webpack_require__(332)))
}
var _packageResolver
function _load_packageResolver() {
return (_packageResolver = _interopRequireDefault(__webpack_require__(334)))
}
var _packageLinker
function _load_packageLinker() {
return (_packageLinker = _interopRequireDefault(__webpack_require__(201)))
}
var _index2
function _load_index2() {
return (_index2 = __webpack_require__(52))
}
var _index3
function _load_index3() {
return (_index3 = __webpack_require__(71))
}
var _autoclean
function _load_autoclean() {
return (_autoclean = __webpack_require__(321))
}
var _constants
function _load_constants() {
return (_constants = _interopRequireWildcard(__webpack_require__(9)))
}
var _normalizePattern
function _load_normalizePattern() {
return (_normalizePattern = __webpack_require__(36))
}
var _fs
function _load_fs() {
return (_fs = _interopRequireWildcard(__webpack_require__(6)))
}
var _map
function _load_map() {
return (_map = _interopRequireDefault(__webpack_require__(28)))
}
var _yarnVersion
function _load_yarnVersion() {
return (_yarnVersion = __webpack_require__(112))
}
var _generatePnpMap
function _load_generatePnpMap() {
return (_generatePnpMap = __webpack_require__(547))
}
var _workspaceLayout
function _load_workspaceLayout() {
return (_workspaceLayout = _interopRequireDefault(__webpack_require__(84)))
}
var _resolutionMap
function _load_resolutionMap() {
return (_resolutionMap = _interopRequireDefault(__webpack_require__(204)))
}
var _guessName
function _load_guessName() {
return (_guessName = _interopRequireDefault(__webpack_require__(160)))
}
var _audit
function _load_audit() {
return (_audit = _interopRequireDefault(__webpack_require__(320)))
}
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__(600)
const emoji = __webpack_require__(270)
const invariant = __webpack_require__(8)
const path = __webpack_require__(0)
const semver = __webpack_require__(20)
const uuid = __webpack_require__(111)
const ssri = __webpack_require__(70)
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'
}
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
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: false, 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'))
}
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)
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(
(0, (_extends2 || _load_extends()).default)({_reference: {}}, 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')
}
/***/
},
/* 34 */
/***/ function(module, exports, __webpack_require__) {
var isObject = __webpack_require__(49)
module.exports = function(it) {
if (!isObject(it)) throw TypeError(it + ' is not an object!')
return it
}
/***/
},
/* 35 */
/***/ 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__(10)
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__Subscriber__ = __webpack_require__(7)
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__Subscription__ = __webpack_require__(24)
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__util_ObjectUnsubscribedError__ = __webpack_require__(
180
)
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__SubjectSubscription__ = __webpack_require__(
390
)
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__internal_symbol_rxSubscriber__ = __webpack_require__(
288
)
/** 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
/***/
},
/* 36 */
/***/ 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}
}
/***/
},
/* 37 */
/***/ 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': '