Full Code of cssinjs/jss for AI

master 901882a894c7 cached
530 files
7.2 MB
1.9M tokens
5179 symbols
1 requests
Download .txt
Showing preview only (7,612K chars total). Download the full file or copy to clipboard to get everything.
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): <!-- (if relevant) -->

## 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

<!--
1. Please don't do code changes and move code around in the same PR, even if you are making code better. Make sure the reviewer can see just the changes which fix the problem. This can make your Code Review much more accessible in complex situations; otherwise, it might never get merged even if it is correct because it's impossible to review without reimplementing every change.
2. Often, submitting a failing test is more critical than the fix. Fixing the problem can be challenging and has many ways. Offering an excellent failing test is often 80% of the solution.
3. Please review your PR before submitting it as if you are the reviewer. This way, you show respect for the maintainer's time.
-->

## Changelog

<!--
Please summarize the changes in a way that makes sense inside the changelog. Feel free to add migration tips or examples if necessary.
-->


================================================
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.
Download .txt
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
Download .txt
Showing preview only (367K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (5179 symbols across 95 files)

FILE: .yarn/releases/yarn-1.15.2.js
  function __webpack_require__ (line 7) | function __webpack_require__(moduleId) {
  function __extends (line 138) | function __extends(d, b) {
  function __rest (line 159) | function __rest(s, e) {
  function __decorate (line 169) | function __decorate(decorators, target, key, desc) {
  function __param (line 187) | function __param(paramIndex, decorator) {
  function __metadata (line 193) | function __metadata(metadataKey, metadataValue) {
  function __awaiter (line 198) | function __awaiter(thisArg, _arguments, P, generator) {
  function __generator (line 225) | function __generator(thisArg, body) {
  function __exportStar (line 324) | function __exportStar(m, exports) {
  function __values (line 328) | function __values(o) {
  function __read (line 340) | function __read(o, n) {
  function __spread (line 361) | function __spread() {
  function __await (line 366) | function __await(v) {
  function __asyncGenerator (line 370) | function __asyncGenerator(thisArg, _arguments, generator) {
  function __asyncDelegator (line 416) | function __asyncDelegator(o) {
  function __asyncValues (line 439) | function __asyncValues(o) {
  function __makeTemplateObject (line 470) | function __makeTemplateObject(cooked, raw) {
  function __importStar (line 479) | function __importStar(mod) {
  function __importDefault (line 488) | function __importDefault(mod) {
  function _interopRequireDefault (line 504) | function _interopRequireDefault(obj) {
  function step (line 512) | function step(key, arg) {
  class MessageError (line 561) | class MessageError extends Error {
    method constructor (line 562) | constructor(msg, code) {
  class ProcessSpawnError (line 569) | class ProcessSpawnError extends MessageError {
    method constructor (line 570) | constructor(msg, code, process) {
  class SecurityError (line 577) | class SecurityError extends MessageError {}
  class ProcessTermError (line 580) | class ProcessTermError extends MessageError {}
  class ResponseError (line 583) | class ResponseError extends Error {
    method constructor (line 584) | constructor(msg, responseCode) {
  class OneTimePasswordError (line 591) | class OneTimePasswordError extends Error {}
  function _load_asyncToGenerator (line 607) | function _load_asyncToGenerator() {
  function onDone (line 842) | function onDone() {
  function onDone (line 1186) | function onDone() {
  function _load_fs (line 1859) | function _load_fs() {
  function _load_glob (line 1865) | function _load_glob() {
  function _load_os (line 1871) | function _load_os() {
  function _load_path (line 1877) | function _load_path() {
  function _load_blockingQueue (line 1883) | function _load_blockingQueue() {
  function _load_promise (line 1889) | function _load_promise() {
  function _load_promise2 (line 1895) | function _load_promise2() {
  function _load_map (line 1901) | function _load_map() {
  function _load_fsNormalized (line 1907) | function _load_fsNormalized() {
  function _interopRequireWildcard (line 1911) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 1926) | function _interopRequireDefault(obj) {
  function copy (line 2004) | function copy(src, dest, reporter) {
  function _readFile (line 2008) | function _readFile(loc, encoding) {
  function readFile (line 2020) | function readFile(loc) {
  function readFileRaw (line 2024) | function readFileRaw(loc) {
  function normalizeOS (line 2028) | function normalizeOS(body) {
  function Subscriber (line 2061) | function Subscriber(destinationOrNext, error, complete) {
  function SafeSubscriber (line 2159) | function SafeSubscriber(_parentSubscriber, observerOrNext, error, comple...
  function getPreferredCacheDirectories (line 2443) | function getPreferredCacheDirectories() {
  function getYarnBinPath (line 2472) | function getYarnBinPath() {
  function getPathKey (line 2505) | function getPathKey(platform, env) {
  function Observable (line 2556) | function Observable(subscribe) {
  function getPromiseCtor (line 2686) | function getPromiseCtor(promiseCtor) {
  function OuterSubscriber (line 2717) | function OuterSubscriber() {
  function subscribeToResult (line 2752) | function subscribeToResult(outerSubscriber, result, outerValue, outerInd...
  function _capitalize (line 2873) | function _capitalize(str) {
  function _toss (line 2877) | function _toss(name, expected, oper, arg, actual) {
  function _getClass (line 2887) | function _getClass(arg) {
  function noop (line 2891) | function noop() {
  function _setExports (line 2969) | function _setExports(ndebug) {
  function sortAlpha (line 3119) | function sortAlpha(a, b) {
  function sortOptionsByFlags (line 3132) | function sortOptionsByFlags(a, b) {
  function entries (line 3138) | function entries(obj) {
  function removePrefix (line 3148) | function removePrefix(pattern, prefix) {
  function removeSuffix (line 3156) | function removeSuffix(pattern, suffix) {
  function addSuffix (line 3164) | function addSuffix(pattern, suffix) {
  function hyphenate (line 3172) | function hyphenate(str) {
  function camelCase (line 3178) | function camelCase(str) {
  function compareSortedArrays (line 3186) | function compareSortedArrays(array1, array2) {
  function sleep (line 3198) | function sleep(ms) {
  function _load_asyncToGenerator (line 3217) | function _load_asyncToGenerator() {
  function _load_parse (line 3223) | function _load_parse() {
  function _load_stringify (line 3236) | function _load_stringify() {
  function _load_misc (line 3251) | function _load_misc() {
  function _load_normalizePattern (line 3257) | function _load_normalizePattern() {
  function _load_parse2 (line 3263) | function _load_parse2() {
  function _load_constants (line 3269) | function _load_constants() {
  function _load_fs (line 3275) | function _load_fs() {
  function _interopRequireWildcard (line 3279) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 3294) | function _interopRequireDefault(obj) {
  function getName (line 3303) | function getName(pattern) {
  function blankObjectUndefined (line 3307) | function blankObjectUndefined(obj) {
  function keyForRemote (line 3311) | function keyForRemote(remote) {
  function serializeIntegrity (line 3318) | function serializeIntegrity(integrity) {
  function implodeEntry (line 3328) | function implodeEntry(pattern, obj) {
  function explodeEntry (line 3348) | function explodeEntry(pattern, obj) {
  class Lockfile (line 3362) | class Lockfile {
    method constructor (line 3363) | constructor({cache, source, parseResultType} = {}) {
    method hasEntriesExistWithoutIntegrity (line 3372) | hasEntriesExistWithoutIntegrity() {
    method fromDirectory (line 3387) | static fromDirectory(dir, reporter) {
    method getLocked (line 3421) | getLocked(pattern) {
    method removePattern (line 3439) | removePattern(pattern) {
    method getLockfile (line 3447) | getLockfile(patterns) {
  function parse (line 3833) | function parse(version, loose) {
  function valid (line 3851) | function valid(version, loose) {
  function clean (line 3857) | function clean(version, loose) {
  function SemVer (line 3864) | function SemVer(version, loose) {
  function inc (line 4055) | function inc(version, release, loose, identifier) {
  function diff (line 4069) | function diff(version1, version2) {
  function compareIdentifiers (line 4098) | function compareIdentifiers(a, b) {
  function rcompareIdentifiers (line 4111) | function rcompareIdentifiers(a, b) {
  function major (line 4116) | function major(a, loose) {
  function minor (line 4121) | function minor(a, loose) {
  function patch (line 4126) | function patch(a, loose) {
  function compare (line 4131) | function compare(a, b, loose) {
  function compareLoose (line 4136) | function compareLoose(a, b) {
  function rcompare (line 4141) | function rcompare(a, b, loose) {
  function sort (line 4146) | function sort(list, loose) {
  function rsort (line 4153) | function rsort(list, loose) {
  function gt (line 4160) | function gt(a, b, loose) {
  function lt (line 4165) | function lt(a, b, loose) {
  function eq (line 4170) | function eq(a, b, loose) {
  function neq (line 4175) | function neq(a, b, loose) {
  function gte (line 4180) | function gte(a, b, loose) {
  function lte (line 4185) | function lte(a, b, loose) {
  function cmp (line 4190) | function cmp(a, op, b, loose) {
  function Comparator (line 4230) | function Comparator(comp, loose) {
  function Range (line 4321) | function Range(range, loose) {
  function toComparators (line 4434) | function toComparators(range, loose) {
  function parseComparator (line 4449) | function parseComparator(comp, loose) {
  function isX (line 4462) | function isX(id) {
  function replaceTildes (line 4472) | function replaceTildes(comp, loose) {
  function replaceTilde (line 4482) | function replaceTilde(comp, loose) {
  function replaceCarets (line 4512) | function replaceCarets(comp, loose) {
  function replaceCaret (line 4522) | function replaceCaret(comp, loose) {
  function replaceXRanges (line 4556) | function replaceXRanges(comp, loose) {
  function replaceXRange (line 4566) | function replaceXRange(comp, loose) {
  function replaceStars (line 4627) | function replaceStars(comp, loose) {
  function hyphenReplace (line 4638) | function hyphenReplace($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tp...
  function testSet (line 4665) | function testSet(set, version) {
  function satisfies (line 4699) | function satisfies(version, range, loose) {
  function maxSatisfying (line 4709) | function maxSatisfying(versions, range, loose) {
  function minSatisfying (line 4731) | function minSatisfying(versions, range, loose) {
  function validRange (line 4753) | function validRange(range, loose) {
  function ltr (line 4765) | function ltr(version, range, loose) {
  function gtr (line 4771) | function gtr(version, range, loose) {
  function outside (line 4776) | function outside(version, range, hilo, loose) {
  function prerelease (line 4845) | function prerelease(version, loose) {
  function intersects (line 4851) | function intersects(r1, r2, loose) {
  function coerce (line 4858) | function coerce(version) {
  function _interopRequireDefault (line 4882) | function _interopRequireDefault(obj) {
  function Subscription (line 4941) | function Subscription(unsubscribe) {
  function flattenUnsubscriptionErrors (line 5098) | function flattenUnsubscriptionErrors(errors) {
  function isCompatible (line 5149) | function isCompatible(obj, klass, needVer) {
  function assertCompatible (line 5166) | function assertCompatible(obj, klass, needVer, name) {
  function opensslKeyDeriv (line 5207) | function opensslKeyDeriv(cipher, salt, passphrase, count) {
  function countZeros (line 5241) | function countZeros(buf) {
  function bufferSplit (line 5256) | function bufferSplit(buf, chr) {
  function ecNormalize (line 5280) | function ecNormalize(buf, addZero) {
  function readBitString (line 5300) | function readBitString(der, tag) {
  function writeBitString (line 5311) | function writeBitString(der, buf, tag) {
  function mpNormalize (line 5319) | function mpNormalize(buf) {
  function mpDenormalize (line 5331) | function mpDenormalize(buf) {
  function zeroPadToLength (line 5337) | function zeroPadToLength(buf, len) {
  function bigintToMpBuf (line 5353) | function bigintToMpBuf(bigint) {
  function calculateDSAPublic (line 5359) | function calculateDSAPublic(g, p, x) {
  function calculateED25519Public (line 5378) | function calculateED25519Public(k) {
  function calculateX25519Public (line 5387) | function calculateX25519Public(k) {
  function addRSAMissing (line 5396) | function addRSAMissing(key) {
  function publicFromPrivateECDSA (line 5428) | function publicFromPrivateECDSA(curveName, priv) {
  function opensshCipherInfo (line 5452) | function opensshCipherInfo(cipher) {
  function Key (line 5531) | function Key(opts) {
  function nullify (line 5757) | function nullify(obj = {}) {
  function applyOptions (line 5819) | function applyOptions(obj, options) {
  function Chalk (line 5828) | function Chalk(options) {
  method get (line 5860) | get() {
  method get (line 5873) | get() {
  method get (line 5885) | get() {
  method get (line 5913) | get() {
  function build (line 5935) | function build(_styles, _empty, key) {
  function applyStyle (line 5975) | function applyStyle() {
  function chalkTag (line 6022) | function chalkTag(chalk, strings) {
  function PrivateKey (line 6331) | function PrivateKey(opts) {
  function _load_extends (line 6534) | function _load_extends() {
  function _load_asyncToGenerator (line 6540) | function _load_asyncToGenerator() {
  function _load_hooks (line 6652) | function _load_hooks() {
  function _load_index (line 6658) | function _load_index() {
  function _load_errors (line 6664) | function _load_errors() {
  function _load_integrityChecker (line 6670) | function _load_integrityChecker() {
  function _load_lockfile (line 6676) | function _load_lockfile() {
  function _load_lockfile2 (line 6682) | function _load_lockfile2() {
  function _load_packageFetcher (line 6688) | function _load_packageFetcher() {
  function _load_packageInstallScripts (line 6694) | function _load_packageInstallScripts() {
  function _load_packageCompatibility (line 6700) | function _load_packageCompatibility() {
  function _load_packageResolver (line 6706) | function _load_packageResolver() {
  function _load_packageLinker (line 6712) | function _load_packageLinker() {
  function _load_index2 (line 6718) | function _load_index2() {
  function _load_index3 (line 6724) | function _load_index3() {
  function _load_autoclean (line 6730) | function _load_autoclean() {
  function _load_constants (line 6736) | function _load_constants() {
  function _load_normalizePattern (line 6742) | function _load_normalizePattern() {
  function _load_fs (line 6748) | function _load_fs() {
  function _load_map (line 6754) | function _load_map() {
  function _load_yarnVersion (line 6760) | function _load_yarnVersion() {
  function _load_generatePnpMap (line 6766) | function _load_generatePnpMap() {
  function _load_workspaceLayout (line 6772) | function _load_workspaceLayout() {
  function _load_resolutionMap (line 6778) | function _load_resolutionMap() {
  function _load_guessName (line 6784) | function _load_guessName() {
  function _load_audit (line 6790) | function _load_audit() {
  function _interopRequireWildcard (line 6794) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 6809) | function _interopRequireDefault(obj) {
  function getUpdateCommand (line 6828) | function getUpdateCommand(installationMethod) {
  function getUpdateInstaller (line 6862) | function getUpdateInstaller(installationMethod) {
  function normalizeFlags (line 6871) | function normalizeFlags(config, rawFlags) {
  class Install (line 6928) | class Install {
    method constructor (line 6929) | constructor(flags, config, reporter, lockfile) {
    method fetchRequestFromCwd (line 6958) | fetchRequestFromCwd(excludePatterns = [], ignoreUnusedPatterns = false) {
    method prepareRequests (line 7395) | prepareRequests(requests) {
    method preparePatterns (line 7399) | preparePatterns(patterns) {
    method preparePatternsForLinking (line 7402) | preparePatternsForLinking(patterns, cwdManifest, cwdIsRoot) {
    method prepareManifests (line 7406) | prepareManifests() {
    method bailout (line 7415) | bailout(patterns, workspaceLayout) {
    method createEmptyManifestFolders (line 7492) | createEmptyManifestFolders() {
    method markIgnored (line 7532) | markIgnored(patterns) {
    method getFlattenedDeps (line 7568) | getFlattenedDeps() {
    method init (line 7593) | init() {
    method checkCompatibility (line 7946) | checkCompatibility() {
    method persistChanges (line 7962) | persistChanges() {
    method applyChanges (line 7975) | applyChanges(manifests) {
    method shouldClean (line 8008) | shouldClean() {
    method flatten (line 8018) | flatten(patterns) {
    method pruneOfflineMirror (line 8163) | pruneOfflineMirror(lockfile) {
    method saveLockfileAndIntegrity (line 8220) | saveLockfileAndIntegrity(patterns, workspaceLayout) {
    method _logSuccessSaveLockfile (line 8330) | _logSuccessSaveLockfile() {
    method hydrate (line 8337) | hydrate(ignoreUnusedPatterns) {
    method checkUpdate (line 8417) | checkUpdate() {
    method _checkUpdate (line 8444) | _checkUpdate() {
    method maybeOutputUpdate (line 8493) | maybeOutputUpdate() {}
  function hasWrapper (line 8497) | function hasWrapper(commander, args) {
  function setFlags (line 8501) | function setFlags(commander) {
  function SubjectSubscriber (line 8556) | function SubjectSubscriber(destination) {
  function Subject (line 8566) | function Subject() {
  function AnonymousSubject (line 8677) | function AnonymousSubject(destination, source) {
  function normalizePattern (line 8729) | function normalizePattern(pattern) {
  function apply (line 9444) | function apply(func, thisArg, args) {
  function arrayAggregator (line 9468) | function arrayAggregator(array, setter, iteratee, accumulator) {
  function arrayEach (line 9488) | function arrayEach(array, iteratee) {
  function arrayEachRight (line 9509) | function arrayEachRight(array, iteratee) {
  function arrayEvery (line 9530) | function arrayEvery(array, predicate) {
  function arrayFilter (line 9551) | function arrayFilter(array, predicate) {
  function arrayIncludes (line 9575) | function arrayIncludes(array, value) {
  function arrayIncludesWith (line 9589) | function arrayIncludesWith(array, value, comparator) {
  function arrayMap (line 9610) | function arrayMap(array, iteratee) {
  function arrayPush (line 9629) | function arrayPush(array, values) {
  function arrayReduce (line 9652) | function arrayReduce(array, iteratee, accumulator, initAccum) {
  function arrayReduceRight (line 9677) | function arrayReduceRight(array, iteratee, accumulator, initAccum) {
  function arraySome (line 9698) | function arraySome(array, predicate) {
  function asciiToArray (line 9726) | function asciiToArray(string) {
  function asciiWords (line 9737) | function asciiWords(string) {
  function baseFindKey (line 9752) | function baseFindKey(collection, predicate, eachFunc) {
  function baseFindIndex (line 9774) | function baseFindIndex(array, predicate, fromIndex, fromRight) {
  function baseIndexOf (line 9795) | function baseIndexOf(array, value, fromIndex) {
  function baseIndexOfWith (line 9811) | function baseIndexOfWith(array, value, fromIndex, comparator) {
  function baseIsNaN (line 9830) | function baseIsNaN(value) {
  function baseMean (line 9843) | function baseMean(array, iteratee) {
  function baseProperty (line 9855) | function baseProperty(key) {
  function basePropertyOf (line 9868) | function basePropertyOf(object) {
  function baseReduce (line 9887) | function baseReduce(collection, iteratee, accumulator, initAccum, eachFu...
  function baseSortBy (line 9906) | function baseSortBy(array, comparer) {
  function baseSum (line 9925) | function baseSum(array, iteratee) {
  function baseTimes (line 9948) | function baseTimes(n, iteratee) {
  function baseToPairs (line 9967) | function baseToPairs(object, props) {
  function baseUnary (line 9980) | function baseUnary(func) {
  function baseValues (line 9996) | function baseValues(object, props) {
  function cacheHas (line 10010) | function cacheHas(cache, key) {
  function charsStartIndex (line 10023) | function charsStartIndex(strSymbols, chrSymbols) {
  function charsEndIndex (line 10040) | function charsEndIndex(strSymbols, chrSymbols) {
  function countHolders (line 10055) | function countHolders(array, placeholder) {
  function escapeStringChar (line 10093) | function escapeStringChar(chr) {
  function getValue (line 10105) | function getValue(object, key) {
  function hasUnicode (line 10116) | function hasUnicode(string) {
  function hasUnicodeWord (line 10127) | function hasUnicodeWord(string) {
  function iteratorToArray (line 10138) | function iteratorToArray(iterator) {
  function mapToArray (line 10155) | function mapToArray(map) {
  function overArg (line 10173) | function overArg(func, transform) {
  function replaceHolders (line 10188) | function replaceHolders(array, placeholder) {
  function safeGet (line 10212) | function safeGet(object, key) {
  function setToArray (line 10223) | function setToArray(set) {
  function setToPairs (line 10240) | function setToPairs(set) {
  function strictIndexOf (line 10260) | function strictIndexOf(array, value, fromIndex) {
  function strictLastIndexOf (line 10282) | function strictLastIndexOf(array, value, fromIndex) {
  function stringSize (line 10299) | function stringSize(string) {
  function stringToArray (line 10310) | function stringToArray(string) {
  function unicodeSize (line 10330) | function unicodeSize(string) {
  function unicodeToArray (line 10345) | function unicodeToArray(string) {
  function unicodeWords (line 10356) | function unicodeWords(string) {
  function lodash (line 10643) | function lodash(value) {
  function object (line 10664) | function object() {}
  function baseLodash (line 10684) | function baseLodash() {
  function LodashWrapper (line 10695) | function LodashWrapper(value, chainAll) {
  function LazyWrapper (line 10778) | function LazyWrapper(value) {
  function lazyClone (line 10796) | function lazyClone() {
  function lazyReverse (line 10815) | function lazyReverse() {
  function lazyValue (line 10835) | function lazyValue() {
  function Hash (line 10896) | function Hash(entries) {
    method isHash (line 31946) | get isHash() {
    method constructor (line 31949) | constructor(hash, opts) {
    method hexDigest (line 31967) | hexDigest() {
    method toJSON (line 31970) | toJSON() {
    method toString (line 31973) | toString(opts) {
  function hashClear (line 10914) | function hashClear() {
  function hashDelete (line 10929) | function hashDelete(key) {
  function hashGet (line 10944) | function hashGet(key) {
  function hashHas (line 10962) | function hashHas(key) {
  function hashSet (line 10977) | function hashSet(key, value) {
  function ListCache (line 11000) | function ListCache(entries) {
  function listCacheClear (line 11018) | function listCacheClear() {
  function listCacheDelete (line 11032) | function listCacheDelete(key) {
  function listCacheGet (line 11058) | function listCacheGet(key) {
  function listCacheHas (line 11074) | function listCacheHas(key) {
  function listCacheSet (line 11088) | function listCacheSet(key, value) {
  function MapCache (line 11117) | function MapCache(entries) {
  function mapCacheClear (line 11135) | function mapCacheClear() {
  function mapCacheDelete (line 11153) | function mapCacheDelete(key) {
  function mapCacheGet (line 11168) | function mapCacheGet(key) {
  function mapCacheHas (line 11181) | function mapCacheHas(key) {
  function mapCacheSet (line 11195) | function mapCacheSet(key, value) {
  function SetCache (line 11221) | function SetCache(values) {
  function setCacheAdd (line 11241) | function setCacheAdd(value) {
  function setCacheHas (line 11255) | function setCacheHas(value) {
  function Stack (line 11272) | function Stack(entries) {
  function stackClear (line 11284) | function stackClear() {
  function stackDelete (line 11298) | function stackDelete(key) {
  function stackGet (line 11315) | function stackGet(key) {
  function stackHas (line 11328) | function stackHas(key) {
  function stackSet (line 11342) | function stackSet(key, value) {
  function arrayLikeKeys (line 11375) | function arrayLikeKeys(value, inherited) {
  function arraySample (line 11412) | function arraySample(array) {
  function arraySampleSize (line 11425) | function arraySampleSize(array, n) {
  function arrayShuffle (line 11436) | function arrayShuffle(array) {
  function assignMergeValue (line 11449) | function assignMergeValue(object, key, value) {
  function assignValue (line 11468) | function assignValue(object, key, value) {
  function assocIndexOf (line 11486) | function assocIndexOf(array, key) {
  function baseAggregator (line 11507) | function baseAggregator(collection, setter, iteratee, accumulator) {
  function baseAssign (line 11523) | function baseAssign(object, source) {
  function baseAssignIn (line 11536) | function baseAssignIn(object, source) {
  function baseAssignValue (line 11549) | function baseAssignValue(object, key, value) {
  function baseAt (line 11570) | function baseAt(object, paths) {
  function baseClamp (line 11591) | function baseClamp(number, lower, upper) {
  function baseClone (line 11619) | function baseClone(value, bitmask, customizer, key, object, stack) {
  function baseConforms (line 11710) | function baseConforms(source) {
  function baseConformsTo (line 11725) | function baseConformsTo(object, source, props) {
  function baseDelay (line 11753) | function baseDelay(func, wait, args) {
  function baseDifference (line 11773) | function baseDifference(array, values, iteratee, comparator) {
  function baseEvery (line 11844) | function baseEvery(collection, predicate) {
  function baseExtremum (line 11863) | function baseExtremum(array, iteratee, comparator) {
  function baseFill (line 11894) | function baseFill(array, value, start, end) {
  function baseFilter (line 11920) | function baseFilter(collection, predicate) {
  function baseFlatten (line 11941) | function baseFlatten(array, depth, predicate, isStrict, result) {
  function baseForOwn (line 11997) | function baseForOwn(object, iteratee) {
  function baseForOwnRight (line 12009) | function baseForOwnRight(object, iteratee) {
  function baseFunctions (line 12022) | function baseFunctions(object, props) {
  function baseGet (line 12036) | function baseGet(object, path) {
  function baseGetAllKeys (line 12059) | function baseGetAllKeys(object, keysFunc, symbolsFunc) {
  function baseGetTag (line 12071) | function baseGetTag(value) {
  function baseGt (line 12089) | function baseGt(value, other) {
  function baseHas (line 12101) | function baseHas(object, key) {
  function baseHasIn (line 12113) | function baseHasIn(object, key) {
  function baseInRange (line 12126) | function baseInRange(number, start, end) {
  function baseIntersection (line 12140) | function baseIntersection(arrays, iteratee, comparator) {
  function baseInverter (line 12202) | function baseInverter(object, setter, iteratee, accumulator) {
  function baseInvoke (line 12219) | function baseInvoke(object, path, args) {
  function baseIsArguments (line 12233) | function baseIsArguments(value) {
  function baseIsArrayBuffer (line 12244) | function baseIsArrayBuffer(value) {
  function baseIsDate (line 12255) | function baseIsDate(value) {
  function baseIsEqual (line 12273) | function baseIsEqual(value, other, bitmask, customizer, stack) {
  function baseIsEqualDeep (line 12301) | function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, ...
  function baseIsMap (line 12353) | function baseIsMap(value) {
  function baseIsMatch (line 12367) | function baseIsMatch(object, source, matchData, customizer) {
  function baseIsNative (line 12423) | function baseIsNative(value) {
  function baseIsRegExp (line 12438) | function baseIsRegExp(value) {
  function baseIsSet (line 12449) | function baseIsSet(value) {
  function baseIsTypedArray (line 12460) | function baseIsTypedArray(value) {
  function baseIteratee (line 12473) | function baseIteratee(value) {
  function baseKeys (line 12495) | function baseKeys(object) {
  function baseKeysIn (line 12515) | function baseKeysIn(object) {
  function baseLt (line 12539) | function baseLt(value, other) {
  function baseMap (line 12551) | function baseMap(collection, iteratee) {
  function baseMatches (line 12568) | function baseMatches(source) {
  function baseMatchesProperty (line 12586) | function baseMatchesProperty(path, srcValue) {
  function baseMerge (line 12609) | function baseMerge(object, source, srcIndex, customizer, stack) {
  function baseMergeDeep (line 12649) | function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customi...
  function baseNth (line 12712) | function baseNth(array, n) {
  function baseOrderBy (line 12730) | function baseOrderBy(collection, iteratees, orders) {
  function basePick (line 12758) | function basePick(object, paths) {
  function basePickBy (line 12773) | function basePickBy(object, paths, predicate) {
  function basePropertyDeep (line 12796) | function basePropertyDeep(path) {
  function basePullAll (line 12813) | function basePullAll(array, values, iteratee, comparator) {
  function basePullAt (line 12849) | function basePullAt(array, indexes) {
  function baseRandom (line 12876) | function baseRandom(lower, upper) {
  function baseRange (line 12891) | function baseRange(start, end, step, fromRight) {
  function baseRepeat (line 12911) | function baseRepeat(string, n) {
  function baseRest (line 12939) | function baseRest(func, start) {
  function baseSample (line 12950) | function baseSample(collection) {
  function baseSampleSize (line 12962) | function baseSampleSize(collection, n) {
  function baseSet (line 12977) | function baseSet(object, path, value, customizer) {
  function baseShuffle (line 13046) | function baseShuffle(collection) {
  function baseSlice (line 13059) | function baseSlice(array, start, end) {
  function baseSome (line 13089) | function baseSome(collection, predicate) {
  function baseSortedIndex (line 13111) | function baseSortedIndex(array, value, retHighest) {
  function baseSortedIndexBy (line 13148) | function baseSortedIndexBy(array, value, iteratee, retHighest) {
  function baseSortedUniq (line 13198) | function baseSortedUniq(array, iteratee) {
  function baseToNumber (line 13224) | function baseToNumber(value) {
  function baseToString (line 13242) | function baseToString(value) {
  function baseUniq (line 13267) | function baseUniq(array, iteratee, comparator) {
  function baseUnset (line 13323) | function baseUnset(object, path) {
  function baseUpdate (line 13339) | function baseUpdate(object, path, updater, customizer) {
  function baseWhile (line 13354) | function baseWhile(array, predicate, isDrop, fromRight) {
  function baseWrapperValue (line 13378) | function baseWrapperValue(value, actions) {
  function baseXor (line 13402) | function baseXor(arrays, iteratee, comparator) {
  function baseZipObject (line 13437) | function baseZipObject(props, values, assignFunc) {
  function castArrayLikeObject (line 13457) | function castArrayLikeObject(value) {
  function castFunction (line 13468) | function castFunction(value) {
  function castPath (line 13480) | function castPath(value, object) {
  function castSlice (line 13507) | function castSlice(array, start, end) {
  function cloneBuffer (line 13533) | function cloneBuffer(buffer, isDeep) {
  function cloneArrayBuffer (line 13551) | function cloneArrayBuffer(arrayBuffer) {
  function cloneDataView (line 13565) | function cloneDataView(dataView, isDeep) {
  function cloneRegExp (line 13577) | function cloneRegExp(regexp) {
  function cloneSymbol (line 13590) | function cloneSymbol(symbol) {
  function cloneTypedArray (line 13602) | function cloneTypedArray(typedArray, isDeep) {
  function compareAscending (line 13615) | function compareAscending(value, other) {
  function compareMultiple (line 13663) | function compareMultiple(object, other, orders) {
  function composeArgs (line 13701) | function composeArgs(args, partials, holders, isCurried) {
  function composeArgsRight (line 13736) | function composeArgsRight(args, partials, holders, isCurried) {
  function copyArray (line 13770) | function copyArray(source, array) {
  function copyObject (line 13791) | function copyObject(source, props, object, customizer) {
  function copySymbols (line 13825) | function copySymbols(source, object) {
  function copySymbolsIn (line 13837) | function copySymbolsIn(source, object) {
  function createAggregator (line 13849) | function createAggregator(setter, initializer) {
  function createAssigner (line 13865) | function createAssigner(assigner) {
  function createBaseEach (line 13900) | function createBaseEach(eachFunc, fromRight) {
  function createBaseFor (line 13928) | function createBaseFor(fromRight) {
  function createBind (line 13955) | function createBind(func, bitmask, thisArg) {
  function createCaseFirst (line 13973) | function createCaseFirst(methodName) {
  function createCompounder (line 13994) | function createCompounder(callback) {
  function createCtor (line 14008) | function createCtor(Ctor) {
  function createCurry (line 14050) | function createCurry(func, bitmask, arity) {
  function createFind (line 14095) | function createFind(findIndexFunc) {
  function createFlow (line 14117) | function createFlow(fromRight) {
  function createHybrid (line 14195) | function createHybrid(
  function createInverter (line 14276) | function createInverter(setter, toIteratee) {
  function createMathOperation (line 14290) | function createMathOperation(operator, defaultValue) {
  function createOver (line 14323) | function createOver(arrayFunc) {
  function createPadding (line 14344) | function createPadding(length, chars) {
  function createPartial (line 14369) | function createPartial(func, bitmask, thisArg, partials) {
  function createRange (line 14399) | function createRange(fromRight) {
  function createRelationalOperation (line 14424) | function createRelationalOperation(operator) {
  function createRecurry (line 14451) | function createRecurry(
  function createRound (line 14503) | function createRound(methodName) {
  function createToPairs (line 14541) | function createToPairs(keysFunc) {
  function createWrap (line 14579) | function createWrap(func, bitmask, thisArg, partials, holders, argPos, a...
  function customDefaultsAssignIn (line 14660) | function customDefaultsAssignIn(objValue, srcValue, key, object) {
  function customDefaultsMerge (line 14684) | function customDefaultsMerge(objValue, srcValue, key, object, source, st...
  function customOmitClone (line 14703) | function customOmitClone(value) {
  function equalArrays (line 14720) | function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
  function equalByTag (line 14805) | function equalByTag(object, other, tag, bitmask, customizer, equalFunc, ...
  function equalObjects (line 14894) | function equalObjects(object, other, bitmask, customizer, equalFunc, sta...
  function flatRest (line 14973) | function flatRest(func) {
  function getAllKeys (line 14984) | function getAllKeys(object) {
  function getAllKeysIn (line 14996) | function getAllKeysIn(object) {
  function getFuncName (line 15020) | function getFuncName(func) {
  function getHolder (line 15042) | function getHolder(func) {
  function getIteratee (line 15058) | function getIteratee() {
  function getMapData (line 15072) | function getMapData(map, key) {
  function getMatchData (line 15084) | function getMatchData(object) {
  function getNative (line 15105) | function getNative(object, key) {
  function getRawTag (line 15117) | function getRawTag(value) {
  function getView (line 15224) | function getView(start, end, transforms) {
  function getWrapDetails (line 15257) | function getWrapDetails(source) {
  function hasPath (line 15271) | function hasPath(object, path, hasFunc) {
  function initCloneArray (line 15304) | function initCloneArray(array) {
  function initCloneObject (line 15323) | function initCloneObject(object) {
  function initCloneByTag (line 15341) | function initCloneByTag(object, tag, isDeep) {
  function insertWrapDetails (line 15391) | function insertWrapDetails(source, details) {
  function isFlattenable (line 15409) | function isFlattenable(value) {
  function isIndex (line 15425) | function isIndex(value, length) {
  function isIterateeCall (line 15446) | function isIterateeCall(value, index, object) {
  function isKey (line 15469) | function isKey(value, object) {
  function isKeyable (line 15497) | function isKeyable(value) {
  function isLaziable (line 15512) | function isLaziable(func) {
  function isMasked (line 15533) | function isMasked(func) {
  function isPrototype (line 15553) | function isPrototype(value) {
  function isStrictComparable (line 15568) | function isStrictComparable(value) {
  function matchesStrictComparable (line 15581) | function matchesStrictComparable(key, srcValue) {
  function memoizeCapped (line 15598) | function memoizeCapped(func) {
  function mergeData (line 15626) | function mergeData(data, source) {
  function nativeKeysIn (line 15694) | function nativeKeysIn(object) {
  function objectToString (line 15711) | function objectToString(value) {
  function overRest (line 15724) | function overRest(func, start, transform) {
  function parent (line 15753) | function parent(object, path) {
  function reorder (line 15767) | function reorder(array, indexes) {
  function setWrapToString (line 15829) | function setWrapToString(wrapper, reference, bitmask) {
  function shortOut (line 15846) | function shortOut(func) {
  function shuffleSelf (line 15874) | function shuffleSelf(array, size) {
  function toKey (line 15916) | function toKey(value) {
  function toSource (line 15931) | function toSource(func) {
  function updateWrapDetails (line 15951) | function updateWrapDetails(details, bitmask) {
  function wrapperClone (line 15968) | function wrapperClone(wrapper) {
  function chunk (line 16002) | function chunk(array, size, guard) {
  function compact (line 16037) | function compact(array) {
  function concat (line 16074) | function concat() {
  function drop (line 16219) | function drop(array, n, guard) {
  function dropRight (line 16253) | function dropRight(array, n, guard) {
  function dropRightWhile (line 16298) | function dropRightWhile(array, predicate) {
  function dropWhile (line 16339) | function dropWhile(array, predicate) {
  function fill (line 16372) | function fill(array, value, start, end) {
  function findIndex (line 16419) | function findIndex(array, predicate, fromIndex) {
  function findLastIndex (line 16466) | function findLastIndex(array, predicate, fromIndex) {
  function flatten (line 16493) | function flatten(array) {
  function flattenDeep (line 16512) | function flattenDeep(array) {
  function flattenDepth (line 16537) | function flattenDepth(array, depth) {
  function fromPairs (line 16561) | function fromPairs(pairs) {
  function head (line 16591) | function head(array) {
  function indexOf (line 16618) | function indexOf(array, value, fromIndex) {
  function initial (line 16644) | function initial(array) {
  function join (line 16757) | function join(array, separator) {
  function last (line 16775) | function last(array) {
  function lastIndexOf (line 16801) | function lastIndexOf(array, value, fromIndex) {
  function nth (line 16837) | function nth(array, n) {
  function pullAll (line 16886) | function pullAll(array, values) {
  function pullAllBy (line 16915) | function pullAllBy(array, values, iteratee) {
  function pullAllWith (line 16944) | function pullAllWith(array, values, comparator) {
  function remove (line 17016) | function remove(array, predicate) {
  function reverse (line 17060) | function reverse(array) {
  function slice (line 17080) | function slice(array, start, end) {
  function sortedIndex (line 17112) | function sortedIndex(array, value) {
  function sortedIndexBy (line 17141) | function sortedIndexBy(array, value, iteratee) {
  function sortedIndexOf (line 17161) | function sortedIndexOf(array, value) {
  function sortedLastIndex (line 17190) | function sortedLastIndex(array, value) {
  function sortedLastIndexBy (line 17219) | function sortedLastIndexBy(array, value, iteratee) {
  function sortedLastIndexOf (line 17239) | function sortedLastIndexOf(array, value) {
  function sortedUniq (line 17265) | function sortedUniq(array) {
  function sortedUniqBy (line 17285) | function sortedUniqBy(array, iteratee) {
  function tail (line 17303) | function tail(array) {
  function take (line 17333) | function take(array, n, guard) {
  function takeRight (line 17366) | function takeRight(array, n, guard) {
  function takeRightWhile (line 17411) | function takeRightWhile(array, predicate) {
  function takeWhile (line 17452) | function takeWhile(array, predicate) {
  function uniq (line 17559) | function uniq(array) {
  function uniqBy (line 17586) | function uniqBy(array, iteratee) {
  function uniqWith (line 17610) | function uniqWith(array, comparator) {
  function unzip (line 17634) | function unzip(array) {
  function unzipWith (line 17671) | function unzipWith(array, iteratee) {
  function zipObject (line 17822) | function zipObject(props, values) {
  function zipObjectDeep (line 17841) | function zipObjectDeep(props, values) {
  function chain (line 17904) | function chain(value) {
  function tap (line 17933) | function tap(value, interceptor) {
  function thru (line 17961) | function thru(value, interceptor) {
  function wrapperChain (line 18038) | function wrapperChain() {
  function wrapperCommit (line 18068) | function wrapperCommit() {
  function wrapperNext (line 18094) | function wrapperNext() {
  function wrapperToIterator (line 18122) | function wrapperToIterator() {
  function wrapperPlant (line 18150) | function wrapperPlant(value) {
  function wrapperReverse (line 18190) | function wrapperReverse() {
  function wrapperValue (line 18222) | function wrapperValue() {
  function every (line 18299) | function every(collection, predicate, guard) {
  function filter (line 18344) | function filter(collection, predicate) {
  function flatMap (line 18429) | function flatMap(collection, iteratee) {
  function flatMapDeep (line 18453) | function flatMapDeep(collection, iteratee) {
  function flatMapDepth (line 18478) | function flatMapDepth(collection, iteratee, depth) {
  function forEach (line 18513) | function forEach(collection, iteratee) {
  function forEachRight (line 18538) | function forEachRight(collection, iteratee) {
  function includes (line 18604) | function includes(collection, value, fromIndex, guard) {
  function map (line 18725) | function map(collection, iteratee) {
  function orderBy (line 18759) | function orderBy(collection, iteratees, orders, guard) {
  function reduce (line 18855) | function reduce(collection, iteratee, accumulator) {
  function reduceRight (line 18884) | function reduceRight(collection, iteratee, accumulator) {
  function reject (line 18931) | function reject(collection, predicate) {
  function sample (line 18950) | function sample(collection) {
  function sampleSize (line 18975) | function sampleSize(collection, n, guard) {
  function shuffle (line 19000) | function shuffle(collection) {
  function size (line 19026) | function size(collection) {
  function some (line 19076) | function some(collection, predicate, guard) {
  function after (line 19176) | function after(n, func) {
  function ary (line 19205) | function ary(func, n, guard) {
  function before (line 19228) | function before(n, func) {
  function curry (line 19384) | function curry(func, arity, guard) {
  function curryRight (line 19438) | function curryRight(func, arity, guard) {
  function debounce (line 19508) | function debounce(func, wait, options) {
  function flip (line 19697) | function flip(func) {
  function memoize (line 19745) | function memoize(func, resolver) {
  function negate (line 19791) | function negate(predicate) {
  function once (line 19829) | function once(func) {
  function rest (line 20008) | function rest(func, start) {
  function spread (line 20050) | function spread(func, start) {
  function throttle (line 20110) | function throttle(func, wait, options) {
  function unary (line 20143) | function unary(func) {
  function wrap (line 20169) | function wrap(value, wrapper) {
  function castArray (line 20208) | function castArray() {
  function clone (line 20242) | function clone(value) {
  function cloneWith (line 20277) | function cloneWith(value, customizer) {
  function cloneDeep (line 20300) | function cloneDeep(value) {
  function cloneDeepWith (line 20332) | function cloneDeepWith(value, customizer) {
  function conformsTo (line 20361) | function conformsTo(object, source) {
  function eq (line 20397) | function eq(value, other) {
  function isArrayLike (line 20554) | function isArrayLike(value) {
  function isArrayLikeObject (line 20583) | function isArrayLikeObject(value) {
  function isBoolean (line 20604) | function isBoolean(value) {
  function isElement (line 20667) | function isElement(value) {
  function isEmpty (line 20704) | function isEmpty(value) {
  function isEqual (line 20762) | function isEqual(value, other) {
  function isEqualWith (line 20798) | function isEqualWith(value, other, customizer) {
  function isError (line 20824) | function isError(value) {
  function isFinite (line 20864) | function isFinite(value) {
  function isFunction (line 20885) | function isFunction(value) {
  function isInteger (line 20921) | function isInteger(value) {
  function isLength (line 20951) | function isLength(value) {
  function isObject (line 20985) | function isObject(value) {
  function isObjectLike (line 21014) | function isObjectLike(value) {
  function isMatch (line 21065) | function isMatch(object, source) {
  function isMatchWith (line 21101) | function isMatchWith(object, source, customizer) {
  function isNaN (line 21134) | function isNaN(value) {
  function isNative (line 21167) | function isNative(value) {
  function isNull (line 21191) | function isNull(value) {
  function isNil (line 21215) | function isNil(value) {
  function isNumber (line 21245) | function isNumber(value) {
  function isPlainObject (line 21279) | function isPlainObject(value) {
  function isSafeInteger (line 21341) | function isSafeInteger(value) {
  function isString (line 21381) | function isString(value) {
  function isSymbol (line 21405) | function isSymbol(value) {
  function isUndefined (line 21447) | function isUndefined(value) {
  function isWeakMap (line 21468) | function isWeakMap(value) {
  function isWeakSet (line 21489) | function isWeakSet(value) {
  function toArray (line 21568) | function toArray(value) {
  function toFinite (line 21607) | function toFinite(value) {
  function toInteger (line 21645) | function toInteger(value) {
  function toLength (line 21679) | function toLength(value) {
  function toNumber (line 21706) | function toNumber(value) {
  function toPlainObject (line 21753) | function toPlainObject(value) {
  function toSafeInteger (line 21781) | function toSafeInteger(value) {
  function toString (line 21810) | function toString(value) {
  function create (line 22013) | function create(prototype, properties) {
  function findKey (line 22131) | function findKey(object, predicate) {
  function findLastKey (line 22170) | function findLastKey(object, predicate) {
  function forIn (line 22202) | function forIn(object, iteratee) {
  function forInRight (line 22232) | function forInRight(object, iteratee) {
  function forOwn (line 22266) | function forOwn(object, iteratee) {
  function forOwnRight (line 22296) | function forOwnRight(object, iteratee) {
  function functions (line 22323) | function functions(object) {
  function functionsIn (line 22350) | function functionsIn(object) {
  function get (line 22379) | function get(object, path, defaultValue) {
  function has (line 22411) | function has(object, path) {
  function hasIn (line 22441) | function hasIn(object, path) {
  function keys (line 22557) | function keys(object) {
  function keysIn (line 22584) | function keysIn(object) {
  function mapKeys (line 22609) | function mapKeys(object, iteratee) {
  function mapValues (line 22647) | function mapValues(object, iteratee) {
  function omitBy (line 22793) | function omitBy(object, predicate) {
  function pickBy (line 22836) | function pickBy(object, predicate) {
  function result (line 22878) | function result(object, path, defaultValue) {
  function set (line 22928) | function set(object, path, value) {
  function setWith (line 22956) | function setWith(object, path, value, customizer) {
  function transform (line 23043) | function transform(object, iteratee, accumulator) {
  function unset (line 23091) | function unset(object, path) {
  function update (line 23122) | function update(object, path, updater) {
  function updateWith (line 23150) | function updateWith(object, path, updater, customizer) {
  function values (line 23183) | function values(object) {
  function valuesIn (line 23211) | function valuesIn(object) {
  function clamp (line 23236) | function clamp(number, lower, upper) {
  function inRange (line 23290) | function inRange(number, start, end) {
  function random (line 23333) | function random(lower, upper, floating) {
  function capitalize (line 23419) | function capitalize(string) {
  function deburr (line 23441) | function deburr(string) {
  function endsWith (line 23469) | function endsWith(string, target, position) {
  function escape (line 23509) | function escape(string) {
  function escapeRegExp (line 23531) | function escapeRegExp(string) {
  function pad (line 23629) | function pad(string, length, chars) {
  function padEnd (line 23668) | function padEnd(string, length, chars) {
  function padStart (line 23701) | function padStart(string, length, chars) {
  function parseInt (line 23735) | function parseInt(string, radix, guard) {
  function repeat (line 23766) | function repeat(string, n, guard) {
  function replace (line 23794) | function replace() {
  function split (line 23845) | function split(string, separator, limit) {
  function startsWith (line 23914) | function startsWith(string, target, position) {
  function template (line 24026) | function template(string, options, guard) {
  function toLower (line 24171) | function toLower(value) {
  function toUpper (line 24196) | function toUpper(value) {
  function trim (line 24222) | function trim(string, chars, guard) {
  function trimEnd (line 24257) | function trimEnd(string, chars, guard) {
  function trimStart (line 24290) | function trimStart(string, chars, guard) {
  function truncate (line 24341) | function truncate(string, options) {
  function unescape (line 24416) | function unescape(string) {
  function words (line 24485) | function words(string, pattern, guard) {
  function cond (line 24590) | function cond(pairs) {
  function conforms (line 24638) | function conforms(source) {
  function constant (line 24661) | function constant(value) {
  function defaultTo (line 24687) | function defaultTo(value, defaultValue) {
  function identity (line 24754) | function identity(value) {
  function iteratee (line 24800) | function iteratee(func) {
  function matches (line 24834) | function matches(source) {
  function matchesProperty (line 24864) | function matchesProperty(path, srcValue) {
  function mixin (line 24963) | function mixin(object, source, options) {
  function noConflict (line 25011) | function noConflict() {
  function noop (line 25030) | function noop() {
  function nthArg (line 25054) | function nthArg(n) {
  function property (line 25155) | function property(path) {
  function propertyOf (line 25180) | function propertyOf(object) {
  function stubArray (line 25285) | function stubArray() {
  function stubFalse (line 25302) | function stubFalse() {
  function stubObject (line 25324) | function stubObject() {
  function stubString (line 25341) | function stubString() {
  function stubTrue (line 25358) | function stubTrue() {
  function times (line 25381) | function times(n, iteratee) {
  function toPath (line 25416) | function toPath(value) {
  function uniqueId (line 25440) | function uniqueId(prefix) {
  function max (line 25549) | function max(array) {
  function maxBy (line 25576) | function maxBy(array, iteratee) {
  function mean (line 25596) | function mean(array) {
  function meanBy (line 25623) | function meanBy(array, iteratee) {
  function min (line 25645) | function min(array) {
  function minBy (line 25672) | function minBy(array, iteratee) {
  function sum (line 25753) | function sum(array) {
  function sumBy (line 25780) | function sumBy(array, iteratee) {
  function empty (line 26414) | function empty(scheduler) {
  function emptyScheduled (line 26417) | function emptyScheduled(scheduler) {
  function copyProps (line 26487) | function copyProps(src, dst) {
  function SafeBuffer (line 26500) | function SafeBuffer(arg, encodingOrOffset, length) {
  function map (line 26556) | function map(project, thisArg) {
  function MapOperator (line 26565) | function MapOperator(project, thisArg) {
  function MapSubscriber (line 26577) | function MapSubscriber(destination, project, thisArg) {
  function isScheduler (line 26617) | function isScheduler(value) {
  function wait (line 26640) | function wait(delay) {
  function promisify (line 26646) | function promisify(fn, firstData) {
  function queue (line 26673) | function queue(arr, promiseProducer, concurrency = Infinity) {
  function tryCatcher (line 26749) | function tryCatcher() {
  function tryCatch (line 26757) | function tryCatch(fn) {
  function _load_yarnRegistry (line 26776) | function _load_yarnRegistry() {
  function _load_npmRegistry (line 26782) | function _load_npmRegistry() {
  function _interopRequireDefault (line 26786) | function _interopRequireDefault(obj) {
  function _load_constants (line 26814) | function _load_constants() {
  function _load_blockingQueue (line 26820) | function _load_blockingQueue() {
  function _load_errors (line 26826) | function _load_errors() {
  function _load_promise (line 26832) | function _load_promise() {
  function _interopRequireDefault (line 26836) | function _interopRequireDefault(obj) {
  function _interopRequireWildcard (line 26840) | function _interopRequireWildcard(obj) {
  function forkp (line 26869) | function forkp(program, args, opts) {
  function spawnp (line 26883) | function spawnp(program, args, opts) {
  function forwardSignalToSpawnedProcesses (line 26899) | function forwardSignalToSpawnedProcesses(signal) {
  function spawn (line 26925) | function spawn(program, args, opts = {}, onData) {
  function _load_asyncToGenerator (line 27028) | function _load_asyncToGenerator() {
  function setFlags (line 27089) | function setFlags(commander) {
  function hasWrapper (line 27093) | function hasWrapper(commander, args) {
  function _load_errors (line 27106) | function _load_errors() {
  function _load_misc (line 27112) | function _load_misc() {
  function _interopRequireDefault (line 27116) | function _interopRequireDefault(obj) {
  function from (line 27243) | function from(input, scheduler) {
  function _load_rootUser (line 28375) | function _load_rootUser() {
  function _interopRequireDefault (line 28379) | function _interopRequireDefault(obj) {
  function FingerprintFormatError (line 28485) | function FingerprintFormatError(fp, format) {
  function InvalidAlgorithmError (line 28496) | function InvalidAlgorithmError(alg) {
  function KeyParseError (line 28504) | function KeyParseError(name, format, innerErr) {
  function SignatureParseError (line 28515) | function SignatureParseError(type, format, innerErr) {
  function CertificateParseError (line 28531) | function CertificateParseError(name, format, innerErr) {
  function KeyEncryptedError (line 28547) | function KeyEncryptedError(name, format) {
  function Signature (line 28592) | function Signature(opts) {
  function parseOneNum (line 28747) | function parseOneNum(data, type, format, opts) {
  function parseDSAasn1 (line 28794) | function parseDSAasn1(data, type, format, opts) {
  function parseDSA (line 28806) | function parseDSA(data, type, format, opts) {
  function parseECDSA (line 28820) | function parseECDSA(data, type, format, opts) {
  function ts64 (line 29005) | function ts64(x, i, h, l) {
  function vn (line 29016) | function vn(x, xi, y, yi, n) {
  function crypto_verify_16 (line 29023) | function crypto_verify_16(x, xi, y, yi) {
  function crypto_verify_32 (line 29027) | function crypto_verify_32(x, xi, y, yi) {
  function core_salsa20 (line 29031) | function core_salsa20(o, p, k, c) {
  function core_hsalsa20 (line 29284) | function core_hsalsa20(o, p, k, c) {
  function crypto_core_salsa20 (line 29481) | function crypto_core_salsa20(out, inp, k, c) {
  function crypto_core_hsalsa20 (line 29485) | function crypto_core_hsalsa20(out, inp, k, c) {
  function crypto_stream_salsa20_xor (line 29509) | function crypto_stream_salsa20_xor(c, cpos, m, mpos, b, n, k) {
  function crypto_stream_salsa20 (line 29535) | function crypto_stream_salsa20(c, cpos, b, n, k) {
  function crypto_stream (line 29560) | function crypto_stream(c, cpos, d, n, k) {
  function crypto_stream_xor (line 29568) | function crypto_stream_xor(c, cpos, m, mpos, d, n, k) {
  function crypto_onetimeauth (line 29965) | function crypto_onetimeauth(out, outpos, m, mpos, n, k) {
  function crypto_onetimeauth_verify (line 29972) | function crypto_onetimeauth_verify(h, hpos, m, mpos, n, k) {
  function crypto_secretbox (line 29978) | function crypto_secretbox(c, m, d, n, k) {
  function crypto_secretbox_open (line 29987) | function crypto_secretbox_open(m, c, d, n, k) {
  function set25519 (line 29998) | function set25519(r, a) {
  function car25519 (line 30003) | function car25519(o) {
  function sel25519 (line 30015) | function sel25519(p, q, b) {
  function pack25519 (line 30025) | function pack25519(o, n) {
  function neq25519 (line 30050) | function neq25519(a, b) {
  function par25519 (line 30058) | function par25519(a) {
  function unpack25519 (line 30064) | function unpack25519(o, n) {
  function A (line 30070) | function A(o, a, b) {
  function Z (line 30074) | function Z(o, a, b) {
  function M (line 30078) | function M(o, a, b) {
  function S (line 30541) | function S(o, a) {
  function inv25519 (line 30545) | function inv25519(o, i) {
  function pow2523 (line 30556) | function pow2523(o, i) {
  function crypto_scalarmult (line 30567) | function crypto_scalarmult(q, n, p) {
  function crypto_scalarmult_base (line 30626) | function crypto_scalarmult_base(q, n) {
  function crypto_box_keypair (line 30630) | function crypto_box_keypair(y, x) {
  function crypto_box_beforenm (line 30635) | function crypto_box_beforenm(k, y, x) {
  function crypto_box (line 30644) | function crypto_box(c, m, d, n, y, x) {
  function crypto_box_open (line 30650) | function crypto_box_open(m, c, d, n, y, x) {
  function crypto_hashblocks_hl (line 30819) | function crypto_hashblocks_hl(hh, hl, m, n) {
  function crypto_hash (line 31284) | function crypto_hash(out, m, n) {
  function add (line 31325) | function add(p, q) {
  function cswap (line 31357) | function cswap(p, q, b) {
  function pack (line 31364) | function pack(r, p) {
  function scalarmult (line 31375) | function scalarmult(p, q, s) {
  function scalarbase (line 31390) | function scalarbase(p, s) {
  function crypto_sign_keypair (line 31399) | function crypto_sign_keypair(pk, sk, seeded) {
  function modL (line 31452) | function modL(r, x) {
  function reduce (line 31477) | function reduce(r) {
  function crypto_sign (line 31486) | function crypto_sign(sm, m, n, sk) {
  function unpackneg (line 31525) | function unpackneg(r, p) {
  function crypto_sign_open (line 31567) | function crypto_sign_open(m, sm, n, pk) {
  function checkLengths (line 31663) | function checkLengths(k, n) {
  function checkBoxLengths (line 31668) | function checkBoxLengths(pk, sk) {
  function checkArrayTypes (line 31673) | function checkArrayTypes() {
  function cleanup (line 31681) | function cleanup(arr) {
  class Hash (line 31945) | class Hash {
    method isHash (line 31946) | get isHash() {
    method constructor (line 31949) | constructor(hash, opts) {
    method hexDigest (line 31967) | hexDigest() {
    method toJSON (line 31970) | toJSON() {
    method toString (line 31973) | toString(opts) {
  class Integrity (line 32001) | class Integrity {
    method isIntegrity (line 32002) | get isIntegrity() {
    method toJSON (line 32005) | toJSON() {
    method toString (line 32008) | toString(opts) {
    method concat (line 32027) | concat(integrity, opts) {
    method hexDigest (line 32031) | hexDigest() {
    method match (line 32034) | match(integrity, opts) {
    method pickAlgorithm (line 32046) | pickAlgorithm(opts) {
  function parse (line 32059) | function parse(sri, opts) {
  function _parse (line 32072) | function _parse(integrity, opts) {
  function stringify (line 32095) | function stringify(obj, opts) {
  function fromHex (line 32106) | function fromHex(hexDigest, algorithm, opts) {
  function fromData (line 32116) | function fromData(data, opts) {
  function fromStream (line 32138) | function fromStream(stream, opts) {
  function checkData (line 32156) | function checkData(data, sri, opts) {
  function checkStream (line 32204) | function checkStream(stream, sri, opts) {
  function integrityStream (line 32226) | function integrityStream(opts) {
  function createIntegrity (line 32288) | function createIntegrity(opts) {
  function getPrioritizedHash (line 32341) | function getPrioritizedHash(algo1, algo2) {
  function _load_baseResolver (line 32363) | function _load_baseResolver() {
  function _load_npmResolver (line 32369) | function _load_npmResolver() {
  function _load_yarnResolver (line 32375) | function _load_yarnResolver() {
  function _load_gitResolver (line 32381) | function _load_gitResolver() {
  function _load_tarballResolver (line 32387) | function _load_tarballResolver() {
  function _load_githubResolver (line 32393) | function _load_githubResolver() {
  function _load_fileResolver (line 32399) | function _load_fileResolver() {
  function _load_linkResolver (line 32405) | function _load_linkResolver() {
  function _load_gitlabResolver (line 32411) | function _load_gitlabResolver() {
  function _load_gistResolver (line 32417) | function _load_gistResolver() {
  function _load_bitbucketResolver (line 32423) | function _load_bitbucketResolver() {
  function _load_hostedGitResolver (line 32429) | function _load_hostedGitResolver() {
  function _load_registryResolver (line 32435) | function _load_registryResolver() {
  function _interopRequireDefault (line 32439) | function _interopRequireDefault(obj) {
  function getExoticResolver (line 32461) | function getExoticResolver(pattern) {
  function hostedGitFragmentToGitUrl (line 32498) | function hostedGitFragmentToGitUrl(fragment, reporter) {
  class Prompt (line 32548) | class Prompt {
    method constructor (line 32549) | constructor(question, rl, answers) {
    method run (line 32589) | run() {
    method _run (line 32596) | _run(cb) {
    method throwParamError (line 32606) | throwParamError(name) {
    method close (line 32613) | close() {
    method handleSubmitEvents (line 32622) | handleSubmitEvents(submit) {
    method getQuestion (line 32660) | getQuestion() {
  function normalizeKeypressEvents (line 32693) | function normalizeKeypressEvents(value, key) {
  function BigInteger (line 32760) | function BigInteger(a, b, c) {
  function nbi (line 32768) | function nbi() {
  function am1 (line 32780) | function am1(i, x, w, j, c, n) {
  function am2 (line 32791) | function am2(i, x, w, j, c, n) {
  function am3 (line 32806) | function am3(i, x, w, j, c, n) {
  function int2char (line 32852) | function int2char(n) {
  function intAt (line 32855) | function intAt(s, i) {
  function bnpCopyTo (line 32861) | function bnpCopyTo(r) {
  function bnpFromInt (line 32868) | function bnpFromInt(x) {
  function nbv (line 32877) | function nbv(i) {
  function bnpFromString (line 32884) | function bnpFromString(s, b) {
  function bnpClamp (line 32926) | function bnpClamp() {
  function bnToString (line 32932) | function bnToString(b) {
  function bnNegate (line 32971) | function bnNegate() {
  function bnAbs (line 32978) | function bnAbs() {
  function bnCompareTo (line 32983) | function bnCompareTo(a) {
  function nbits (line 32994) | function nbits(x) {
  function bnBitLength (line 33021) | function bnBitLength() {
  function bnpDLShiftTo (line 33027) | function bnpDLShiftTo(n, r) {
  function bnpDRShiftTo (line 33036) | function bnpDRShiftTo(n, r) {
  function bnpLShiftTo (line 33043) | function bnpLShiftTo(n, r) {
  function bnpRShiftTo (line 33062) | function bnpRShiftTo(n, r) {
  function bnpSubTo (line 33083) | function bnpSubTo(a, r) {
  function bnpMultiplyTo (line 33118) | function bnpMultiplyTo(a, r) {
  function bnpSquareTo (line 33131) | function bnpSquareTo(r) {
  function bnpDivRemTo (line 33149) | function bnpDivRemTo(m, q, r) {
  function bnMod (line 33209) | function bnMod(a) {
  function Classic (line 33217) | function Classic(m) {
  function cConvert (line 33220) | function cConvert(x) {
  function cRevert (line 33224) | function cRevert(x) {
  function cReduce (line 33227) | function cReduce(x) {
  function cMulTo (line 33230) | function cMulTo(x, y, r) {
  function cSqrTo (line 33234) | function cSqrTo(x, r) {
  function bnpInvDigit (line 33255) | function bnpInvDigit() {
  function Montgomery (line 33271) | function Montgomery(m) {
  function montConvert (line 33281) | function montConvert(x) {
  function montRevert (line 33290) | function montRevert(x) {
  function montReduce (line 33298) | function montReduce(x) {
  function montSqrTo (line 33323) | function montSqrTo(x, r) {
  function montMulTo (line 33329) | function montMulTo(x, y, r) {
  function bnpIsEven (line 33341) | function bnpIsEven() {
  function bnpExp (line 33346) | function bnpExp(e, z) {
  function bnModPowInt (line 33366) | function bnModPowInt(e, m) {
  function bnClone (line 33413) | function bnClone() {
  function bnIntValue (line 33420) | function bnIntValue() {
  function bnByteValue (line 33431) | function bnByteValue() {
  function bnShortValue (line 33436) | function bnShortValue() {
  function bnpChunkSize (line 33441) | function bnpChunkSize(r) {
  function bnSigNum (line 33446) | function bnSigNum() {
  function bnpToRadix (line 33453) | function bnpToRadix(b) {
  function bnpFromRadix (line 33471) | function bnpFromRadix(s, b) {
  function bnpFromNumber (line 33501) | function bnpFromNumber(a, b, c) {
  function bnToByteArray (line 33529) | function bnToByteArray() {
  function bnEquals (line 33558) | function bnEquals(a) {
  function bnMin (line 33561) | function bnMin(a) {
  function bnMax (line 33564) | function bnMax(a) {
  function bnpBitwiseTo (line 33569) | function bnpBitwiseTo(a, op, r) {
  function op_and (line 33588) | function op_and(x, y) {
  function bnAnd (line 33591) | function bnAnd(a) {
  function op_or (line 33598) | function op_or(x, y) {
  function bnOr (line 33601) | function bnOr(a) {
  function op_xor (line 33608) | function op_xor(x, y) {
  function bnXor (line 33611) | function bnXor(a) {
  function op_andnot (line 33618) | function op_andnot(x, y) {
  function bnAndNot (line 33621) | function bnAndNot(a) {
  function bnNot (line 33628) | function bnNot() {
  function bnShiftLeft (line 33637) | function bnShiftLeft(n) {
  function bnShiftRight (line 33645) | function bnShiftRight(n) {
  function lbit (line 33653) | function lbit(x) {
  function bnGetLowestSetBit (line 33677) | function bnGetLowestSetBit() {
  function cbit (line 33684) | function cbit(x) {
  function bnBitCount (line 33694) | function bnBitCount() {
  function bnTestBit (line 33702) | function bnTestBit(n) {
  function bnpChangeBit (line 33709) | function bnpChangeBit(n, op) {
  function bnSetBit (line 33716) | function bnSetBit(n) {
  function bnClearBit (line 33721) | function bnClearBit(n) {
  function bnFlipBit (line 33726) | function bnFlipBit(n) {
  function bnpAddTo (line 33731) | function bnpAddTo(a, r) {
  function bnAdd (line 33765) | function bnAdd(a) {
  function bnSubtract (line 33772) | function bnSubtract(a) {
  function bnMultiply (line 33779) | function bnMultiply(a) {
  function bnSquare (line 33786) | function bnSquare() {
  function bnDivide (line 33793) | function bnDivide(a) {
  function bnRemainder (line 33800) | function bnRemainder(a) {
  function bnDivideAndRemainder (line 33807) | function bnDivideAndRemainder(a) {
  function bnpDMultiply (line 33815) | function bnpDMultiply(n) {
  function bnpDAddOffset (line 33822) | function bnpDAddOffset(n, w) {
  function NullExp (line 33834) | function NullExp() {}
  function nNop (line 33835) | function nNop(x) {
  function nMulTo (line 33838) | function nMulTo(x, y, r) {
  function nSqrTo (line 33841) | function nSqrTo(x, r) {
  function bnPow (line 33851) | function bnPow(e) {
  function bnpMultiplyLowerTo (line 33857) | function bnpMultiplyLowerTo(a, n, r) {
  function bnpMultiplyUpperTo (line 33870) | function bnpMultiplyUpperTo(a, n, r) {
  function Barrett (line 33882) | function Barrett(m) {
  function barrettConvert (line 33891) | function barrettConvert(x) {
  function barrettRevert (line 33902) | function barrettRevert(x) {
  function barrettReduce (line 33907) | function barrettReduce(x) {
  function barrettSqrTo (line 33921) | function barrettSqrTo(x, r) {
  function barrettMulTo (line 33927) | function barrettMulTo(x, y, r) {
  function bnModPow (line 33939) | function bnModPow(e, m) {
  function bnGCD (line 34026) | function bnGCD(a) {
  function bnpModInt (line 34058) | function bnpModInt(n) {
  function bnModInverse (line 34069) | function bnModInverse(m) {
  function bnIsProbablePrime (line 34292) | function bnIsProbablePrime(t) {
  function bnpMillerRabin (line 34312) | function bnpMillerRabin(t) {
  function rng_seed_int (line 34412) | function rng_seed_int(x) {
  function rng_seed_time (line 34421) | function rng_seed_time() {
  function rng_get_byte (line 34454) | function rng_get_byte() {
  function rng_get_bytes (line 34467) | function rng_get_bytes(ba) {
  function SecureRandom (line 34472) | function SecureRandom() {}
  function Arcfour (line 34478) | function Arcfour() {
  function ARC4init (line 34485) | function ARC4init(key) {
  function ARC4next (line 34499) | function ARC4next() {
  function prng_newstate (line 34513) | function prng_newstate() {
  function charSet (line 34574) | function charSet(s) {
  function filter (line 34585) | function filter(pattern, options) {
  function ext (line 34592) | function ext(a, b) {
  function minimatch (line 34626) | function minimatch(p, pattern, options) {
  function Minimatch (line 34644) | function Minimatch(pattern, options) {
  function make (line 34676) | function make() {
  function parseNegate (line 34732) | function parseNegate() {
  function braceExpand (line 34765) | function braceExpand(pattern, options) {
  function parse (line 34801) | function parse(pattern, isSub) {
  function makeRe (line 35170) | function makeRe() {
  function match (line 35228) | function match(f, partial) {
  function globUnescape (line 35450) | function globUnescape(s) {
  function regExpEscape (line 35454) | function regExpEscape(s) {
  function once (line 35482) | function once(fn) {
  function onceStrict (line 35492) | function onceStrict(fn) {
  function InnerSubscriber (line 35518) | function InnerSubscriber(parent, outerValue, outerIndex) {
  function fromArray (line 35555) | function fromArray(input, scheduler) {
  function read (line 35617) | function read(buf, options, forceType) {
  function write (line 35723) | function write(key, options, type) {
  function _load_extends (line 35800) | function _load_extends() {
  function _load_asyncToGenerator (line 35806) | function _load_asyncToGenerator() {
  function _load_constants (line 35812) | function _load_constants() {
  function _load_fs (line 35818) | function _load_fs() {
  function _load_npmResolver (line 35824) | function _load_npmResolver() {
  function _load_envReplace (line 35830) | function _load_envReplace() {
  function _load_baseRegistry (line 35836) | function _load_baseRegistry() {
  function _load_misc (line 35842) | function _load_misc() {
  function _load_path (line 35848) | function _load_path() {
  function _load_normalizeUrl (line 35854) | function _load_normalizeUrl() {
  function _load_userHomeDir (line 35860) | function _load_userHomeDir() {
  function _load_userHomeDir2 (line 35866) | function _load_userHomeDir2() {
  function _load_errors (line 35872) | function _load_errors() {
  function _load_login (line 35878) | function _load_login() {
  function _load_path2 (line 35884) | function _load_path2() {
  function _load_url (line 35890) | function _load_url() {
  function _load_ini (line 35896) | function _load_ini() {
  function _interopRequireWildcard (line 35900) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 35915) | function _interopRequireDefault(obj) {
  function getGlobalPrefix (line 35935) | function getGlobalPrefix() {
  function isPathConfigOption (line 35958) | function isPathConfigOption(key) {
  function normalizePath (line 35962) | function normalizePath(val) {
  function urlParts (line 35974) | function urlParts(requestUrl) {
  class NpmRegistry (line 35982) | class NpmRegistry extends (_baseRegistry || _load_baseRegistry()).default {
    method constructor (line 35983) | constructor(cwd, registries, requestManager, reporter, enableDefaultRc...
    method escapeName (line 35988) | static escapeName(name) {
    method isScopedPackage (line 35993) | isScopedPackage(packageIdent) {
    method getRequestUrl (line 35997) | getRequestUrl(registry, pathname) {
    method isRequestToRegistry (line 36010) | isRequestToRegistry(requestUrl, registryUrl) {
    method request (line 36030) | request(pathname, opts = {}, packageName) {
    method requestNeedsAuth (line 36104) | requestNeedsAuth(requestUrl) {
    method checkOutdated (line 36122) | checkOutdated(config, name, range) {
    method getPossibleConfigLocations (line 36163) | getPossibleConfigLocations(filename, reporter) {
    method getConfigEnv (line 36278) | static getConfigEnv(env = process.env) {
    method normalizeConfig (line 36286) | static normalizeConfig(config) {
    method loadConfig (line 36300) | loadConfig() {
    method getScope (line 36347) | getScope(packageIdent) {
    method getRegistry (line 36352) | getRegistry(packageIdent) {
    method getAuthByRegistry (line 36376) | getAuthByRegistry(registry) {
    method getAuth (line 36400) | getAuth(packageIdent) {
    method getScopedOption (line 36444) | getScopedOption(scope, option) {
    method getRegistryOption (line 36448) | getRegistryOption(registry, option) {
    method getRegistryOrGlobalOption (line 36465) | getRegistryOrGlobalOption(registry, option) {
  function _load_baseResolver (line 36484) | function _load_baseResolver() {
  function _interopRequireDefault (line 36488) | function _interopRequireDefault(obj) {
  class ExoticResolver (line 36492) | class ExoticResolver extends (_baseResolver || _load_baseResolver()).def...
    method isVersion (line 36493) | static isVersion(pattern) {
  function _load_normalizePattern (line 36516) | function _load_normalizePattern() {
  class WorkspaceLayout (line 36522) | class WorkspaceLayout {
    method constructor (line 36523) | constructor(workspaces, config) {
    method getWorkspaceManifest (line 36528) | getWorkspaceManifest(key) {
    method getManifestByPattern (line 36532) | getManifestByPattern(pattern) {
  function PromiseCapability (line 36588) | function PromiseCapability(C) {
  function glob (line 36717) | function glob(pattern, options, cb) {
  function extend (line 36735) | function extend(origin, add) {
  function Glob (line 36768) | function Glob(pattern, options, cb) {
  function next (line 36853) | function next() {
  function lstatcb_ (line 37124) | function lstatcb_(er, lstat) {
  function readdirCb (line 37159) | function readdirCb(self, abs, cb) {
  function lstatcb_ (line 37348) | function lstatcb_(er, lstat) {
  function posix (line 37388) | function posix(path) {
  function win32 (line 37392) | function win32(path) {
  function algToKeyType (line 37458) | function algToKeyType(alg) {
  function keyTypeToAlg (line 37468) | function keyTypeToAlg(key) {
  function read (line 37478) | function read(partial, type, buf, options) {
  function write (line 37550) | function write(key, options) {
  function _load_util (line 37603) | function _load_util() {
  function _load_invariant (line 37609) | function _load_invariant() {
  function _load_stripBom (line 37615) | function _load_stripBom() {
  function _load_constants (line 37621) | function _load_constants() {
  function _load_errors (line 37627) | function _load_errors() {
  function _load_map (line 37633) | function _load_map() {
  function _interopRequireDefault (line 37637) | function _interopRequireDefault(obj) {
  function isValidPropValueToken (line 37661) | function isValidPropValueToken(token) {
  function buildToken (line 37670) | function buildToken(type, value) {
  class Parser (line 37782) | class Parser {
    method constructor (line 37783) | constructor(input, fileLoc = 'lockfile') {
    method onComment (line 37789) | onComment(token) {
    method next (line 37814) | next() {
    method unexpected (line 37831) | unexpected(msg = 'Unexpected token') {
    method expect (line 37835) | expect(tokType) {
    method eat (line 37843) | eat(tokType) {
    method parse (line 37852) | parse(indent = 0) {
  function extractConflictVariants (line 37993) | function extractConflictVariants(str) {
  function hasMergeConflicts (line 38036) | function hasMergeConflicts(str) {
  function parse (line 38047) | function parse(str, fileLoc) {
  function parseWithConflict (line 38056) | function parseWithConflict(str, fileLoc) {
  function copy (line 38104) | function copy(o, to) {
  function checkDataType (line 38110) | function checkDataType(dataType, data, negate) {
  function checkDataTypes (line 38158) | function checkDataTypes(dataTypes, data) {
  function coerceToTypes (line 38180) | function coerceToTypes(optionCoerceTypes, dataTypes) {
  function toHash (line 38196) | function toHash(arr) {
  function getProperty (line 38204) | function getProperty(key) {
  function escapeQuotes (line 38212) | function escapeQuotes(str) {
  function varOccurences (line 38221) | function varOccurences(str, dataVar) {
  function varReplace (line 38227) | function varReplace(str, dataVar, expr) {
  function cleanUpCode (line 38236) | function cleanUpCode(out) {
  function finalCleanUpCode (line 38253) | function finalCleanUpCode(out, async) {
  function schemaHasRules (line 38266) | function schemaHasRules(schema, rules) {
  function schemaHasRulesExcept (line 38271) | function schemaHasRulesExcept(schema, rules, exceptKeyword) {
  function toQuotedString (line 38276) | function toQuotedString(str) {
  function getPathExpr (line 38280) | function getPathExpr(currentPath, expr, jsonPointers, isNumber) {
  function getPath (line 38289) | function getPath(currentPath, prop, jsonPointers) {
  function getData (line 38298) | function getData($data, lvl, paths) {
  function joinPaths (line 38336) | function joinPaths(a, b) {
  function unescapeFragment (line 38341) | function unescapeFragment(str) {
  function escapeFragment (line 38345) | function escapeFragment(str) {
  function escapeJsonPointer (line 38349) | function escapeJsonPointer(str) {
  function unescapeJsonPointer (line 38353) | function unescapeJsonPointer(str) {
  function _load_asyncToGenerator (line 38370) | function _load_asyncToGenerator() {
  function revoke (line 38506) | function revoke() {
  function _load_errors (line 38545) | function _load_errors() {
  function _interopRequireDefault (line 38549) | function _interopRequireDefault(obj) {
  function getOneTimePassword (line 38553) | function getOneTimePassword(reporter) {
  function hasWrapper (line 38557) | function hasWrapper(commander, args) {
  function setFlags (line 38561) | function setFlags(commander) {
  function _load_asyncToGenerator (line 38577) | function _load_asyncToGenerator() {
  function _load_format (line 38585) | function _load_format() {
  function _load_index (line 38591) | function _load_index() {
  function _load_isCi (line 38597) | function _load_isCi() {
  function _load_os (line 38603) | function _load_os() {
  function _interopRequireWildcard (line 38607) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 38622) | function _interopRequireDefault(obj) {
  function stringifyLangArgs (line 38631) | function stringifyLangArgs(args) {
  class BaseReporter (line 38655) | class BaseReporter {
    method constructor (line 38656) | constructor(opts = {}) {
    method lang (line 38676) | lang(key, ...args) {
    method rawText (line 38697) | rawText(str) {
    method verbose (line 38705) | verbose(msg) {
    method verboseInspect (line 38711) | verboseInspect(val) {
    method _verbose (line 38717) | _verbose(msg) {}
    method _verboseInspect (line 38718) | _verboseInspect(val) {}
    method _getStandardInput (line 38720) | _getStandardInput() {
    method initPeakMemoryCounter (line 38737) | initPeakMemoryCounter() {
    method checkPeakMemory (line 38746) | checkPeakMemory() {
    method close (line 38756) | close() {
    method getTotalTime (line 38763) | getTotalTime() {
    method list (line 38768) | list(key, items, hints) {}
    method tree (line 38771) | tree(key, obj, {force = false} = {}) {}
    method step (line 38774) | step(current, total, message, emoji) {}
    method error (line 38778) | error(message) {}
    method info (line 38781) | info(message) {}
    method warn (line 38784) | warn(message) {}
    method success (line 38787) | success(message) {}
    method log (line 38791) | log(message, {force = false} = {}) {}
    method command (line 38794) | command(command) {}
    method inspect (line 38797) | inspect(value) {}
    method header (line 38800) | header(command, pkg) {}
    method footer (line 38803) | footer(showPeakMemory) {}
    method table (line 38806) | table(head, body) {}
    method auditAction (line 38809) | auditAction(recommendation) {}
    method auditManualReview (line 38812) | auditManualReview() {}
    method auditAdvisory (line 38815) | auditAdvisory(resolution, auditAdvisory) {}
    method auditSummary (line 38818) | auditSummary(auditMetadata) {}
    method activity (line 38821) | activity() {
    method activitySet (line 38829) | activitySet(total, workers) {
    method question (line 38842) | question(question, options = {}) {
    method questionAffirm (line 38847) | questionAffirm(question) {
    method select (line 38875) | select(header, question, options) {
    method progress (line 38880) | progress(total) {
    method disableProgress (line 38885) | disableProgress() {
    method prompt (line 38890) | prompt(message, choices, options = {}) {
  function _load_asyncToGenerator (line 38908) | function _load_asyncToGenerator() {
  function _load_errors (line 38916) | function _load_errors() {
  function _load_index (line 38922) | function _load_index() {
  function _load_gitResolver (line 38928) | function _load_gitResolver() {
  function _load_exoticResolver (line 38934) | function _load_exoticResolver() {
  function _load_git (line 38940) | function _load_git() {
  function _load_guessName (line 38946) | function _load_guessName() {
  function _interopRequireDefault (line 38950) | function _interopRequireDefault(obj) {
  function parseHash (line 38954) | function parseHash(fragment) {
  function explodeHostedGitFragment (line 38959) | function explodeHostedGitFragment(fragment, reporter) {
  class HostedGitResolver (line 38989) | class HostedGitResolver extends (_exoticResolver || _load_exoticResolver...
    method constructor (line 38990) | constructor(request, fragment) {
    method getTarballUrl (line 39003) | static getTarballUrl(exploded, commit) {
    method getGitHTTPUrl (line 39009) | static getGitHTTPUrl(exploded) {
    method getGitHTTPBaseUrl (line 39014) | static getGitHTTPBaseUrl(exploded) {
    method getGitSSHUrl (line 39019) | static getGitSSHUrl(exploded) {
    method getHTTPFileUrl (line 39024) | static getHTTPFileUrl(exploded, filename, commit) {
    method getRefOverHTTP (line 39031) | getRefOverHTTP(url) {
    method resolveOverHTTP (line 39067) | resolveOverHTTP(url) {
    method hasHTTPCapability (line 39140) | hasHTTPCapability(url) {
    method resolve (line 39155) | resolve() {
  function _load_map (line 39216) | function _load_map() {
  function _interopRequireDefault (line 39220) | function _interopRequireDefault(obj) {
  class BlockingQueue (line 39226) | class BlockingQueue {
    method constructor (line 39227) | constructor(alias, maxConcurrency = Infinity) {
    method stillActive (line 39241) | stillActive() {
    method stuckTick (line 39253) | stuckTick() {
    method push (line 39263) | push(key, factory) {
    method shift (line 39281) | shift(key) {
    method maybePushConcurrencyQueue (line 39340) | maybePushConcurrencyQueue(run) {
    method shiftConcurrencyQueue (line 39348) | shiftConcurrencyQueue() {
  function isArray (line 39399) | function isArray(arg) {
  function isBoolean (line 39407) | function isBoolean(arg) {
  function isNull (line 39412) | function isNull(arg) {
  function isNullOrUndefined (line 39417) | function isNullOrUndefined(arg) {
  function isNumber (line 39422) | function isNumber(arg) {
  function isString (line 39427) | function isString(arg) {
  function isSymbol (line 39432) | function isSymbol(arg) {
  function isUndefined (line 39437) | function isUndefined(arg) {
  function isRegExp (line 39442) | function isRegExp(re) {
  function isObject (line 39447) | function isObject(arg) {
  function isDate (line 39452) | function isDate(d) {
  function isError (line 39457) | function isError(e) {
  function isFunction (line 39462) | function isFunction(arg) {
  function isPrimitive (line 39467) | function isPrimitive(arg) {
  function objectToString (line 39481) | function objectToString(o) {
  function micromatch (line 39510) | function micromatch(files, patterns, opts) {
  function match (line 39551) | function match(files, pattern, opts) {
  function filter (line 39633) | function filter(patterns, opts) {
  function isMatch (line 39681) | function isMatch(fp, pattern, opts) {
  function contains (line 39698) | function contains(fp, pattern, opts) {
  function any (line 39723) | function any(fp, patterns, opts) {
  function matchKeys (line 39750) | function matchKeys(obj, glob, options) {
  function matcher (line 39775) | function matcher(pattern, opts) {
  function toRegex (line 39824) | function toRegex(glob, options) {
  function wrapGlob (line 39861) | function wrapGlob(glob, opts) {
  function makeRe (line 39881) | function makeRe(glob, opts) {
  function msg (line 39903) | function msg(method, what, type) {
  function Duplex (line 39998) | function Duplex(options) {
  function onend (line 40025) | function onend() {
  function onEndNT (line 40035) | function onEndNT(self) {
  function multicast (line 40079) | function multicast(subjectOrSubjectFactory, selector) {
  function MulticastOperator (line 40104) | function MulticastOperator(subjectFactory, selector) {
  function identity (line 40139) | function identity(x) {
  function _load_asyncToGenerator (line 40170) | function _load_asyncToGenerator() {
  function _load_fs (line 40211) | function _load_fs() {
  function _load_fs2 (line 40217) | function _load_fs2() {
  function _load_path (line 40223) | function _load_path() {
  function _interopRequireDefault (line 40227) | function _interopRequireDefault(obj) {
  function _load_asyncToGenerator (line 40255) | function _load_asyncToGenerator() {
  function throwPermError (line 40450) | function throwPermError(err, dest) {
  function _load_errors (line 40603) | function _load_errors() {
  function _load_index (line 40609) | function _load_index() {
  function _load_baseReporter (line 40615) | function _load_baseReporter() {
  function _load_buildSubCommands (line 40621) | function _load_buildSubCommands() {
  function _load_lockfile (line 40627) | function _load_lockfile() {
  function _load_install (line 40633) | function _load_install() {
  function _load_add (line 40639) | function _load_add() {
  function _load_remove (line 40645) | function _load_remove() {
  function _load_upgrade (line 40651) | function _load_upgrade() {
  function _load_upgradeInteractive (line 40657) | function _load_upgradeInteractive() {
  function _load_packageLinker (line 40663) | function _load_packageLinker() {
  function _load_constants (line 40669) | function _load_constants() {
  function _load_fs (line 40675) | function _load_fs() {
  function _interopRequireWildcard (line 40679) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 40694) | function _interopRequireDefault(obj) {
  class GlobalAdd (line 40698) | class GlobalAdd extends (_add || _load_add()).Add {
    method constructor (line 40699) | constructor(args, flags, config, reporter, lockfile) {
    method maybeOutputSaveTree (line 40705) | maybeOutputSaveTree() {
    method _logSuccessSaveLockfile (line 40733) | _logSuccessSaveLockfile() {
  function hasWrapper (line 40740) | function hasWrapper(flags, args) {
  function ls (line 40744) | function ls(manifest, reporter, saved) {
  method add (line 40762) | add(config, reporter, flags, args) {
  method bin (line 40783) | bin(config, reporter, flags, args) {
  method dir (line 40789) | dir(config, reporter, flags, args) {
  method ls (line 40794) | ls(config, reporter, flags, args) {
  method list (line 40801) | list(config, reporter, flags, args) {
  method remove (line 40807) | remove(config, reporter, flags, args) {
  method upgrade (line 40821) | upgrade(config, reporter, flags, args) {
  method upgradeInteractive (line 40835) | upgradeInteractive(config, reporter, flags, args) {
  function setFlags (line 40856) | function setFlags(commander) {
  function _load_asyncToGenerator (line 40875) | function _load_asyncToGenerator() {
  function _load_path (line 40881) | function _load_path() {
  function _load_invariant (line 40887) | function _load_invariant() {
  function _load_semver (line 40893) | function _load_semver() {
  function _load_validate (line 40899) | function _load_validate() {
  function _load_lockfile (line 40905) | function _load_lockfile() {
  function _load_packageReference (line 40911) | function _load_packageReference() {
  function _load_index (line 40917) | function _load_index() {
  function _load_errors (line 40923) | function _load_errors() {
  function _load_constants (line 40929) | function _load_constants() {
  function _load_version (line 40935) | function _load_version() {
  function _load_workspaceResolver (line 40941) | function _load_workspaceResolver() {
  function _load_fs (line 40947) | function _load_fs() {
  function _load_normalizePattern (line 40953) | function _load_normalizePattern() {
  function _interopRequireWildcard (line 40957) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 40972) | function _interopRequireDefault(obj) {
  class PackageRequest (line 40978) | class PackageRequest {
    method constructor (line 40979) | constructor(req, resolver) {
    method init (line 40993) | init() {
    method getLocked (line 40997) | getLocked(remoteType) {
    method findVersionOnRegistry (line 41036) | findVersionOnRegistry(pattern) {
    method getRegistryResolver (line 41091) | getRegistryResolver() {
    method normalizeRange (line 41102) | normalizeRange(pattern) {
    method normalize (line 41137) | normalize(pattern) {
    method findExoticVersionInfo (line 41157) | findExoticVersionInfo(ExoticResolver, range) {
    method findVersionInfo (line 41167) | findVersionInfo() {
    method reportResolvedRangeMatch (line 41213) | reportResolvedRangeMatch(info, resolved) {}
    method resolveToExistingVersion (line 41220) | resolveToExistingVersion(info) {
    method find (line 41251) | find({fresh, frozen}) {
    method validateVersionInfo (line 41427) | static validateVersionInfo(info, reporter) {
    method getPackageVersion (line 41466) | static getPackageVersion(info) {
    method getOutdatedPackages (line 41475) | static getOutdatedPackages(lockfile, install, config, reporter, filter...
  class BaseResolver (line 41606) | class BaseResolver {
    method constructor (line 41607) | constructor(request, fragment) {
    method fork (line 41617) | fork(Resolver, resolveArg, ...args) {
    method resolve (line 41623) | resolve(resolveArg) {
  function _load_asyncToGenerator (line 41641) | function _load_asyncToGenerator() {
  function _load_index (line 41647) | function _load_index() {
  function _load_misc (line 41653) | function _load_misc() {
  function _load_version (line 41659) | function _load_version() {
  function _load_guessName (line 41665) | function _load_guessName() {
  function _load_index2 (line 41671) | function _load_index2() {
  function _load_exoticResolver (line 41677) | function _load_exoticResolver() {
  function _load_git (line 41683) | function _load_git() {
  function _interopRequireWildcard (line 41687) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 41702) | function _interopRequireDefault(obj) {
  class GitResolver (line 41718) | class GitResolver extends (_exoticResolver || _load_exoticResolver()).de...
    method constructor (line 41719) | constructor(request, fragment) {
    method isVersion (line 41731) | static isVersion(pattern) {
    method resolve (line 41772) | resolve(forked) {
  function _load_extends (line 41890) | function _load_extends() {
  function _load_asyncToGenerator (line 41896) | function _load_asyncToGenerator() {
  function _load_errors (line 42378) | function _load_errors() {
  function _load_constants (line 42384) | function _load_constants() {
  function _load_child (line 42390) | function _load_child() {
  function _load_fs (line 42396) | function _load_fs() {
  function _load_dynamicRequire (line 42402) | function _load_dynamicRequire() {
  function _load_portableScript (line 42408) | function _load_portableScript() {
  function _load_fixCmdWinSlashes (line 42414) | function _load_fixCmdWinSlashes() {
  function _load_global (line 42420) | function _load_global() {
  function _interopRequireWildcard (line 42424) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 42439) | function _interopRequireDefault(obj) {
  function checkForGypIfNeeded (line 42468) | function checkForGypIfNeeded(config, cmd, paths) {
  function _load_errors (line 42580) | function _load_errors() {
  function _load_util (line 42586) | function _load_util() {
  function _load_typos (line 42592) | function _load_typos() {
  function _interopRequireDefault (line 42596) | function _interopRequireDefault(obj) {
  function isValidName (line 42616) | function isValidName(name) {
  function isValidScopedName (line 42620) | function isValidScopedName(name) {
  function isValidPackageName (line 42629) | function isValidPackageName(name) {
  function cleanDependencies (line 42633) | function cleanDependencies(info, isRoot, reporter, warn) {
  function selectColor (line 43174) | function selectColor(namespace) {
  function createDebug (line 43194) | function createDebug(namespace) {
  function destroy (line 43265) | function destroy() {
  function enable (line 43283) | function enable(namespaces) {
  function disable (line 43315) | function disable() {
  function enabled (line 43327) | function enabled(name) {
  function coerce (line 43353) | function coerce(val) {
  function ECFieldElementFp (line 43374) | function ECFieldElementFp(q, x) {
  function feFpEquals (line 43380) | function feFpEquals(other) {
  function feFpToBigInteger (line 43385) | function feFpToBigInteger() {
  function feFpNegate (line 43389) | function feFpNegate() {
  function feFpAdd (line 43393) | function feFpAdd(b) {
  function feFpSubtract (line 43397) | function feFpSubtract(b) {
  function feFpMultiply (line 43401) | function feFpMultiply(b) {
  function feFpSquare (line 43405) | function feFpSquare() {
  function feFpDivide (line 43409) | function feFpDivide(b) {
  function ECPointFp (line 43429) | function ECPointFp(curve, x, y, z) {
  function pointFpGetX (line 43444) | function pointFpGetX() {
  function pointFpGetY (line 43453) | function pointFpGetY() {
  function pointFpEquals (line 43462) | function pointFpEquals(other) {
  function pointFpIsInfinity (line 43483) | function pointFpIsInfinity() {
  function pointFpNegate (line 43488) | function pointFpNegate() {
  function pointFpAdd (line 43492) | function pointFpAdd(b) {
  function pointFpTwice (line 43557) | function pointFpTwice() {
  function pointFpMultiply (line 43610) | function pointFpMultiply(k) {
  function pointFpMultiplyTwo (line 43636) | function pointFpMultiplyTwo(j, x, k) {
  function ECCurveFp (line 43676) | function ECCurveFp(q, a, b) {
  function curveFpGetQ (line 43684) | function curveFpGetQ() {
  function curveFpGetA (line 43688) | function curveFpGetA() {
  function curveFpGetB (line 43692) | function curveFpGetB() {
  function curveFpEquals (line 43696) | function curveFpEquals(other) {
  function curveFpGetInfinity (line 43701) | function curveFpGetInfinity() {
  function curveFpFromBigInteger (line 43705) | function curveFpFromBigInteger(x) {
  function curveReduce (line 43709) | function curveReduce(x) {
  function curveFpDecodePointHex (line 43714) | function curveFpDecodePointHex(s) {
  function curveFpEncodePointHex (line 43743) | function curveFpEncodePointHex(p) {
  function newError (line 44000) | function newError(er) {
  function realpath (line 44008) | function realpath(p, cache, cb) {
  function realpathSync (line 44026) | function realpathSync(p, cache) {
  function monkeypatch (line 44042) | function monkeypatch() {
  function unmonkeypatch (line 44047) | function unmonkeypatch() {
  function ownProp (line 44066) | function ownProp(obj, field) {
  function alphasorti (line 44075) | function alphasorti(a, b) {
  function alphasort (line 44079) | function alphasort(a, b) {
  function setupIgnores (line 44083) | function setupIgnores(self, options) {
  function ignoreMap (line 44094) | function ignoreMap(pattern) {
  function setopts (line 44107) | function setopts(self, pattern, options) {
  function finish (line 44171) | function finish(self) {
  function mark (line 44222) | function mark(self, p) {
  function makeAbs (line 44244) | function makeAbs(self, f) {
  function isIgnored (line 44263) | function isIgnored(self, path) {
  function childrenIgnored (line 44271) | function childrenIgnored(self, path) {
  function mkdirP (line 44299) | function mkdirP(p, opts, f, made) {
  function defaultIfEmpty (line 44399) | function defaultIfEmpty(defaultValue) {
  function DefaultIfEmptyOperator (line 44408) | function DefaultIfEmptyOperator(defaultValue) {
  function DefaultIfEmptySubscriber (line 44418) | function DefaultIfEmptySubscriber(destination, defaultValue) {
  function filter (line 44448) | function filter(predicate, thisArg) {
  function FilterOperator (line 44454) | function FilterOperator(predicate, thisArg) {
  function FilterSubscriber (line 44465) | function FilterSubscriber(destination, predicate, thisArg) {
  function mergeMap (line 44512) | function mergeMap(project, resultSelector, concurrent) {
  function MergeMapOperator (line 44540) | function MergeMapOperator(project, concurrent) {
  function MergeMapSubscriber (line 44555) | function MergeMapSubscriber(destination, project, concurrent) {
  function AsyncAction (line 44642) | function AsyncAction(scheduler, work) {
  function AsyncScheduler (line 44744) | function AsyncScheduler(SchedulerAction, now) {
  function getSymbolIterator (line 44808) | function getSymbolIterator() {
  function ArgumentOutOfRangeErrorImpl (line 44827) | function ArgumentOutOfRangeErrorImpl() {
  function EmptyErrorImpl (line 44846) | function EmptyErrorImpl() {
  function isFunction (line 44863) | function isFunction(x) {
  function Certificate (line 44897) | function Certificate(opts) {
  function Fingerprint (line 45230) | function Fingerprint(opts) {
  function addColons (line 45339) | function addColons(s) {
  function base64Strip (line 45344) | function base64Strip(s) {
  function sshBase64Format (line 45349) | function sshBase64Format(alg, h) {
  function read (line 45395) | function read(buf, options) {
  function write (line 45399) | function write(key, options) {
  function readMPInt (line 45404) | function readMPInt(der, nm) {
  function readPkcs8 (line 45409) | function readPkcs8(alg, type, der) {
  function readPkcs8RSAPublic (line 45448) | function readPkcs8RSAPublic(der) {
  function readPkcs8RSAPrivate (line 45468) | function readPkcs8RSAPrivate(der) {
  function readPkcs8DSAPublic (line 45503) | function readPkcs8DSAPublic(der) {
  function readPkcs8DSAPrivate (line 45530) | function readPkcs8DSAPrivate(der) {
  function readECDSACurve (line 45557) | function readECDSACurve(der) {
  function readPkcs8ECDSAPrivate (line 45645) | function readPkcs8ECDSAPrivate(der) {
  function readPkcs8ECDSAPublic (line 45673) | function readPkcs8ECDSAPublic(der) {
  function readPkcs8EdDSAPublic (line 45688) | function readPkcs8EdDSAPublic(der) {
  function readPkcs8X25519Public (line 45701) | function readPkcs8X25519Public(der) {
  function readPkcs8EdDSAPrivate (line 45712) | function readPkcs8EdDSAPrivate(der) {
  function readPkcs8X25519Private (line 45738) | function readPkcs8X25519Private(der) {
  function writePkcs8 (line 45758) | function writePkcs8(der, key) {
  function writePkcs8RSAPrivate (line 45796) | function writePkcs8RSAPrivate(key, der) {
  function writePkcs8RSAPublic (line 45820) | function writePkcs8RSAPublic(key, der) {
  function writePkcs8DSAPrivate (line 45835) | function writePkcs8DSAPrivate(key, der) {
  function writePkcs8DSAPublic (line 45849) | function writePkcs8DSAPublic(key, der) {
  function writeECDSACurve (line 45863) | function writeECDSACurve(key, der) {
  function writePkcs8ECDSAPublic (line 45903) | function writePkcs8ECDSAPublic(key, der) {
  function writePkcs8ECDSAPrivate (line 45911) | function writePkcs8ECDSAPrivate(key, der) {
  function writePkcs8EdDSAPublic (line 45932) | function writePkcs8EdDSAPublic(key, der) {
  function writePkcs8EdDSAPrivate (line 45938) | function writePkcs8EdDSAPrivate(key, der) {
  function Identity (line 45986) | function Identity(opts) {
  function globMatch (line 46104) | function globMatch(a, b) {
  function SSHBuffer (line 46232) | function SSHBuffer(opts) {
  function wrappy (line 46395) | function wrappy(fn, cb) {
  function _load_extends (line 46434) | function _load_extends() {
  function _load_asyncToGenerator (line 46440) | function _load_asyncToGenerator() {
  function _load_executeLifecycleScript (line 46448) | function _load_executeLifecycleScript() {
  function _load_path (line 46454) | function _load_path() {
  function _load_conversion (line 46460) | function _load_conversion() {
  function _load_index (line 46466) | function _load_index() {
  function _load_errors (line 46472) | function _load_errors() {
  function _load_fs (line 46478) | function _load_fs() {
  function _load_constants (line 46484) | function _load_constants() {
  function _load_packageConstraintResolver (line 46490) | function _load_packageConstraintResolver() {
  function _load_requestManager (line 46496) | function _load_requestManager() {
  function _load_index2 (line 46502) | function _load_index2() {
  function _load_index3 (line 46508) | function _load_index3() {
  function _load_map (line 46514) | function _load_map() {
  function _interopRequireWildcard (line 46518) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 46533) | function _interopRequireDefault(obj) {
  function sortObject (line 46543) | function sortObject(object) {
  class Config (line 46553) | class Config {
    method constructor (line 46554) | constructor(reporter) {
    method getCache (line 46606) | getCache(key, factory) {
    method getOption (line 46622) | getOption(key, resolve = false) {
    method resolveConstraints (line 46636) | resolveConstraints(versions, range) {
    method init (line 46644) | init(opts = {}) {
    method _init (line 46943) | _init(opts) {
    method generateUniquePackageSlug (line 46993) | generateUniquePackageSlug(pkg) {
    method generateModuleCachePath (line 47024) | generateModuleCachePath(pkg) {
    method getUnpluggedPath (line 47035) | getUnpluggedPath() {
    method generatePackageUnpluggedPath (line 47042) | generatePackageUnpluggedPath(pkg) {
    method listUnpluggedPackageFolders (line 47050) | listUnpluggedPackageFolders() {
    method executeLifecycleScript (line 47103) | executeLifecycleScript(commandName, cwd) {
    method getTemp (line 47120) | getTemp(filename) {
    method getOfflineMirrorPath (line 47131) | getOfflineMirrorPath(packageFilename) {
    method isValidModuleDest (line 47172) | isValidModuleDest(dest) {
    method readPackageMetadata (line 47194) | readPackageMetadata(dir) {
    method readManifest (line 47221) | readManifest(dir, priorityRegistry, isRoot = false) {
    method maybeReadManifest (line 47246) | maybeReadManifest(dir, priorityRegistry, isRoot = false) {
    method readRootManifest (line 47310) | readRootManifest() {
    method tryManifest (line 47318) | tryManifest(dir, registry, isRoot) {
    method findManifest (line 47336) | findManifest(dir, isRoot) {
    method findWorkspaceRoot (line 47372) | findWorkspaceRoot(initial) {
    method resolveWorkspaces (line 47404) | resolveWorkspaces(root, rootManifest) {
    method getWorkspaces (line 47495) | getWorkspaces(manifest, shouldThrow = false) {
    method getFolder (line 47545) | getFolder(pkg) {
    method getRootManifests (line 47559) | getRootManifests() {
    method saveRootManifests (line 47608) | saveRootManifests(manifests) {
    method readJson (line 47683) | readJson(loc, factory = (_fs || _load_fs()).readJson) {
    method create (line 47697) | static create(opts = {}, reporter = new (_index3 || _load_index3()).No...
  function extractWorkspaces (line 47707) | function extractWorkspaces(manifest) {
  function _load_asyncToGenerator (line 47772) | function _load_asyncToGenerator() {
  function _load_extends (line 47778) | function _load_extends() {
  function _load_lockfile (line 47820) | function _load_lockfile() {
  function _load_normalizePattern (line 47826) | function _load_normalizePattern() {
  function _load_workspaceLayout (line 47832) | function _load_workspaceLayout() {
  function _load_index (line 47838) | function _load_index() {
  function _load_list (line 47844) | function _load_list() {
  function _load_install (line 47850) | function _load_install() {
  function _load_errors (line 47856) | function _load_errors() {
  function _load_constants (line 47862) | function _load_constants() {
  function _load_fs (line 47868) | function _load_fs() {
  function _load_invariant (line 47874) | function _load_invariant() {
  function _load_path (line 47880) | function _load_path() {
  function _load_semver (line 47886) | function _load_semver() {
  function _interopRequireWildcard (line 47890) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 47905) | function _interopRequireDefault(obj) {
  class Add (line 47911) | class Add extends (_install || _load_install()).Install {
    method constructor (line 47912) | constructor(args, flags, config, reporter, lockfile) {
    method prepareRequests (line 47934) | prepareRequests(requests) {
    method getPatternVersion (line 47970) | getPatternVersion(pattern, pkg) {
    method preparePatterns (line 48011) | preparePatterns(patterns) {
    method preparePatternsForLinking (line 48048) | preparePatternsForLinking(patterns, cwdManifest, cwdIsRoot) {
    method bailout (line 48094) | bailout(patterns, workspaceLayout) {
    method init (line 48126) | init() {
    method applyChanges (line 48148) | applyChanges(manifests) {
    method fetchRequestFromCwd (line 48195) | fetchRequestFromCwd() {
    method maybeOutputSaveTree (line 48206) | maybeOutputSaveTree(patterns) {
    method savePackages (line 48284) | savePackages() {
    method _iterateAddedPackages (line 48288) | _iterateAddedPackages(f) {
  function hasWrapper (line 48335) | function hasWrapper(commander) {
  function setFlags (line 48339) | function setFlags(commander) {
  function _load_asyncToGenerator (line 48367) | function _load_asyncToGenerator() {
  function _load_fs (line 48632) | function _load_fs() {
  function _load_filter (line 48638) | function _load_filter() {
  function _load_errors (line 48644) | function _load_errors() {
  function _interopRequireWildcard (line 48648) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 48663) | function _interopRequireDefault(obj) {
  function packWithIgnoreAndHeaders (line 48708) | function packWithIgnoreAndHeaders(cwd, ignoreFunction, {mapHeader} = {}) {
  function setFlags (line 48721) | function setFlags(commander) {
  function hasWrapper (line 48726) | function hasWrapper(commander, args) {
  function _load_asyncToGenerator (line 48742) | function _load_asyncToGenerator() {
  function _load_index (line 48748) | function _load_index() {
  function _load_constants (line 48754) | function _load_constants() {
  function _load_fs (line 48760) | function _load_fs() {
  function _load_mutex (line 48766) | function _load_mutex() {
  function _interopRequireWildcard (line 48770) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 48785) | function _interopRequireDefault(obj) {
  class BaseFetcher (line 48794) | class BaseFetcher {
    method constructor (line 48795) | constructor(dest, remote, config) {
    method setupMirrorFromCache (line 48806) | setupMirrorFromCache() {
    method _fetch (line 48812) | _fetch() {
    method fetch (line 48816) | fetch(defaultManifest) {
  function hash (line 48937) | function hash(content, type = 'md5') {
  class HashStream (line 48944) | class HashStream extends stream.Transform {
    method constructor (line 48945) | constructor(options) {
    method _transform (line 48951) | _transform(chunk, encoding, callback) {
    method getHash (line 48957) | getHash() {
    method test (line 48961) | test(sum) {
  function _load_url (line 48980) | function _load_url() {
  function _interopRequireDefault (line 48984) | function _interopRequireDefault(obj) {
  function cleanup (line 48988) | function cleanup(name) {
  function guessNameFallback (line 48993) | function guessNameFallback(source) {
  function guessName (line 48999) | function guessName(source) {
  function HttpSignatureError (line 49211) | function HttpSignatureError(message, caller) {
  function InvalidAlgorithmError (line 49219) | function InvalidAlgorithmError(message) {
  function validateAlgorithm (line 49224) | function validateAlgorithm(algorithm) {
  class Separator (line 49320) | class Separator {
    method constructor (line 49321) | constructor(line) {
    method toString (line 49330) | toString() {
  class Paginator (line 49361) | class Paginator {
    method constructor (line 49362) | constructor(screen) {
    method paginate (line 49368) | paginate(output, active, pageSize) {
  function nextTick (line 49574) | function nextTick(fn, arg1, arg2, arg3) {
  function AsyncSubject (line 50229) | function AsyncSubject() {
  function Notification (line 50290) | function Notification(kind, value, error) {
  method useDeprecatedSynchronousErrorHandling (line 50373) | set useDeprecatedSynchronousErrorHandling(value) {
  method useDeprecatedSynchronousErrorHandling (line 50385) | get useDeprecatedSynchronousErrorHandling() {
  function concat (line 50407) | function concat() {
  function reduce (line 50443) | function reduce(accumulator, seed) {
  function defaultErrorFactory (line 50503) | function defaultErrorFactory() {
  function ObjectUnsubscribedErrorImpl (line 50517) | function ObjectUnsubscribedErrorImpl() {
  function isNumeric (line 50536) | function isNumeric(val) {
  function noop (line 50551) | function noop() {}
  function read (line 50582) | function read(buf, options) {
  function readSSHPrivate (line 50588) | function readSSHPrivate(type, buf, options) {
  function write (line 50688) | function write(key, options) {
  function validate (line 51169) | function validate(fs, name, root, cb) {
  function mkdirfix (line 51178) | function mkdirfix(name, opts, cb) {
  function _load_misc (line 51376) | function _load_misc() {
  function _load_constants (line 51382) | function _load_constants() {
  function _load_package (line 51388) | function _load_package() {
  function shouldWrapKey (line 51394) | function shouldWrapKey(str) {
  function maybeWrap (line 51404) | function maybeWrap(str) {
  function priorityThenAlphaSort (line 51422) | function priorityThenAlphaSort(a, b) {
  function _stringify (line 51430) | function _stringify(obj, options) {
  function stringify (line 51486) | function stringify(obj, noHeader, enableVersions) {
  function _load_consoleReporter (line 51520) | function _load_consoleReporter() {
  function _load_bufferReporter (line 51533) | function _load_bufferReporter() {
  function _load_eventReporter (line 51546) | function _load_eventReporter() {
  function _load_jsonReporter (line 51559) | function _load_jsonReporter() {
  function _load_noopReporter (line 51572) | function _load_noopReporter() {
  function _load_baseReporter (line 51585) | function _load_baseReporter() {
  function _interopRequireDefault (line 51596) | function _interopRequireDefault(obj) {
  function cmdShimIfExists (line 51631) | function cmdShimIfExists(src, to, opts) {
  function rm (line 51641) | function rm(path) {
  function cmdShim (line 51645) | function cmdShim(src, to, opts) {
  function cmdShim_ (line 51650) | function cmdShim_(src, to, opts) {
  function writeShim (line 51656) | function writeShim(src, to, opts) {
  function writeShim_ (line 51680) | function writeShim_(src, to, opts) {
  function chmodShim (line 51867) | function chmodShim(to, {createCmdFile, createPwshFile}) {
  function normalizePathEnvVar (line 51879) | function normalizePathEnvVar(nodePath) {
  function ValidationError (line 51919) | function ValidationError(errors) {
  function MissingRefError (line 51929) | function MissingRefError(baseId, ref, message) {
  function errorSubclass (line 51935) | function errorSubclass(Subclass) {
  function resolve (line 51970) | function resolve(compile, root, ref) {
  function resolveSchema (line 52011) | function resolveSchema(root, ref) {
  function resolveRecursive (line 52041) | function resolveRecursive(root, ref, parsedRef) {
  function getJsonPointer (line 52062) | function getJsonPointer(parsedRef, baseId, schema, root) {
  function inlineRef (line 52111) | function inlineRef(schema, limit) {
  function checkNoRef (line 52117) | function checkNoRef(schema) {
  function countKeys (line 52134) | function countKeys(schema) {
  function getFullPath (line 52158) | function getFullPath(id, normalize) {
  function _getFullPath (line 52164) | function _getFullPath(p) {
  function normalizeId (line 52170) | function normalizeId(id) {
  function resolveUrl (line 52174) | function resolveUrl(baseId, id) {
  function resolveIds (line 52180) | function resolveIds(schema) {
  function _load_asyncToGenerator (line 52354) | function _load_asyncToGenerator() {
  function _load_add (line 52486) | function _load_add() {
  function _load_lockfile (line 52492) | function _load_lockfile() {
  function _load_packageRequest (line 52498) | function _load_packageRequest() {
  function _load_normalizePattern (line 52504) | function _load_normalizePattern() {
  function _load_install (line 52510) | function _load_install() {
  function _interopRequireDefault (line 52514) | function _interopRequireDefault(obj) {
  function setUserRequestedPackageVersions (line 52528) | function setUserRequestedPackageVersions(deps, args, latest, packagePatt...
  function getRangeOperator (line 52588) | function getRangeOperator(version) {
  function buildPatternToUpgradeTo (line 52595) | function buildPatternToUpgradeTo(dep, flags) {
  function scopeFilter (line 52619) | function scopeFilter(flags, dep) {
  function cleanLockfile (line 52631) | function cleanLockfile(lockfile, deps, packagePatterns, reporter) {
  function setFlags (line 52658) | function setFlags(commander) {
  function hasWrapper (line 52684) | function hasWrapper(commander, args) {
  function _load_extends (line 52703) | function _load_extends() {
  function _load_asyncToGenerator (line 52709) | function _load_asyncToGenerator() {
  function _load_constants (line 52715) | function _load_constants() {
  function _load_fs (line 52721) | function _load_fs() {
  function _load_misc (line 52727) | function _load_misc() {
  function _load_packageNameUtils (line 52733) | function _load_packageNameUtils() {
  function _load_workspaceLayout (line 52739) | function _load_workspaceLayout() {
  function _interopRequireWildcard (line 52743) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 52758) | function _interopRequireDefault(obj) {
  class InstallationIntegrityChecker (line 52790) | class InstallationIntegrityChecker {
    method constructor (line 52791) | constructor(config) {
    method _getModulesRootFolder (line 52799) | _getModulesRootFolder() {
    method _getIntegrityFileFolder (line 52816) | _getIntegrityFileFolder() {
    method _getIntegrityFileLocation (line 52836) | _getIntegrityFileLocation() {
    method _getModulesFolders (line 52860) | _getModulesFolders({workspaceLayout} = {}) {
    method _getIntegrityListing (line 52912) | _getIntegrityListing({workspaceLayout} = {}) {
    method _generateIntegrityFile (line 52993) | _generateIntegrityFile(lockfile, patterns, flags, workspaceLayout, art...
    method _getIntegrityFile (line 53199) | _getIntegrityFile(locationPath) {
    method _compareIntegrityFiles (line 53213) | _compareIntegrityFiles(actual, expected, checkFiles, workspaceLayout) {
    method check (line 53331) | check(patterns, lockfile, flags, workspaceLayout) {
    method getArtifacts (line 53409) | getArtifacts() {
    method save (line 53433) | save(patterns, lockfile, flags, workspaceLayout, artifacts) {
    method removeIntegrityFile (line 53456) | removeIntegrityFile() {
  function _load_asyncToGenerator (line 53482) | function _load_asyncToGenerator() {
  function _load_errors (line 53592) | function _load_errors() {
  function _load_index (line 53598) | function _load_index() {
  function _load_fs (line 53604) | function _load_fs() {
  function _load_promise (line 53610) | function _load_promise() {
  function _interopRequireWildcard (line 53614) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 53629) | function _interopRequireDefault(obj) {
  function fetchOne (line 53633) | function fetchOne(ref, config) {
  function fetch (line 53639) | function fetch(pkgs, config) {
  function _load_asyncToGenerator (line 53736) | function _load_asyncToGenerator() {
  function _load_packageHoister (line 53766) | function _load_packageHoister() {
  function _load_constants (line 53772) | function _load_constants() {
  function _load_promise (line 53778) | function _load_promise() {
  function _load_normalizePattern (line 53784) | function _load_normalizePattern() {
  function _load_misc (line 53790) | function _load_misc() {
  function _load_fs (line 53796) | function _load_fs() {
  function _load_mutex (line 53802) | function _load_mutex() {
  function _load_semver (line 53808) | function _load_semver() {
  function _load_workspaceLayout (line 53814) | function _load_workspaceLayout() {
  function _interopRequireWildcard (line 53818) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 53833) | function _interopRequireDefault(obj) {
  class PackageLinker (line 53845) | class PackageLinker {
    method constructor (line 53846) | constructor(config, resolver) {
    method setArtifacts (line 53855) | setArtifacts(artifacts) {
    method setTopLevelBinLinking (line 53859) | setTopLevelBinLinking(topLevelBinLinking) {
    method linkSelfDependencies (line 53863) | linkSelfDependencies(pkg, pkgLoc, targetBinLoc, override = false) {
    method linkBinDependencies (line 53905) | linkBinDependencies(pkg, dir) {
    method findNearestInstalledVersionOfPackage (line 54039) | findNearestInstalledVersionOfPackage(pkg, binLoc) {
    method getFlatHoistedTree (line 54115) | getFlatHoistedTree(patterns, workspaceLayout, {ignoreOptional} = {}) {
    method copyModules (line 54128) | copyModules(patterns, workspaceLayout, {linkDuplicates, ignoreOptional...
    method _buildTreeHash (line 54783) | _buildTreeHash(flatTree) {
    method getParentBinLoc (line 54815) | getParentBinLoc(parts, flatTree) {
    method determineTopLevelBinLinkOrder (line 54830) | determineTopLevelBinLinkOrder(flatTree) {
    method resolvePeerModules (line 54908) | resolvePeerModules() {
    method _satisfiesPeerDependency (line 55052) | _satisfiesPeerDependency(range, version) {
    method _warnForMissingBundledDependencies (line 55063) | _warnForMissingBundledDependencies(pkg) {
    method _isUnplugged (line 55116) | _isUnplugged(pkg, ref) {
    method init (line 55149) | init(patterns, workspaceLayout, {linkDuplicates, ignoreOptional} = {}) {
  function _load_tty (line 55182) | function _load_tty() {
  function _interopRequireDefault (line 55186) | function _interopRequireDefault(obj) {
  function clearLine (line 55199) | function clearLine(stdout) {
  function toStartOfLine (line 55214) | function toStartOfLine(stdout) {
  function writeOnNthLine (line 55223) | function writeOnNthLine(stdout, n, msg) {
  function clearNthLine (line 55242) | function clearNthLine(stdout, n) {
  function _load_extends (line 55269) | function _load_extends() {
  function _load_baseReporter (line 55275) | function _load_baseReporter() {
  function _interopRequireDefault (line 55279) | function _interopRequireDefault(obj) {
  class JSONReporter (line 55283) | class JSONReporter extends (_baseReporter || _load_baseReporter()).defau...
    method constructor (line 55284) | constructor(opts) {
    method _dump (line 55291) | _dump(type, data, error) {
    method _verbose (line 55299) | _verbose(msg) {
    method list (line 55303) | list(type, items, hints) {
    method tree (line 55307) | tree(type, trees) {
    method step (line 55311) | step(current, total, message) {
    method inspect (line 55315) | inspect(value) {
    method footer (line 55319) | footer(showPeakMemory) {
    method log (line 55323) | log(msg) {
    method command (line 55327) | command(msg) {
    method table (line 55331) | table(head, body) {
    method success (line 55335) | success(msg) {
    method error (line 55339) | error(msg) {
    method warn (line 55343) | warn(msg) {
    method info (line 55347) | info(msg) {
    method activitySet (line 55351) | activitySet(total, workers) {
    method activity (line 55391) | activity() {
    method _activity (line 55395) | _activity(data) {
    method progress (line 55417) | progress(total) {
    method auditAction (line 55438) | auditAction(recommendation) {
    method auditAdvisory (line 55442) | auditAdvisory(resolution, auditAdvisory) {
    method auditSummary (line 55446) | auditSummary(auditMetadata) {
  function _load_semver (line 55465) | function _load_semver() {
  function _load_minimatch (line 55471) | function _load_minimatch() {
  function _load_map (line 55477) | function _load_map() {
  function _load_normalizePattern (line 55483) | function _load_normalizePattern() {
  function _load_parsePackagePath (line 55489) | function _load_parsePackagePath() {
  function _load_parsePackagePath2 (line 55495) | function _load_parsePackagePath2() {
  function _load_resolvers (line 55501) | function _load_resolvers() {
  function _interopRequireDefault (line 55505) | function _interopRequireDefault(obj) {
  class ResolutionMap (line 55512) | class ResolutionMap {
    method constructor (line 55513) | constructor(config) {
    method init (line 55520) | init(resolutions = {}) {
    method addToDelayQueue (line 55531) | addToDelayQueue(req) {
    method parsePatternInfo (line 55535) | parsePatternInfo(globPattern, range) {
    method find (line 55569) | find(reqPattern, parentNames) {
  function _load_asyncToGenerator (line 55633) | function _load_asyncToGenerator() {
  function _load_path (line 55639) | function _load_path() {
  function _load_invariant (line 55645) | function _load_invariant() {
  function _load_uuid (line 55651) | function _load_uuid() {
  function _load_errors (line 55657) | function _load_errors() {
  function _load_exoticResolver (line 55663) | function _load_exoticResolver() {
  function _load_misc (line 55669) | function _load_misc() {
  function _load_fs (line 55675) | function _load_fs() {
  function _interopRequireWildcard (line 55679) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 55694) | function _interopRequireDefault(obj) {
  class FileResolver (line 55700) | class FileResolver extends (_exoticResolver || _load_exoticResolver()).d...
    method constructor (line 55701) | constructor(request, fragment) {
    method isVersion (line 55706) | static isVersion(pattern) {
    method resolve (line 55714) | resolve() {
  function _load_errors (line 55793) | function _load_errors() {
  function _load_gitResolver (line 55799) | function _load_gitResolver() {
  function _load_exoticResolver (line 55805) | function _load_exoticResolver() {
  function _load_misc (line 55811) | function _load_misc() {
  function _interopRequireWildcard (line 55815) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 55830) | function _interopRequireDefault(obj) {
  function explodeGistFragment (line 55834) | function explodeGistFragment(fragment, reporter) {
  class GistResolver (line 55851) | class GistResolver extends (_exoticResolver || _load_exoticResolver()).d...
    method constructor (line 55852) | constructor(request, fragment) {
    method resolve (line 55864) | resolve() {
  function _load_asyncToGenerator (line 55887) | function _load_asyncToGenerator() {
  function _load_cache (line 55893) | function _load_cache() {
  function _load_errors (line 55899) | function _load_errors() {
  function _load_registryResolver (line 55905) | function _load_registryResolver() {
  function _load_npmRegistry (line 55911) | function _load_npmRegistry() {
  function _load_map (line 55917) | function _load_map() {
  function _load_fs (line 55923) | function _load_fs() {
  function _load_constants (line 55929) | function _load_constants() {
  function _load_packageNameUtils (line 55935) | function _load_packageNameUtils() {
  function _interopRequireWildcard (line 55939) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 55954) | function _interopRequireDefault(obj) {
  class NpmResolver (line 55966) | class NpmResolver extends (_registryResolver || _load_registryResolver()...
    method findVersionInRegistryResponse (line 55967) | static findVersionInRegistryResponse(config, name, range, body, reques...
    method resolveRequest (line 56026) | resolveRequest(desiredVersion) {
    method resolveRequestOffline (line 56055) | resolveRequestOffline() {
    method cleanRegistry (line 56131) | cleanRegistry(url) {
    method resolve (line 56144) | resolve() {
  function _load_asyncToGenerator (line 56244) | function _load_asyncToGenerator() {
  function _load_fs (line 56313) | function _load_fs() {
  function _load_promise (line 56319) | function _load_promise() {
  function _load_fs2 (line 56325) | function _load_fs2() {
  function _interopRequireDefault (line 56329) | function _interopRequireDefault(obj) {
  function _load_asyncToGenerator (line 56464) | function _load_asyncToGenerator() {
  function _load_extends (line 56470) | function _load_extends() {
  function _load_invariant (line 56476) | function _load_invariant() {
  function _load_string_decoder (line 56482) | function _load_string_decoder() {
  function _load_tarFs (line 56488) | function _load_tarFs() {
  function _load_tarStream (line 56494) | function _load_tarStream() {
  function _load_url (line 56500) | function _load_url() {
  function _load_fs (line 56506) | function _load_fs() {
  function _load_errors (line 56512) | function _load_errors() {
  function _load_gitSpawn (line 56518) | function _load_gitSpawn() {
  function _load_gitRefResolver (line 56524) | function _load_gitRefResolver() {
  function _load_crypto (line 56530) | function _load_crypto() {
  function _load_fs2 (line 56536) | function _load_fs2() {
  function _load_map (line 56542) | function _load_map() {
  function _load_misc (line 56548) | function _load_misc() {
  function _interopRequireWildcard (line 56552) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 56567) | function _interopRequireDefault(obj) {
  class Git (line 56613) | class Git {
    method constructor (line 56614) | constructor(config, gitUrl, hash) {
    method npmUrlToGitUrl (line 56629) | static npmUrlToGitUrl(npmUrl) {
    method hasArchiveCapability (line 56679) | static hasArchiveCapability(ref) {
    method repoExists (line 56707) | static repoExists(ref) {
    method replaceProtocol (line 56731) | static replaceProtocol(ref, protocol) {
    method secureGitUrl (line 56742) | static secureGitUrl(ref, hash, reporter) {
    method archive (line 56777) | archive(dest) {
    method _archiveViaRemoteArchive (line 56785) | _archiveViaRemoteArchive(dest) {
    method _archiveViaLocalFetched (line 56808) | _archiveViaLocalFetched(dest) {
    method clone (line 56834) | clone(dest) {
    method _cloneViaRemoteArchive (line 56842) | _cloneViaRemoteArchive(dest) {
    method _cloneViaLocalFetched (line 56864) | _cloneViaLocalFetched(dest) {
    method fetch (line 56889) | fetch() {
    method getFile (line 56914) | getFile(filename) {
    method _getFileFromArchive (line 56922) | _getFileFromArchive(filename) {
    method _getFileFromClone (line 56966) | _getFileFromClone(filename) {
    method init (line 56989) | init() {
    method setRefRemote (line 57008) | setRefRemote() {
    method setRefHosted (line 57034) | setRefHosted(hostedRefsList) {
    method resolveDefaultBranch (line 57043) | resolveDefaultBranch() {
    method resolveCommit (line 57105) | resolveCommit(shaToResolve) {
    method setRef (line 57141) | setRef(refs) {
  function _load_asyncToGenerator (line 57186) | function _load_asyncToGenerator() {
  function _load_resolveRelative (line 57192) | function _load_resolveRelative() {
  function _load_validate (line 57198) | function _load_validate() {
  function _load_fix (line 57204) | function _load_fix() {
  function _interopRequireDefault (line 57208) | function _interopRequireDefault(obj) {
  function warn (line 57236) | function warn(msg) {
  function isValidLicense (line 57295) | function isValidLicense(license) {
  function stringifyPerson (line 57299) | function stringifyPerson(person) {
  function parsePerson (line 57322) | function parsePerson(person) {
  function normalizePerson (line 57351) | function normalizePerson(person) {
  function extractDescription (line 57355) | function extractDescription(readme) {
  function extractRepositoryUrl (line 57391) | function extractRepositoryUrl(repository) {
  function getPlatformSpecificPackageFilename (line 57409) | function getPlatformSpecificPackageFilename(pkg) {
  function getSystemParams (line 57416) | function getSystemParams() {
  function getUid (line 57432) | function getUid() {
  function isFakeRoot (line 57440) | function isFakeRoot() {
  function isRootUser (line 57444) | function isRootUser(uid) {
  function _load_semver (line 57462) | function _load_semver() {
  function _interopRequireDefault (line 57466) | function _interopRequireDefault(obj) {
  function satisfiesWithPrereleases (line 57475) | function satisfiesWithPrereleases(version, range, loose = false) {
  function diffWithUnstable (line 57538) | function diffWithUnstable(version1, version2) {
  function getDataDir (line 57607) | function getDataDir() {
  function getCacheDir (line 57626) | function getCacheDir() {
  function getConfigDir (line 57642) | function getConfigDir() {
  function getLocalAppDataDir (line 57657) | function getLocalAppDataDir() {
  function explodeHashedUrl (line 57671) | function explodeHashedUrl(url) {
  function balanced (line 57693) | function balanced(a, b, str) {
  function maybeMatch (line 57710) | function maybeMatch(reg, str) {
  function range (line 57716) | function range(a, b, str) {
  function numeric (line 57768) | function numeric(str) {
  function escapeBraces (line 57772) | function escapeBraces(str) {
  function unescapeBraces (line 57786) | function unescapeBraces(str) {
  function parseCommaParts (line 57803) | function parseCommaParts(str) {
  function expandTop (line 57828) | function expandTop(str) {
  function identity (line 57844) | function identity(e) {
  function embrace (line 57848) | function embrace(str) {
  function isPadded (line 57851) | function isPadded(el) {
  function lte (line 57855) | function lte(i, y) {
  function gte (line 57858) | function gte(i, y) {
  function expand (line 57862) | function expand(str, isTop) {
  function preserveCamelCase (line 57962) | function preserveCamelCase(str) {
  function Caseless (line 58034) | function Caseless(dict) {
  function useColors (line 59262) | function useColors() {
  function formatArgs (line 59321) | function formatArgs(args) {
  function log (line 59363) | function log() {
  function save (line 59380) | function save(namespaces) {
  function load (line 59397) | function load() {
  function localstorage (line 59428) | function localstorage() {
  function useColors (line 59600) | function useColors() {
  function formatArgs (line 59636) | function formatArgs(args) {
  function getDate (line 59652) | function getDate() {
  function log (line 59664) | function log() {
  function save (line 59675) | function save(namespaces) {
  function load (line 59692) | function load() {
  function init (line 59703) | function init(debug) {
  function rethrow (line 60031) | function rethrow() {
  function maybeCallback (line 60063) | function maybeCallback(cb) {
  function start (line 60107) | function start() {
  function start (line 60208) | function start() {
  function LOOP (line 60230) | function LOOP() {
  function gotStat (line 60258) | function gotStat(err, stat) {
  function gotTarget (line 60287) | function gotTarget(err, target, base) {
  function gotResolvedLink (line 60295) | function gotResolvedLink(resolvedLink) {
  function globSync (line 60326) | function globSync(pattern, options) {
  function GlobSync (line 60336) | function GlobSync(pattern, options) {
  function inflight (line 60772) | function inflight(key, cb) {
  function makeres (line 60782) | function makeres(key) {
  function slice (line 60813) | function slice(args) {
  function parse (line 63219) | function parse(str) {
  function fmtShort (line 63280) | function fmtShort(ms) {
  function fmtLong (line 63304) | function fmtLong(ms) {
  function plural (line 63318) | function plural(ms, n, name) {
  function toObject (line 63350) | function toObject(val) {
  function shouldUseNative (line 63358) | function shouldUseNative() {
  function paramsHaveRequestBody (line 63442) | function paramsHaveRequestBody(params) {
  function safeStringify (line 63451) | function safeStringify(obj, replacer) {
  function md5 (line 63461) | function md5(str) {
  function isReadStream (line 63468) | function isReadStream(rs) {
  function toBase64 (line 63472) | function toBase64(str) {
  function copy (line 63476) | function copy(obj) {
  function version (line 63484) | function version() {
  function specifierIncluded (line 63509) | function specifierIncluded(specifier) {
  function matchesRange (line 63531) | function matchesRange(range) {
  function versionIncluded (line 63544) | function versionIncluded(specifierValue) {
  function defaults (line 63593) | function defaults(options) {
  function rimraf (line 63610) | function rimraf(p, options, cb) {
  function rimraf_ (line 63691) | function rimraf_(p, options, cb) {
  function fixWinEPERM (line 63718) | function fixWinEPERM(p, options, er, cb) {
  function fixWinEPERMSync (line 63735) | function fixWinEPERMSync(p, options, er) {
  function rmdir (line 63758) | function rmdir(p, options, originalEr, cb) {
  function rmkids (line 63775) | function rmkids(p, options, cb) {
  function rimrafSync (line 63798) | function rimrafSync(p, options) {
  function rmdirSync (line 63849) | function rmdirSync(p, options, originalEr) {
  function rmkidsSync (line 63864) | function rmkidsSync(p, options) {
  function ReplaySubject (line 63918) | function ReplaySubject(bufferSize, windowTime, scheduler) {
  function ReplayEvent (line 64023) | function ReplayEvent(time, value) {
  function combineLatest (line 64056) | function combineLatest() {
  function CombineLatestOperator (line 64086) | function CombineLatestOperator(resultSelector) {
  function CombineLatestSubscriber (line 64097) | function CombineLatestSubscriber(destination, resultSelector) {
  function defer (line 64177) | function defer(observableFactory) {
  function of (line 64210) | function of() {
  function scalar (line 64255) | function scalar(value) {
  function throwError (line 64277) | function throwError(error, scheduler) {
  function dispatch (line 64292) | function dispatch(_a) {
  function zip (line 64324) | function zip() {
  function ZipOperator (line 64338) | function ZipOperator(resultSelector) {
  function ZipSubscriber (line 64349) | function ZipSubscriber(destination, resultSelector, values) {
  function StaticIterator (line 64454) | function StaticIterator(iterator) {
  function StaticArrayIterator (line 64473) | function StaticArrayIterator(array) {
  function ZipBufferIterator (line 64499) | function ZipBufferIterator(destination, parent, observable) {
  function mergeAll (line 64566) | function mergeAll(concurrent) {
  function refCount (line 64587) | function refCount() {
  function RefCountOperator (line 64593) | function RefCountOperator(connectable) {
  function RefCountSubscriber (line 64610) | function RefCountSubscriber(destination, connectable) {
  function scan (line 64653) | function scan(accumulator, seed) {
  function ScanOperator (line 64663) | function ScanOperator(accumulator, seed, hasSeed) {
  function ScanSubscriber (line 64680) | function ScanSubscriber(destination, accumulator, _seed, hasSeed) {
  function switchMap (line 64744) | function switchMap(project, resultSelector) {
  function SwitchMapOperator (line 64767) | function SwitchMapOperator(project) {
  function SwitchMapSubscriber (line 64777) | function SwitchMapSubscriber(destination, project) {
  function take (line 64855) | function take(count) {
  function TakeOperator (line 64867) | function TakeOperator(total) {
  function TakeSubscriber (line 64882) | function TakeSubscriber(destination, total) {
  function takeLast (line 64919) | function takeLast(count) {
  function TakeLastOperator (line 64931) | function TakeLastOperator(total) {
  function TakeLastSubscriber (line 64946) | function TakeLastSubscriber(destination, total) {
  function canReportError (line 65007) | function canReportError(observer) {
  function hostReportError (line 65035) | function hostReportError(err) {
  function pipe (line 65052) | function pipe() {
  function pipeFromArray (line 65059) | function pipeFromArray(fns) {
  function DiffieHellman (line 65100) | function DiffieHellman(key) {
  function X9ECParameters (line 65342) | function X9ECParameters(name) {
  function ECPublic (line 65372) | function ECPublic(params, buffer) {
  function ECPrivate (line 65378) | function ECPrivate(params, buffer) {
  function generateED25519 (line 65392) | function generateED25519() {
  function generateECDSA (line 65412) | function generateECDSA(curve) {
  function read (line 65519) | function read(buf, options) {
  function readRFC3110 (line 65547) | function readRFC3110(keyString) {
  function elementToBuf (line 65599) | function elementToBuf(e) {
  function readDNSSECRSAPrivateKey (line 65603) | function readDNSSECRSAPrivateKey(elements) {
  function readDNSSECPrivateKey (line 65646) | function readDNSSECPrivateKey(alg, elements) {
  function dnssecTimestamp (line 65679) | function dnssecTimestamp(date) {
  function rsaAlgFromOptions (line 65688) | function rsaAlgFromOptions(opts) {
  function writeRSA (line 65695) | function writeRSA(key, options) {
  function writeECDSA (line 65728) | function writeECDSA(key, options) {
  function write (line 65751) | function write(key, options) {
  function read (line 65798) | function read(buf, options) {
  function write (line 65802) | function write(key, options) {
  function readMPInt (line 65807) | function readMPInt(der, nm) {
  function readPkcs1 (line 65812) | function readPkcs1(alg, type, der) {
  function readPkcs1RSAPublic (line 65836) | function readPkcs1RSAPublic(der) {
  function readPkcs1RSAPrivate (line 65850) | function readPkcs1RSAPrivate(der) {
  function readPkcs1DSAPrivate (line 65882) | function readPkcs1DSAPrivate(der) {
  function readPkcs1EdDSAPrivate (line 65907) | function readPkcs1EdDSAPrivate(der) {
  function readPkcs1DSAPublic (line 65929) | function readPkcs1DSAPublic(der) {
  function readPkcs1ECDSAPublic (line 65948) | function readPkcs1ECDSAPublic(der) {
  function readPkcs1ECDSAPrivate (line 65979) | function readPkcs1ECDSAPrivate(der) {
  function writePkcs1 (line 66006) | function writePkcs1(der, key) {
  function writePkcs1RSAPublic (line 66033) | function writePkcs1RSAPublic(der, key) {
  function writePkcs1RSAPrivate (line 66038) | function writePkcs1RSAPrivate(der, key) {
  function writePkcs1DSAPrivate (line 66053) | function writePkcs1DSAPrivate(der, key) {
  function writePkcs1DSAPublic (line 66064) | function writePkcs1DSAPublic(der, key) {
  function writePkcs1ECDSAPublic (line 66071) | function writePkcs1ECDSAPublic(der, key) {
  function writePkcs1ECDSAPrivate (line 66086) | function writePkcs1ECDSAPrivate(der, key) {
  function writePkcs1EdDSAPrivate (line 66105) | function writePkcs1EdDSAPrivate(der, key) {
  function writePkcs1EdDSAPublic (line 66120) | function writePkcs1EdDSAPublic(der, key) {
  function _load_constants (line 66298) | function _load_constants() {
  function _load_access (line 66304) | function _load_access() {
  function _load_add (line 66310) | function _load_add() {
  function _load_audit (line 66316) | function _load_audit() {
  function _load_autoclean (line 66322) | function _load_autoclean() {
  function _load_bin (line 66328) | function _load_bin() {
  function _load_cache (line 66334) | function _load_cache() {
  function _load_check (line 66340) | function _load_check() {
  function _load_config (line 66346) | function _load_config() {
  function _load_create (line 66352) | function _load_create() {
  function _load_exec (line 66358) | function _load_exec() {
  function _load_generateLockEntry (line 66364) | function _load_generateLockEntry() {
  function _load_global (line 66370) | function _load_global() {
  function _load_help (line 66376) | function _load_help() {
  function _load_import (line 66382) | function _load_import() {
  function _load_info (line 66388) | function _load_info() {
  function _load_init (line 66394) | function _load_init() {
  function _load_install (line 66400) | function _load_install() {
  function _load_licenses (line 66406) | function _load_licenses() {
  function _load_link (line 66412) | function _load_link() {
  function _load_login (line 66418) | function _load_login() {
  function _load_logout (line 66424) | function _load_logout() {
  function _load_list (line 66430) | function _load_list() {
  function _load_node (line 66436) | function _load_node() {
  function _load_outdated (line 66442) | function _load_outdated() {
  function _load_owner (line 66448) | function _load_owner() {
  function _load_pack (line 66454) | function _load_pack() {
  function _load_policies (line 66460) | function _load_policies() {
  function _load_publish (line 66466) | function _load_publish() {
  function _load_remove (line 66472) | function _load_remove() {
  function _load_run (line 66478) | function _load_run() {
  function _load_tag (line 66484) | function _load_tag() {
  function _load_team (line 66490) | function _load_team() {
  function _load_unplug (line 66496) | function _load_unplug() {
  function _load_unlink (line 66502) | function _load_unlink() {
  function _load_upgrade (line 66508) | function _load_upgrade() {
  function _load_version (line 66514) | function _load_version() {
  function _load_versions (line 66520) | function _load_versions() {
  function _load_why (line 66526) | function _load_why() {
  function _load_workspaces (line 66532) | function _load_workspaces() {
  function _load_workspace (line 66538) | function _load_workspace() {
  function _load_upgradeInteractive (line 66544) | function _load_upgradeInteractive() {
  function _load_useless (line 66550) | function _load_useless() {
  function _load_aliases (line 66556) | function _load_aliases() {
  function _interopRequireDefault (line 66560) | function _interopRequireDefault(obj) {
  function _interopRequireWildcard (line 66564) | function _interopRequireWildcard(obj) {
  function _load_fs (line 66663) | function _load_fs() {
  function _load_path (line 66669) | function _load_path() {
  function _load_commander (line 66675) | function _load_commander() {
  function _load_lockfile (line 66681) | function _load_lockfile() {
  function _load_rc (line 66687) | function _load_rc() {
  function _interopRequireWildcard (line 66691) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 66706) | function _interopRequireDefault(obj) {
  function getRcConfigForCwd (line 66722) | function getRcConfigForCwd(cwd, args) {
  function loadRcFile (line 66752) | function loadRcFile(fileText, filePath) {
  function buildRcArgs (line 66772) | function buildRcArgs(cwd, args) {
  function extractCwdArg (line 66809) | function extractCwdArg(args) {
  function getRcArgs (line 66822) | function getRcArgs(commandName, args, previousCwds = []) {
  function boolify (line 66860) | function boolify(val) {
  function boolifyWithDefault (line 66864) | function boolifyWithDefault(val, defaultResult) {
  function isOffline (line 66883) | function isOffline() {
  function Option (line 66983) | function Option(flags, description) {
  function Command (line 67036) | function Command(name) {
  function camelcase (line 68110) | function camelcase(flag) {
  function pad (line 68125) | function pad(str, width) {
  function outputHelpIfNecessary (line 68138) | function outputHelpIfNecessary(cmd, options) {
  function humanReadableArgName (line 68156) | function humanReadableArgName(arg) {
  function exists (line 68163) | function exists(file) {
  function SchemaObject (line 68183) | function SchemaObject(obj) {
  function $shouldUseGroup (line 69424) | function $shouldUseGroup($rulesGroup) {
  function $shouldUseRule (line 69429) | function $shouldUseRule($rule) {
  function $ruleImplementsSomeKeyword (line 69436) | function $ruleImplementsSomeKeyword($rule) {
  function abort (line 69461) | function abort(state) {
  function clean (line 69474) | function clean(key) {
  function async (line 69496) | function async(callback) {
  function iterate (line 69533) | function iterate(list, iterator, state, callback) {
  function runJob (line 69570) | function runJob(iterator, key, item, callback) {
  function state (line 69601) | function state(list, sortMethod) {
  function terminator (line 69642) | function terminator(callback) {
  function serialOrdered (line 69680) | function serialOrdered(list, iterator, sortMethod, callback) {
  function ascending (line 69715) | function ascending(a, b) {
  function descending (line 69726) | function descending(a, b) {
  function _load_asyncToGenerator (line 69757) | function _load_asyncToGenerator() {
  function _load_promise (line 69826) | function _load_promise() {
  function _load_hoistedTreeBuilder (line 69832) | function _load_hoistedTreeBuilder() {
  function _load_getTransitiveDevDependencies (line 69838) | function _load_getTransitiveDevDependencies() {
  function _load_install (line 69844) | function _load_install() {
  function _load_lockfile (line 69850) | function _load_lockfile() {
  function _load_constants (line 69856) | function _load_constants() {
  function _interopRequireDefault (line 69860) | function _interopRequireDefault(obj) {
  function setFlags (line 69868) | function setFlags(commander) {
  function hasWrapper (line 69873) | function hasWrapper(commander, args) {
  class Audit (line 69877) | class Audit {
    method constructor (line 69878) | constructor(config, reporter) {
    method _mapHoistedNodes (line 69883) | _mapHoistedNodes(auditNode, hoistedNodes, transitiveDevDeps) {
    method _mapHoistedTreesToAuditTree (line 69953) | _mapHoistedTreesToAuditTree(manifest, hoistedTrees, transitiveDevDeps) {
    method _fetchAudit (line 69977) | _fetchAudit(auditTree) {
    method _insertWorkspacePackagesIntoManifest (line 70015) | _insertWorkspacePackagesIntoManifest(manifest, resolver) {
    method performAudit (line 70036) | performAudit(manifest, lockfile, resolver, linker, patterns) {
    method summary (line 70060) | summary() {
    method report (line 70067) | report() {
  function _load_asyncToGenerator (line 70128) | function _load_asyncToGenerator() {
  function _load_index (line 70426) | function _load_index() {
  function _load_filter (line 70432) | function _load_filter() {
  function _load_constants (line 70438) | function _load_constants() {
  function _load_fs (line 70444) | function _load_fs() {
  function _interopRequireWildcard (line 70448) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 70463) | function _interopRequireDefault(obj) {
  function setFlags (line 70521) | function setFlags(commander) {
  function hasWrapper (line 70538) | function hasWrapper(commander) {
  function _load_asyncToGenerator (line 70555) | function _load_asyncToGenerator() {
  function _load_buildSubCommands (line 70794) | function _load_buildSubCommands() {
  function _load_fs (line 70800) | function _load_fs() {
  function _interopRequireWildcard (line 70804) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 70819) | function _interopRequireDefault(obj) {
  function hasWrapper (line 70827) | function hasWrapper(flags, args) {
  function _getMetadataWithPath (line 70831) | function _getMetadataWithPath(getMetadataFn, paths) {
  method ls (line 70847) | ls(config, reporter, flags, args) {
  method dir (line 70855) | dir(config, reporter) {
  function setFlags (line 70866) | function setFlags(commander) {
  function _load_asyncToGenerator (line 70885) | function _load_asyncToGenerator() {
  function reportError (line 70897) | function reportError(msg, ...vars) {
  function reportError (line 71043) | function reportError(msg, ...vars) {
  function humaniseLocation (line 71146) | function humaniseLocation(loc) {
  function reportError (line 71166) | function reportError(msg, ...vars) {
  function _load_errors (line 71453) | function _load_errors() {
  function _load_integrityChecker (line 71459) | function _load_integrityChecker() {
  function _load_integrityChecker2 (line 71465) | function _load_integrityChecker2() {
  function _load_lockfile (line 71471) | function _load_lockfile() {
  function _load_fs (line 71477) | function _load_fs() {
  function _load_install (line 71483) | function _load_install() {
  function _load_normalizePattern (line 71489) | function _load_normalizePattern() {
  function _interopRequireWildcard (line 71493) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 71508) | function _interopRequireDefault(obj) {
  function hasWrapper (line 71518) | function hasWrapper(commander) {
  function setFlags (line 71522) | function setFlags(commander) {
  function _load_asyncToGenerator (line 71543) | function _load_asyncToGenerator() {
  function _load_errors (line 71674) | function _load_errors() {
  function _load_fs (line 71680) | function _load_fs() {
  function _load_global (line 71686) | function _load_global() {
  function _interopRequireWildcard (line 71690) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 71705) | function _interopRequireDefault(obj) {
  function hasWrapper (line 71714) | function hasWrapper(commander, args) {
  function setFlags (line 71718) | function setFlags(commander) {
  function _load_asyncToGenerator (line 71735) | function _load_asyncToGenerator() {
  function _load_install (line 72041) | function _load_install() {
  function _load_lockfile (line 72047) | function _load_lockfile() {
  function _interopRequireDefault (line 72051) | function _interopRequireDefault(obj) {
  function buildCount (line 72061) | function buildCount(trees) {
  function getParent (line 72100) | function getParent(key, treesByKey) {
  function hasWrapper (line 72108) | function hasWrapper(commander, args) {
  function setFlags (line 72112) | function setFlags(commander) {
  function getReqDepth (line 72118) | function getReqDepth(inputDepth) {
  function filterTree (line 72122) | function filterTree(tree, filters, pattern = '') {
  function getDevDeps (line 72135) | function getDevDeps(manifest) {
  function _load_extends (line 72160) | function _load_extends() {
  function _load_asyncToGenerator (line 72166) | function _load_asyncToGenerator() {
  function _load_lockfile (line 72360) | function _load_lockfile() {
  function _load_index (line 72366) | function _load_index() {
  function _load_install (line 72372) | function _load_install() {
  function _load_errors (line 72378) | function _load_errors() {
  function _load_index2 (line 72384) | function _load_index2() {
  function _load_fs (line 72390) | function _load_fs() {
  function _load_constants (line 72396) | function _load_constants() {
  function _interopRequireWildcard (line 72400) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 72415) | function _interopRequireDefault(obj) {
  function setFlags (line 72425) | function setFlags(commander) {
  function hasWrapper (line 72436) | function hasWrapper(commander, args) {
  function _load_asyncToGenerator (line 72453) | function _load_asyncToGenerator() {
  function _load_executeLifecycleScript (line 72833) | function _load_executeLifecycleScript() {
  function _load_dynamicRequire (line 72839) | function _load_dynamicRequire() {
  function _load_errors (line 72845) | function _load_errors() {
  function _load_fs (line 72851) | function _load_fs() {
  function _load_constants (line 72857) | function _load_constants() {
  function _interopRequireWildcard (line 72861) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 72876) | function _interopRequireDefault(obj) {
  function toObject (line 72891) | function toObject(input) {
  function setFlags (line 72923) | function setFlags(commander) {
  function hasWrapper (line 72927) | function hasWrapper(commander, args) {
  function _load_asyncToGenerator (line 72944) | function _load_asyncToGenerator() {
  function _load_buildSubCommands (line 73061) | function _load_buildSubCommands() {
  function _load_login (line 73067) | function _load_login() {
  function _load_npmRegistry (line 73073) | function _load_npmRegistry() {
  function _load_errors (line 73079) | function _load_errors() {
  function _load_normalizePattern (line 73085) | function _load_normalizePattern() {
  function _load_validate (line 73091) | function _load_validate() {
  function _interopRequireDefault (line 73095) | function _interopRequireDefault(obj) {
  function setFlags (line 73099) | function setFlags(commander) {
  method add (line 73106) | add(config, reporter, flags, args) {
  method rm (line 73163) | rm(config, reporter, flags, args) {
  method remove (line 73170) | remove(config, reporter, flags, args) {
  method ls (line 73176) | ls(config, reporter, flags, args) {
  method list (line 73183) | list(config, reporter, flags, args) {
  function _load_extends (line 73212) | function _load_extends() {
  function _load_asyncToGenerator (line 73218) | function _load_asyncToGenerator() {
  function _load_inquirer (line 73487) | function _load_inquirer() {
  function _load_lockfile (line 73493) | function _load_lockfile() {
  function _load_add (line 73499) | function _load_add() {
  function _load_upgrade (line 73505) | function _load_upgrade() {
  function _load_colorForVersions (line 73511) | function _load_colorForVersions() {
  function _load_colorizeDiff (line 73517) | function _load_colorizeDiff() {
  function _load_install (line 73523) | function _load_install() {
  function _interopRequireDefault (line 73527) | function _interopRequireDefault(obj) {
  function setFlags (line 73535) | function setFlags(commander) {
  function hasWrapper (line 73557) | function hasWrapper(commander, args) {
  function _load_asyncToGenerator (line 73574) | function _load_asyncToGenerator() {
  function runLifecycle (line 73598) | function runLifecycle(lifecycle) {
  function isCommitHooksDisabled (line 73612) | function isCommitHooksDisabled() {
  function _load_index (line 73810) | function _load_index() {
  function _load_executeLifecycleScript (line 73816) | function _load_executeLifecycleScript() {
  function _load_errors (line 73822) | function _load_errors() {
  function _load_gitSpawn (line 73828) | function _load_gitSpawn() {
  function _load_fs (line 73834) | function _load_fs() {
  function _load_map (line 73840) | function _load_map() {
  function _interopRequireWildcard (line 73844) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 73859) | function _interopRequireDefault(obj) {
  function isValidNewVersion (line 73868) | function isValidNewVersion(oldVersion, newVersion, looseSemver) {
  function setFlags (line 73874) | function setFlags(commander) {
  function hasWrapper (line 73885) | function hasWrapper(commander, args) {
  function _load_extends (line 73902) | function _load_extends() {
  function _load_asyncToGenerator (line 73908) | function _load_asyncToGenerator() {
  function _load_errors (line 73914) | function _load_errors() {
  function _load_constants (line 73920) | function _load_constants() {
  function _load_baseFetcher (line 73926) | function _load_baseFetcher() {
  function _load_fs (line 73932) | function _load_fs() {
  function _load_misc (line 73938) | function _load_misc() {
  function _load_normalizeUrl (line 73944) | function _load_normalizeUrl() {
  function _interopRequireWildcard (line 73948) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 73963) | function _interopRequireDefault(obj) {
  class TarballFetcher (line 73999) | class TarballFetcher extends (_baseFetcher || _load_baseFetcher()).defau...
    method constructor (line 74000) | constructor(...args) {
    method setupMirrorFromCache (line 74011) | setupMirrorFromCache() {
    method getTarballCachePath (line 74033) | getTarballCachePath() {
    method getTarballMirrorPath (line 74037) | getTarballMirrorPath() {
    method createExtractor (line 74062) | createExtractor(resolve, reject, tarballPath) {
    method getLocalPaths (line 74175) | getLocalPaths(override) {
    method fetchFromLocal (line 74185) | fetchFromLocal(override) {
    method fetchFromExternal (line 74224) | fetchFromExternal() {
    method requestHeaders (line 74288) | requestHeaders() {
    method _fetch (line 74309) | _fetch() {
    method _findIntegrity (line 74328) | _findIntegrity() {
    method _supportedIntegrity (line 74338) | _supportedIntegrity() {
  class LocalTarballFetcher (line 74384) | class LocalTarballFetcher extends TarballFetcher {
    method _fetch (line 74385) | _fetch() {
  function urlParts (line 74392) | function urlParts(requestUrl) {
  function _load_errors (line 74416) | function _load_errors() {
  function _load_map (line 74422) | function _load_map() {
  function _load_misc (line 74428) | function _load_misc() {
  function _load_yarnVersion (line 74434) | function _load_yarnVersion() {
  function _load_semver (line 74440) | function _load_semver() {
  function _interopRequireDefault (line 74444) | function _interopRequireDefault(obj) {
  function isValid (line 74456) | function isValid(items, actual) {
  function testEngine (line 74514) | function testEngine(name, range, versions, looseSemver) {
  function isValidArch (line 74573) | function isValidArch(archs) {
  function isValidPlatform (line 74577) | function isValidPlatform(platforms) {
  function checkOne (line 74581) | function checkOne(info, config, ignoreEngines) {
  function check (line 74662) | function check(infos, config, ignoreEngines) {
  function shouldCheckCpu (line 74688) | function shouldCheckCpu(cpu, ignorePlatform) {
  function shouldCheckPlatform (line 74692) | function shouldCheckPlatform(os, ignorePlatform) {
  function shouldCheckEngines (line 74696) | function shouldCheckEngines(engines, ignoreEngines) {
  function shouldCheck (line 74700) | function shouldCheck(manifest, options) {
  function _load_misc (line 74720) | function _load_misc() {
  class PackageReference (line 74724) | class PackageReference {
    method constructor (line 74725) | constructor(request, info, remote) {
    method setFresh (line 74754) | setFresh(fresh) {
    method addLocation (line 74758) | addLocation(loc) {
    method addRequest (line 74764) | addRequest(request) {
    method prune (line 74770) | prune() {
    method addDependencies (line 74797) | addDependencies(deps) {
    method setPermission (line 74801) | setPermission(key, val) {
    method hasPermission (line 74805) | hasPermission(key) {
    method addPattern (line 74813) | addPattern(pattern, manifest) {
    method addOptional (line 74848) | addOptional(optional) {
  function _load_asyncToGenerator (line 74873) | function _load_asyncToGenerator() {
  function _load_index (line 74879) | function _load_index() {
  function _load_packageRequest (line 74885) | function _load_packageRequest() {
  function _load_normalizePattern (line 74891) | function _load_normalizePattern() {
  function _load_requestManager (line 74897) | function _load_requestManager() {
  function _load_blockingQueue (line 74903) | function _load_blockingQueue() {
  function _load_lockfile (line 74909) | function _load_lockfile() {
  function _load_map (line 74915) | function _load_map() {
  function _load_workspaceLayout (line 74921) | function _load_workspaceLayout() {
  function _load_resolutionMap (line 74927) | function _load_resolutionMap() {
  function _load_resolutionMap2 (line 74933) | function _load_resolutionMap2() {
  function _interopRequireDefault (line 74937) | function _interopRequireDefault(obj) {
  class PackageResolver (line 74945) | class PackageResolver {
    method constructor (line 74946) | constructor(
    method isNewPattern (line 74996) | isNewPattern(pattern) {
    method updateManifest (line 75000) | updateManifest(ref, newPkg) {
    method updateManifests (line 75037) | updateManifests(newPkgs) {
    method dedupePatterns (line 75096) | dedupePatterns(patterns) {
    method getTopologicalManifests (line 75137) | getTopologicalManifests(seedPatterns) {
    method getLevelOrderManifests (line 75185) | getLevelOrderManifests(seedPatterns) {
    method getAllDependencyNamesByLevelOrder (line 75260) | getAllDependencyNamesByLevelOrder(seedPatterns) {
    method getAllInfoForPackageName (line 75293) | getAllInfoForPackageName(name) {
    method getAllInfoForPatterns (line 75302) | getAllInfoForPatterns(patterns) {
    method getManifests (line 75343) | getManifests() {
    method replacePattern (line 75363) | replacePattern(pattern, newPattern) {
    method collapseAllVersionsOfPackage (line 75377) | collapseAllVersionsOfPackage(name, version) {
    method collapsePackageVersions (line 75385) | collapsePackageVersions(name, version, patterns) {
    method addPattern (line 75492) | addPattern(pattern, info) {
    method removePattern (line 75506) | removePattern(pattern) {
    method getResolvedPattern (line 75525) | getResolvedPattern(pattern) {
    method getStrictResolvedPattern (line 75533) | getStrictResolvedPattern(pattern) {
    method getExactVersionMatch (line 75543) | getExactVersionMatch(name, version, manifest) {
    method getHighestRangeVersionMatch (line 75590) | getHighestRangeVersionMatch(name, range, manifest) {
    method exoticRangeMatch (line 75623) | exoticRangeMatch(resolvedPkgs, manifest) {
    method isLockfileEntryOutdated (line 75644) | isLockfileEntryOutdated(version, range, hasVersion) {
    method find (line 75658) | find(initialReq) {
    method init (line 75711) | init(
    method optimizeResolutions (line 75814) | optimizeResolutions(name) {
    method reportPackageWithExistingVersion (line 75874) | reportPackageWithExistingVersion(req, info) {
    method resolvePackagesWithExistingVersions (line 75883) | resolvePackagesWithExistingVersions() {
    method resolveToResolution (line 75911) | resolveToResolution(req) {
  function _load_hostedGitResolver (line 75963) | function _load_hostedGitResolver() {
  function _interopRequireDefault (line 75967) | function _interopRequireDefault(obj) {
  class GitHubResolver (line 75971) | class GitHubResolver extends (_hostedGitResolver || _load_hostedGitResol...
    method isVersion (line 75972) | static isVersion(pattern) {
    method getTarballUrl (line 75986) | static getTarballUrl(parts, hash) {
    method getGitSSHUrl (line 75990) | static getGitSSHUrl(parts) {
    method getGitHTTPBaseUrl (line 75997) | static getGitHTTPBaseUrl(parts) {
    method getGitHTTPUrl (line 76001) | static getGitHTTPUrl(parts) {
    method getHTTPFileUrl (line 76005) | static getHTTPFileUrl(parts, filename, commit) {
  function _load_asyncToGenerator (line 76028) | function _load_asyncToGenerator() {
  function _load_exoticResolver (line 76034) | function _load_exoticResolver() {
  function _load_misc (line 76040) | function _load_misc() {
  function _load_fs (line 76046) | function _load_fs() {
  function _interopRequireWildcard (line 76050) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 76065) | function _interopRequireDefault(obj) {
  class LinkResolver (line 76073) | class LinkResolver extends (_exoticResolver || _load_exoticResolver()).d...
    method constructor (line 76074) | constructor(request, fragment) {
    method resolve (line 76079) | resolve() {
  function _load_semver (line 76134) | function _load_semver() {
  function _load_semver2 (line 76140) | function _load_semver2() {
  function _load_constants (line 76146) | function _load_constants() {
  function _interopRequireDefault (line 76150) | function _interopRequireDefault(obj) {
  function _load_misc (line 76205) | function _load_misc() {
  function sortFilter (line 76214) | function sortFilter(
  function matchesFilter (line 76410) | function matchesFilter(filter, basename, loc) {
  function ignoreLinesToRegex (line 76427) | function ignoreLinesToRegex(lines, base = '.') {
  function filterOverridenGitignores (line 76467) | function filterOverridenGitignores(files) {
  function _load_extends (line 76506) | function _load_extends() {
  function _load_path (line 76512) | function _load_path() {
  function _load_child (line 76518) | function _load_child() {
  function _interopRequireWildcard (line 76522) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 76537) | function _interopRequireDefault(obj) {
  function parsePackagePath (line 76617) | function parsePackagePath(input) {
  function isValidPackagePath (line 76623) | function isValidPackagePath(input) {
  function _load_path (line 76641) | function _load_path() {
  function getPosixPath (line 76647) | function getPosixPath(path) {
  function resolveWithHome (line 76651) | function resolveWithHome(path) {
  function _load_fs (line 76672) | function _load_fs() {
  function _load_http (line 76678) | function _load_http() {
  function _load_url (line 76684) | function _load_url() {
  function _load_dnscache (line 76690) | function _load_dnscache() {
  function _load_invariant (line 76696) | function _load_invariant() {
  function _load_requestCaptureHar (line 76702) | function _load_requestCaptureHar() {
  function _load_errors (line 76708) | function _load_errors() {
  function _load_blockingQueue (line 76714) | function _load_blockingQueue() {
  function _load_constants (line 76720) | function _load_constants() {
  function _load_network (line 76726) | function _load_network() {
  function _load_map (line 76732) | function _load_map() {
  function _interopRequireWildcard (line 76736) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 76751) | function _interopRequireDefault(obj) {
  class RequestManager (line 76767) | class RequestManager {
    method constructor (line 76768) | constructor(reporter) {
    method setOptions (line 76787) | setOptions(opts) {
    method _getRequestModule (line 76860) | _getRequestModule() {
    method request (line 76879) | request(params) {
    method clearCache (line 76922) | clearCache() {
    method isPossibleOfflineError (line 76933) | isPossibleOfflineError(err) {
    method queueForRetry (line 76978) | queueForRetry(opts) {
    method initOfflineRetry (line 77026) | initOfflineRetry() {
    method execute (line 77060) | execute(opts) {
    method shiftQueue (line 77249) | shiftQueue() {
    method saveHar (line 77260) | saveHar(filename) {
  function F (line 78423) | function F(S, x8, i) {
  function stream2word (line 78455) | function stream2word(data, databytes) {
  function bcrypt_hash (line 78535) | function bcrypt_hash(sha2pass, sha2salt, out) {
  function bcrypt_pbkdf (line 78592) | function bcrypt_pbkdf(pass, passlen, salt, saltlen, key, keylen, rounds) {
  function codeRegex (line 78747) | function codeRegex(capture) {
  function strlen (line 78751) | function strlen(str) {
  function repeat (line 78760) | function repeat(str, times) {
  function pad (line 78764) | function pad(str, len, pad, dir) {
  function addToCodeCache (line 78789) | function addToCodeCache(name, on, off) {
  function updateState (line 78804) | function updateState(state, controlChars) {
  function readState (line 78832) | function readState(line) {
  function unwindState (line 78843) | function unwindState(state, ret) {
  function rewindState (line 78866) | function rewindState(state, ret) {
  function truncateWidth (line 78889) | function truncateWidth(str, desiredLength) {
  function truncateWidthWithAnsi (line 78901) | function truncateWidthWithAnsi(str, desiredLength) {
  function truncate (line 78932) | function truncate(str, desiredLength, truncateChar) {
  function defaultOptions (line 78945) | function defaultOptions() {
  function mergeOptions (line 78980) | function mergeOptions(options, defaults) {
  function wordWrap (line 78989) | function wordWrap(maxLength, input) {
  function multiLineWordWrap (line 79019) | function multiLineWordWrap(maxLength, input) {
  function colorizeLines (line 79028) | function colorizeLines(input) {
  function createPromise (line 79081) | function createPromise() {
  function co (line 79095) | function co(gen) {
  function toPromise (line 79173) | function toPromise(obj) {
  function thunkToPromise (line 79191) | function thunkToPromise(fn) {
  function arrayToPromise (line 79211) | function arrayToPromise(obj) {
  function objectToPromise (line 79224) | function objectToPromise(obj) {
  function isPromise (line 79257) | function isPromise(obj) {
  function isGenerator (line 79269) | function isGenerator(obj) {
  function isGeneratorFunction (line 79280) | function isGeneratorFunction(obj) {
  function isObject (line 79299) | function isObject(val) {
  function comparativeDistance (line 79476) | function comparativeDistance(x, y) {
  function CombinedStream (line 80209) | function CombinedStream() {
  function unstupid (line 80661) | function unstupid(hex, len) {
  function clone (line 80805) | function clone(obj) {
  function noop (line 80829) | function noop() {}
  function patch (line 80876) | function patch(fs) {
  function enqueue (line 81055) | function enqueue(elem) {
  function retry (line 81060) | function retry() {
  class InputPrompt (line 81083) | class InputPrompt extends Base {
    method _run (line 81090) | _run(cb) {
    method render (line 81114) | render(error) {
    method filterInput (line 81144) | filterInput(input) {
    method onEnd (line 81151) | onEnd(state) {
    method onError (line 81162) | onError(state) {
    method onKeypress (line 81170) | onKeypress() {
  class UI (line 81196) | class UI {
    method constructor (line 81197) | constructor(opt) {
    method onForceClose (line 81219) | onForceClose() {
    method close (line 81229) | close() {
  function setupReadlineOptions (line 81247) | function setupReadlineOptions(opt) {
  function isStream (line 82112) | function isStream(obj) {
  function isReadable (line 82116) | function isReadable(obj) {
  function isWritable (line 82122) | function isWritable(obj) {
  function isDuplex (line 82128) | function isDuplex(obj) {
  function charset (line 82188) | function charset(type) {
  function contentType (line 82216) | function contentType(str) {
  function extension (line 82244) | function extension(type) {
  function lookup (line 82269) | function lookup(path) {
  function populateMaps (line 82291) | function populateMaps(extensions, types) {
  function MuteStream (line 82339) | function MuteStream(opts) {
  function onPipe (line 82376) | function onPipe(src) {
  function getIsTTY (line 82387) | function getIsTTY() {
  function setIsTTY (line 82392) | function setIsTTY(isTTY) {
  function proxy (line 82465) | function proxy(fn) {
  function testParameter (line 82510) | function testParameter(name, filters) {
  function hasOwnProperty (line 82683) | function hasOwnProperty(obj, prop) {
  function isEmpty (line 82691) | function isEmpty(value) {
  function toString (line 82708) | function toString(type) {
  function isObject (line 82712) | function isObject(obj) {
  function isBoolean (line 82723) | function isBoolean(obj) {
  function getKey (line 82727) | function getKey(key) {
  function factory (line 82735) | function factory(options) {
  function _uint8ArrayToBuffer (line 83292) | function _uint8ArrayToBuffer(chunk) {
  function _isUint8Array (line 83295) | function _isUint8Array(obj) {
  function prependListener (line 83324) | function prependListener(emitter, event, fn) {
  function ReadableState (line 83338) | function ReadableState(options, stream) {
  function Readable (line 83417) | function Readable(options) {
  function readableAddChunk (line 83492) | function readableAddChunk(stream, chunk, encoding, addToFront, skipChunk...
  function addChunk (line 83535) | function addChunk(stream, state, chunk, addToFront) {
  function chunkInvalid (line 83550) | function chunkInvalid(state, chunk) {
  function needMoreData (line 83570) | function needMoreData(state) {
  function computeNewHighWaterMark (line 83591) | function computeNewHighWaterMark(n) {
  function howMuchToRead (line 83610) | function howMuchToRead(n, state) {
  function onEofChunk (line 83732) | function onEofChunk(stream, state) {
  function emitReadable (line 83750) | function emitReadable(stream) {
  function emitReadable_ (line 83761) | function emitReadable_(stream) {
  function maybeReadMore (line 83773) | function maybeReadMore(stream, state) {
  function maybeReadMore_ (line 83780) | function maybeReadMore_(stream, state) {
  function onunpipe (line 83834) | function onunpipe(readable, unpipeInfo) {
  function onend (line 83844) | function onend() {
  function cleanup (line 83857) | function cleanup() {
  function ondata (line 83885) | function ondata(chunk) {
  function onerror (line 83909) | function onerror(er) {
  function onclose (line 83920) | function onclose() {
  function onfinish (line 83925) | function onfinish() {
  function unpipe (line 83932) | function unpipe() {
  function pipeOnDrain (line 83949) | function pipeOnDrain(src) {
  function nReadingNextTick (line 84037) | function nReadingNextTick(self) {
  function resume (line 84054) | function resume(stream, state) {
  function resume_ (line 84061) | function resume_(stream, state) {
  function flow (line 84084) | function flow(stream) {
  function fromList (line 84171) | function fromList(n, state) {
  function fromListPartial (line 84194) | function fromListPartial(n, list, hasStrings) {
  function copyFromBufferString (line 84214) | function copyFromBufferString(n, list) {
  function copyFromBuffer (line 84245) | function copyFromBuffer(n, list) {
  function endReadable (line 84273) | function endReadable(stream) {
  function endReadableNT (line 84286) | function endReadableNT(state, stream) {
  function indexOf (line 84295) | function indexOf(xs, x) {
  function afterTransform (line 84381) | function afterTransform(er, data) {
  function Transform (line 84407) | function Transform(options) {
  function prefinish (line 84439) | function prefinish() {
  function done (line 84507) | function done(stream, er, data) {
  function WriteReq (line 84563) | function WriteReq(chunk, encoding, cb) {
  function CorkedRequest (line 84572) | function CorkedRequest(state) {
  function _uint8ArrayToBuffer (line 84615) | function _uint8ArrayToBuffer(chunk) {
  function _isUint8Array (line 84618) | function _isUint8Array(obj) {
  function nop (line 84628) | function nop() {}
  function WritableState (line 84630) | function WritableState(options, stream) {
  function Writable (line 84790) | function Writable(options) {
  function writeAfterEnd (line 84827) | function writeAfterEnd(stream, cb) {
  function validChunk (line 84837) | function validChunk(stream, state, chunk, cb) {
  function decodeChunk (line 84930) | function decodeChunk(state, chunk, encoding) {
  function writeOrBuffer (line 84950) | function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
  function doWrite (line 84989) | function doWrite(stream, state, writev, len, chunk, encoding, cb) {
  function onwriteError (line 84999) | function onwriteError(stream, state, sync, er, cb) {
  function onwriteStateUpdate (line 85023) | function onwriteStateUpdate(state) {
  function onwrite (line 85030) | function onwrite(stream, er) {
  function afterWrite (line 85056) | function afterWrite(stream, state, finished, cb) {
  function onwriteDrain (line 85066) | function onwriteDrain(stream, state) {
  function clearBuffer (line 85074) | function clearBuffer(stream, state) {
  function needFinish (line 85165) | function needFinish(state) {
  function callFinal (line 85174) | function callFinal(stream, state) {
  function prefinish (line 85185) | function prefinish(stream, state) {
  function finishMaybe (line 85198) | function finishMaybe(stream, state) {
  function endWritable (line 85210) | function endWritable(stream, state, cb) {
  function onCorkedFinish (line 85221) | function onCorkedFinish(corkReq, state, err) {
  function destroy (line 85276) | function destroy(err, cb) {
  function undestroy (line 85317) | function undestroy() {
  function emitErrorNT (line 85334) | function emitErrorNT(self, err) {
  function RequestJar (line 85393) | function RequestJar(store) {
  function pathMatch (line 85454) | function pathMatch(reqPath, cookiePath) {
  function permuteDomain (line 85521) | function permuteDomain(domain) {
  function Store (line 94136) | function Store() {}
  function BehaviorSubject (line 94257) | function BehaviorSubject(_value) {
  function Scheduler (line 94337) | function Scheduler(SchedulerAction, now) {
  function SubjectSubscription (line 94372) | function SubjectSubscription(subject, subscriber) {
  function ConnectableObservable (line 94423) | function ConnectableObservable(source, subjectFactory) {
  function ConnectableSubscriber (line 94482) | function ConnectableSubscriber(destination, connectable) {
  function RefCountOperator (line 94512) | function RefCountOperator(connectable) {
  function RefCountSubscriber (line 94529) | function RefCountSubscriber(destination, connectable) {
  function merge (line 94578) | function merge() {
  function never (line 94632) | function never() {
  function race (line 94656) | function race() {
  function RaceOperator (line 94677) | function RaceOperator() {}
  function RaceSubscriber (line 94686) | function RaceSubscriber(destination) {
  function timer (line 94758) | function timer(dueTime, periodOrScheduler, scheduler) {
  function dispatch (line 94798) | function dispatch(state) {
  function audit (line 94834) | function audit(durationSelector) {
  function AuditOperator (line 94840) | function AuditOperator(durationSelector) {
  function AuditSubscriber (line 94850) | function AuditSubscriber(destination, durationSelector) {
  function concatAll (line 94921) | function concatAll() {
  function concatMap (line 94935) | function concatMap(project, resultSelector) {
  function distinctUntilChanged (line 94960) | function distinctUntilChanged(compare, keySelector) {
  function DistinctUntilChangedOperator (line 94966) | function DistinctUntilChangedOperator(compare, keySelector) {
  function DistinctUntilChangedSubscriber (line 94982) | function DistinctUntilChangedSubscriber(destination, compare, keySelecto...
  function find (line 95043) | function find(predicate, thisArg) {
  function FindValueOperator (line 95052) | function FindValueOperator(predicate, source, yieldIndex, thisArg) {
  function FindValueSubscriber (line 95074) | function FindValueSubscriber(destination, predicate, source, yieldIndex,...
  function groupBy (line 95127) | function groupBy(keySelector, elementSelector, durationSelector, subject...
  function GroupByOperator (line 95135) | function GroupByOperator(keySelector, elementSelector, durationSelector,...
  function GroupBySubscriber (line 95156) | function GroupBySubscriber(
  function GroupDurationSubscriber (line 95256) | function GroupDurationSubscriber(key, group, parent) {
  function GroupedObservable (line 95279) | function GroupedObservable(key, groupSubject, refCountSubscription) {
  function InnerRefCountSubscription (line 95304) | function InnerRefCountSubscription(parent) {
  function observeOn (line 95342) | function observeOn(scheduler, delay) {
  function ObserveOnOperator (line 95351) | function ObserveOnOperator(scheduler, delay) {
  function ObserveOnSubscriber (line 95366) | function ObserveOnSubscriber(destination, scheduler, delay) {
  function ObserveOnMessage (line 95412) | function ObserveOnMessage(notification, destination) {
  function tap (line 95435) | function tap(nextOrObserver, error, complete) {
  function DoOperator (line 95441) | function DoOperator(nextOrObserver, error, complete) {
  function TapSubscriber (line 95455) | function TapSubscriber(destination, observerOrNext, error, complete) {
  function throttle (line 95533) | function throttle(durationSelector, config) {
  function ThrottleOperator (line 95544) | function ThrottleOperator(durationSelector, leading, trailing) {
  function ThrottleSubscriber (line 95558) | function ThrottleSubscriber(destination, durationSelector, _leading, _tr...
  function timeoutWith (line 95654) | function timeoutWith(due, withObservable, scheduler) {
  function TimeoutWithOperator (line 95669) | function TimeoutWithOperator(waitFor, absoluteTimeout, withObservable, s...
  function TimeoutWithSubscriber (line 95690) | function TimeoutWithSubscriber(
  function TimeoutErrorImpl (line 95791) | function TimeoutErrorImpl() {
  function UnsubscriptionErrorImpl (line 95810) | function UnsubscriptionErrorImpl(errors) {
  function isDate (line 95850) | function isDate(value) {
  function isObject (line 95862) | function isObject(x) {
  function isPromise (line 95874) | function isPromise(value) {
  function unload (line 96151) | function unload() {
  function emit (line 96167) | function emit(event, code, signal) {
  function load (line 96203) | function load() {
  function processReallyExit (line 96229) | function processReallyExit(code) {
  function processEmit (line 96239) | function processEmit(ev, arg) {
  function Verifier (line 96634) | function Verifier(key, hashAlgo) {
  function Signer (line 96678) | function Signer(key, hashAlgo) {
  function read (line 96736) | function read(buf, options) {
  function findSSHHeader (line 96753) | function findSSHHeader(buf) {
  function findPEMHeader (line 96770) | function findPEMHeader(buf) {
  function findDNSSECHeader (line 96781) | function findDNSSECHeader(buf) {
  function write (line 96802) | function write(key, options) {
  function read (line 96831) | function read(buf, options) {
  function write (line 96900) | function write(key, options) {
  function readMPInt (line 96948) | function readMPInt(der, nm) {
  function verify (line 96953) | function verify(cert, key) {
  function Local (line 96972) | function Local(i) {
  function Context (line 96976) | function Context(i) {
  function read (line 97008) | function read(buf, options) {
  function readDate (line 97105) | function readDate(der) {
  function readExtension (line 97153) | function readExtension(cert, buf, der) {
  function utcTimeToDate (line 97286) | function utcTimeToDate(t) {
  function gTimeToDate (line 97304) | function gTimeToDate(t) {
  function zeroPad (line 97315) | function zeroPad(n) {
  function dateToUTCTime (line 97321) | function dateToUTCTime(d) {
  function sign (line 97333) | function sign(cert, key) {
  function signAsync (line 97352) | function signAsync(cert, signer, done) {
  function write (line 97376) | function write(cert, options) {
  function writeTBSCert (line 97405) | function writeTBSCert(cert, der) {
  function readBitField (line 97565) | function readBitField(bits, bitIndex) {
  function writeBitField (line 97587) | function writeBitField(setBits, bitIndex) {
  function _normalizeEncoding (line 97660) | function _normalizeEncoding(enc) {
  function normalizeEncoding (line 97690) | function normalizeEncoding(enc) {
  function StringDecoder (line 97701) | function StringDecoder(encoding) {
  function utf8CheckByte (line 97762) | function utf8CheckByte(byte) {
  function utf8CheckIncomplete (line 97773) | function utf8CheckIncomplete(self, buf, i) {
  function utf8CheckExtraBytes (line 97807) | function utf8CheckExtraBytes(self, buf, p) {
  function utf8FillLast (line 97827) | function utf8FillLast(buf) {
  function utf8Text (line 97842) | function utf8Text(buf, i) {
  function utf8End (line 97853) | function utf8End(buf) {
  function utf16Text (line 97863) | function utf16Text(buf, i) {
  function utf16End (line 97886) | function utf16End(buf) {
  function base64Text (line 97895) | function base64Text(buf, i) {
  function base64End (line 97909) | function base64End(buf) {
  function simpleWrite (line 97916) | function simpleWrite(buf) {
  function simpleEnd (line 97920) | function simpleEnd(buf) {
  function parse256 (line 98029) | function parse256(buf) {
  function DestroyableTransform (line 98231) | function DestroyableTransform(opts) {
  function noop (line 98250) | function noop(chunk, enc, callback) {
  function through2 (line 98256) | function through2(construct) {
  function Through2 (line 98286) | function Through2(override) {
  function bufferFrom (line 98321) | function bufferFrom(buf, enc) {
  function toBuffer (line 98325) | function toBuffer(buf, enc) {
  function bytesToUuid (line 98345) | function bytesToUuid(buf, offset) {
  function extend (line 98396) | function extend() {
  function _load_child (line 98437) | function _load_child() {
  function forwardSignalAndExit (line 98441) | function forwardSignalAndExit(signal) {
  function handleSignals (line 98447) | function handleSignals() {
  function ON_DEATH (line 98466) | function ON_DEATH(callback) {
  function getLockFile (line 98574) | function getLockFile(file) {
  function canonicalPath (line 98578) | function canonicalPath(file, options, callback) {
  function acquireLock (line 98588) | function acquireLock(file, options, callback) {
  function isLockStale (line 98638) | function isLockStale(stat, options) {
  function removeLock (line 98642) | function removeLock(file, options, callback) {
  function updateLock (line 98653) | function updateLock(file, options) {
  function compromisedLock (line 98726) | function compromisedLock(file, lock, err) {
  function lock (line 98740) | function lock(file, options, compromised, callback) {
  function unlock (line 98822) | function unlock(file, options, callback) {
  function lockSync (line 98861) | function lockSync(file, options, compromised) {
  function unlockSync (line 98893) | function unlockSync(file, options) {
  function check (line 98908) | function check(file, options, callback) {
  function checkSync (line 98948) | function checkSync(file, options) {
  function Ajv (line 99098) | function Ajv(opts) {
  function validate (line 99137) | function validate(schemaKeyRef, data) {
  function compile (line 99160) | function compile(schema, _meta) {
  function addSchema (line 99174) | function addSchema(schema, key, _skipValidation, _meta) {
  function addMetaSchema (line 99197) | function addMetaSchema(schema, key, skipValidation) {
  function validateSchema (line 99209) | function validateSchema(schema, throwOrLogError) {
  function defaultMeta (line 99236) | function defaultMeta(self) {
  function getSchema (line 99253) | function getSchema(keyRef) {
  function _getSchemaFragment (line 99265) | function _getSchemaFragment(self, ref) {
  function _getSchemaObj (line 99284) | function _getSchemaObj(self, keyRef) {
  function removeSchema (line 99298) | function removeSchema(schemaKeyRef) {
  function _removeAllSchemas (line 99330) | function _removeAllSchemas(self, schemas, regex) {
  function _addSchema (line 99341) | function _addSchema(schema, skipValidation, meta, shouldAddSchema) {
  function _compile (line 99378) | function _compile(schemaObj, root) {
  function chooseGetId (line 99417) | function chooseGetId(opts) {
  function _getId (line 99429) | function _getId(schema) {
  function _get$Id (line 99435) | function _get$Id(schema) {
  function _get$IdOrId (line 99440) | function _get$IdOrId(schema) {
  function errorsText (line 99453) | function errorsText(errors, options) {
  function addFormat (line 99475) | function addFormat(name, format) {
  function addDraft6MetaSchema (line 99481) | function addDraft6MetaSchema(self) {
  function addInitialSchemas (line 99494) | function addInitialSchemas(self) {
  function addInitialFormats (line 99501) | function addInitialFormats(self) {
  function checkUnique (line 99508) | function checkUnique(self, id) {
  function getMetaSchemaOptions (line 99513) | function getMetaSchemaOptions(self) {
  function setLogger (line 99519) | function setLogger(self) {
  function noop (line 99531) | function noop() {}
  function compileAsync (line 99614) | function compileAsync(schema, meta, callback) {
  function formats (line 99718) | function formats(mode) {
  function date (line 99771) | function date(str) {
  function time (line 99781) | function time(str, full) {
  function date_time (line 99793) | function date_time(str) {
  function hostname (line 99799) | function hostname(str) {
  function uri (line 99806) | function uri(str) {
  function regex (line 99812) | function regex(str) {
  function compile (line 99857) | function compile(schema, root, localRefs, baseId) {
  function checkCompiling (line 100134) | function checkCompiling(schema, root, baseId) {
  function endCompiling (line 100154) | function endCompiling(schema, root, baseId) {
  function compIndex (line 100168) | function compIndex(schema, root, baseId) {
  function patternCode (line 100177) | function patternCode(i, patterns) {
  function defaultCode (line 100181) | function defaultCode(i) {
  function refValCode (line 100185) | function refValCode(i, refVal) {
  function customRuleCode (line 100189) | function customRuleCode(i) {
  function vars (line 100193) | function vars(arr, statement) {
  function addKeyword (line 103955) | function addKeyword(keyword, definition) {
  function getKeyword (line 104042) | function getKeyword(keyword) {
  function removeKeyword (line 104054) | function removeKeyword(keyword) {
  function _traverse (line 104266) | function _traverse(
  function escapeJsonPtr (line 104321) | function escapeJsonPtr(str) {
  function assembleStyles (line 104476) | function assembleStyles() {
  function webpackEmptyContext (line 104631) | function webpackEmptyContext(req) {
  function loadImplementation (line 104747) | function loadImplementation(implementation) {
  function shouldPreferGlobalPromise (line 104791) | function shouldPreferGlobalPromise(implementation) {
  function tryAutoDetect (line 104815) | function tryAutoDetect() {
  function flat (line 104854) | function flat(arr, res) {
  function asap (line 104916) | function asap(task) {
  function RawTask (line 104928) | function RawTask() {
  function rawAsap (line 104984) | function rawAsap(task) {
  function flush (line 105012) | function flush() {
  function requestFlush (line 105040) | function requestFlush() {
  function Reader (line 105116) | function Reader(data) {
  function merge (line 105355) | function merge(from, to) {
  function Writer (line 105374) | function Writer(options) {
  function encodeOctet (line 105489) | function encodeOctet(bytes, octet) {
  function defer (line 105638) | function defer(fn) {
  function parallel (line 105672) | function parallel(list, iterator, callback) {
  function serial (line 105712) | function serial(list, iterator, callback) {
  function authorization (line 105773) | function authorization(options) {
  function hmacSha1 (line 105788) | function hmacSha1(options) {
  function sign (line 105805) | function sign(options) {
  function signQuery (line 105821) | function signQuery(options) {
  function stringToSign (line 105844) | function stringToSign(options) {
  function queryStringToSign (line 105872) | function queryStringToSign(options) {
  function canonicalizeHeaders (line 105891) | function canonicalizeHeaders(headers) {
  function canonicalizeResource (line 105916) | function canonicalizeResource(resource) {
  function hmac (line 105944) | function hmac(key, string, encoding) {
  function hash (line 105951) | function hash(string, encoding) {
  function encodeRfc3986 (line 105959) | function encodeRfc3986(urlEncodedString) {
  function RequestSigner (line 105973) | function RequestSigner(request, credentials) {
  function trimAll (line 106225) | function trimAll(header) {
  function LruCache (line 106317) | function LruCache(size) {
  function DoublyLinkedList (line 106357) | function DoublyLinkedList() {
  function DoublyLinkedNode (line 106401) | function DoublyLinkedNode(key, val) {
  method run (line 106421) | run() {
  function _load_errors (line 106431) | function _load_errors() {
  function _load_buildSubCommands (line 106449) | function _load_buildSubCommands() {
  function _interopRequireDefault (line 106453) | function _interopRequireDefault(obj) {
  function setFlags (line 106460) | function setFlags(commander) {
  function _load_asyncToGenerator (line 106507) | function _load_asyncToGenerator() {
  function _load_run (line 106545) | function _load_run() {
  function _interopRequireDefault (line 106549) | function _interopRequireDefault(obj) {
  function hasWrapper (line 106555) | function hasWrapper(commander) {
  function setFlags (line 106559) | function setFlags(commander) {
  function _load_asyncToGenerator (line 106576) | function _load_asyncToGenerator() {
  function _load_buildSubCommands (line 106585) | function _load_buildSubCommands() {
  function _interopRequireDefault (line 106589) | function _interopRequireDefault(obj) {
  function hasWrapper (line 106629) | function hasWrapper(flags, args) {
  function setFlags (line 106633) | function setFlags(commander) {
  method set (line 106640) | set(config, reporter, flags, args) {
  method get (line 106656) | get(config, reporter, flags, args) {
  function _delete (line 106683) | function _delete(_x, _x2, _x3, _x4) {
  method list (line 106690) | list(config, reporter, flags, args) {
  method current (line 106704) | current(config, reporter, flags, args) {
  function _load_asyncToGenerator (line 106734) | function _load_asyncToGenerator() {
  function _load_extends (line 106740) | function _load_extends() {
  function _load_errors (line 106783) | function _load_errors() {
  function _load_child (line 106789) | function _load_child() {
  function _load_global (line 106795) | function _load_global() {
  function _interopRequireWildcard (line 106799) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 106814) | function _interopRequireDefault(obj) {
  function setFlags (line 106820) | function setFlags(commander) {
  function hasWrapper (line 106824) | function hasWrapper(commander, args) {
  function parsePackageName (line 106828) | function parsePackageName(str) {
  function coerceCreatePackageName (line 106849) | function coerceCreatePackageName(str) {
  function _load_asyncToGenerator (line 106873) | function _load_asyncToGenerator() {
  function _load_errors (line 106911) | function _load_errors() {
  function _load_child (line 106917) | function _load_child() {
  function _load_executeLifecycleScript (line 106923) | function _load_executeLifecycleScript() {
  function _interopRequireWildcard (line 106927) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 106942) | function _interopRequireDefault(obj) {
  function setFlags (line 106946) | function setFlags(commander) {}
  function hasWrapper (line 106948) | function hasWrapper(commander, args) {
  function _load_asyncToGenerator (line 106965) | function _load_asyncToGenerator() {
  function _load_errors (line 107015) | function _load_errors() {
  function _load_lockfile (line 107021) | function _load_lockfile() {
  function _interopRequireDefault (line 107025) | function _interopRequireDefault(obj) {
  function hasWrapper (line 107029) | function hasWrapper(commander, args) {
  function setFlags (line 107033) | function setFlags(commander) {
  function _load_index (line 107061) | function _load_index() {
  function _load_constants (line 107067) | function _load_constants() {
  function _load_misc (line 107073) | function _load_misc() {
  function _load_aliases (line 107079) | function _load_aliases() {
  function _interopRequireWildcard (line 107083) | function _interopRequireWildcard(obj) {
  function _interopRequireDefault (line 107098) | function _interopRequireDefault(obj) {
  function hasWrapper (line 107104) | function hasWrapper(flags, args) {
  function setFlags (line 107108) | function setFlags(commander) {
  function run (line 107112) | function run(config, reporter, commander, args) {
  function _load_asyncToGenerator (line 107209) | function _load_asyncToGenerator() {
  function _load_install (line 107239) | function _load_install() {
  function _load_check (line 107245) | function _load_check() {
  function _load_errors
Condensed preview — 530 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (7,849K chars).
[
  {
    "path": ".bithoundrc",
    "chars": 140,
    "preview": "{\n  \"ignore\": [\n    \"benchmark/**\",\n    \"docs/**\",\n    \"dist/**\",\n    \"test/**\",\n    \"node_modules/**\"\n  ],\n  \"tests\": ["
  },
  {
    "path": ".eslintignore",
    "chars": 80,
    "preview": "flow-typed/\n**/node_modules/**\npackages/**/dist/\nexamples/**/static/\n*.ts\n*.tsx\n"
  },
  {
    "path": ".eslintrc.js",
    "chars": 701,
    "preview": "module.exports = {\n  extends: ['jss', 'prettier', 'prettier/react'],\n  parser: 'babel-eslint',\n  env: {\n    mocha: true,"
  },
  {
    "path": ".flowconfig",
    "chars": 60,
    "preview": "[ignore]\n\n[include]\n\n[libs]\n\n[options]\ninclude_warnings=true"
  },
  {
    "path": ".gitattributes",
    "chars": 25,
    "preview": "package-lock.json binary\n"
  },
  {
    "path": ".github/CODEOWNERS",
    "chars": 13,
    "preview": "*       @kof\n"
  },
  {
    "path": ".github/FUNDING.yml",
    "chars": 68,
    "preview": "# These are supported funding model platforms\n\nopen_collective: jss\n"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/---bug-report.md",
    "chars": 1096,
    "preview": "---\nname: \"\\U0001F41B Bug report\"\nabout: \"If something isn't working as expected \\U0001F914.\"\n\n---\n\n__Expected behavior:"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/---feature-request.md",
    "chars": 696,
    "preview": "---\nname: \"\\U0001F680 Feature request\"\nabout: \"I have a suggestion (and may want to implement it \\U0001F642)!\"\n\n---\n\n__I"
  },
  {
    "path": ".github/PULL_REQUEST_TEMPLATE.md",
    "chars": 1092,
    "preview": "## Corresponding Issue(s): <!-- (if relevant) -->\n\n## What Would You Like to Add/Fix?\n\n## Todo\n\n- [ ] Add test(s) that v"
  },
  {
    "path": ".gitignore",
    "chars": 108,
    "preview": "node_modules\n.DS_Store\nnpm-debug.log\ntmp\n*~\ndist\n.env\ncoverage\nlerna-debug.log\nyarn-error.log\n.idea\n.vscode\n"
  },
  {
    "path": ".nvmrc",
    "chars": 2,
    "preview": "10"
  },
  {
    "path": ".prettierignore",
    "chars": 153,
    "preview": "node_modules/\ncoverage/\ndist/\ntmp/\n*.html\n# npm install does it's own formatting, which can conflict with prettier\npacka"
  },
  {
    "path": ".prettierrc",
    "chars": 118,
    "preview": "{\n  \"semi\": false,\n  \"singleQuote\": true,\n  \"trailingComma\": \"none\",\n  \"bracketSpacing\": false,\n  \"printWidth\": 100\n}\n"
  },
  {
    "path": ".travis.yml",
    "chars": 502,
    "preview": "language: node_js\nnode_js:\n  - '10'\nbranches:\n  only:\n    - master\nsudo: required\nbefore_install:\n  - npm i yarn@latest "
  },
  {
    "path": ".yarn/releases/yarn-1.15.2.js",
    "chars": 5626218,
    "preview": "#!/usr/bin/env node\nmodule.exports = /******/ (function(modules) {\n  // webpackBootstrap\n  /******/ // The module cache\n"
  },
  {
    "path": ".yarnrc",
    "chars": 158,
    "preview": "# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.\n# yarn lockfile v1\n\n\nlastUpdateCheck 1553377279244\nyarn"
  },
  {
    "path": "CODE_OF_CONDUCT.md",
    "chars": 3352,
    "preview": "# Contributor Covenant Code of Conduct\n\n## Our Pledge\n\nIn the interest of fostering an open and welcoming environment, w"
  },
  {
    "path": "LICENSE",
    "chars": 1113,
    "preview": "The MIT License (MIT)\nCopyright (c) 2014-present Oleg Isonen (Slobodskoi) & contributors\n\nPermission is hereby granted, "
  },
  {
    "path": "babelOptions.js",
    "chars": 259,
    "preview": "exports.getBabelOptions = ({useESModules}) => ({\n  presets: [['@babel/env', {loose: true}], '@babel/react'],\n  plugins: "
  },
  {
    "path": "browsers.json",
    "chars": 1715,
    "preview": "{\n  \"BS_Safari Yosemite\": {\n    \"base\": \"BrowserStack\",\n    \"os\": \"OS X\",\n    \"os_version\": \"Yosemite\",\n    \"browser\": \""
  },
  {
    "path": "changelog.md",
    "chars": 25025,
    "preview": "Since you are interested in what happens next, in case, you work for a for-profit company that benefits from using the p"
  },
  {
    "path": "contributing.md",
    "chars": 1181,
    "preview": "# Contributing\n\n## Want to contribute but got stuck?\n\nPlease reach out on [Discord](https://discord.gg/e79XhqmaDH)\n\n## P"
  },
  {
    "path": "docs/articles.md",
    "chars": 534,
    "preview": "# A hand-picked selection of articles\n\n## By maintainers\n\nhttps://medium.com/dailyjs/what-is-actually-css-in-js-f2f529a2"
  },
  {
    "path": "docs/cdn.md",
    "chars": 1024,
    "preview": "# CDN links using [unpkg](https://unpkg.com)\n\n## Unminified ESM starter kit for experiments\n\nhttps://unpkg.com/jss-start"
  },
  {
    "path": "docs/csp.md",
    "chars": 5143,
    "preview": "# Setting up Content Security Policy with JSS\n\nContent Security Policy (CSP) is a way of whitelisting what resources the"
  },
  {
    "path": "docs/environment-requirements.md",
    "chars": 857,
    "preview": "## JavaScript Environment Requirements\n\nWe run our tests against a [number of real browsers](../browsers.json) including"
  },
  {
    "path": "docs/examples.md",
    "chars": 678,
    "preview": "# Examples\n\n- [Documentation site](https://github.com/cssinjs/cssinjs/)\n- [Calendar](https://codesandbox.io/s/github/css"
  },
  {
    "path": "docs/faq.md",
    "chars": 1669,
    "preview": "# FAQ\n\n1. Does JSS generate inline styles?\n\n   No, JSS generates CSS.\n\n1. Does JSS support Server-Side Rendering?\n\n   Ye"
  },
  {
    "path": "docs/features.md",
    "chars": 3745,
    "preview": "# Features\n\n1. Real CSS.\n\n   JSS generates actual CSS, not Inline Styles. It supports every existing CSS feature. CSS ru"
  },
  {
    "path": "docs/intro.md",
    "chars": 3424,
    "preview": "# Status\nThis project is no longer maintained. [I am](https://github.com/kof) working on a new tool called [Webstudio](h"
  },
  {
    "path": "docs/jss-api.md",
    "chars": 12448,
    "preview": "# JavaScript API\n\n## Access the global JSS instance\n\nThere is a global Jss instance which is the default export of the p"
  },
  {
    "path": "docs/jss-plugin-cache.md",
    "chars": 779,
    "preview": "## Enables caching JSS rules\n\nThis plugin will cache JSS rules by comparing a reference from the object.\n\nIt should be u"
  },
  {
    "path": "docs/jss-plugin-camel-case.md",
    "chars": 390,
    "preview": "## Camel case syntax\n\nAfter using this plugin, we can write CSS properties in camel case syntax.\n\n```javascript\nconst st"
  },
  {
    "path": "docs/jss-plugin-compose.md",
    "chars": 3914,
    "preview": "## Enables classes composition\n\nThis plugin allows you to use CSS frameworks and legacy code together with JSS as well a"
  },
  {
    "path": "docs/jss-plugin-default-unit.md",
    "chars": 1127,
    "preview": "## Default units for numeric values\n\nProvide numeric values in your style definitions, and the plugin will insert the co"
  },
  {
    "path": "docs/jss-plugin-expand.md",
    "chars": 5911,
    "preview": "## Better syntax for complex properties\n\nThis plugin makes complex properties like `box-shadow: 2px 2px 2px 1px gold;` e"
  },
  {
    "path": "docs/jss-plugin-extend.md",
    "chars": 1554,
    "preview": "## Extending styles\n\nThis plugin implements a custom property `extend` which allows you to mix in styles in various ways"
  },
  {
    "path": "docs/jss-plugin-global.md",
    "chars": 1018,
    "preview": "## Global selectors\n\nSelectors have a generated (scoped) suffix by default to avoid conflicts. You can use this plugin t"
  },
  {
    "path": "docs/jss-plugin-isolate.md",
    "chars": 4273,
    "preview": "## Enables rules isolation through automatic properties reset\n\nSome of the CSS properties are inheritable. It means that"
  },
  {
    "path": "docs/jss-plugin-nested.md",
    "chars": 2499,
    "preview": "## Pseudo and Nested Selectors\n\n### Use `&` to reference selector of the parent rule\n\n```javascript\nconst styles = {\n  c"
  },
  {
    "path": "docs/jss-plugin-props-sort.md",
    "chars": 536,
    "preview": "## Ensures style properties extend each other instead of overriding\n\nInspired by React Native. When using this plugin, m"
  },
  {
    "path": "docs/jss-plugin-rule-value-function.md",
    "chars": 1905,
    "preview": "## Enables functions for dynamic styles\n\nIf you want dynamic behavior for your Style Sheet, you can use functions as a v"
  },
  {
    "path": "docs/jss-plugin-rule-value-observable.md",
    "chars": 1798,
    "preview": "## Enables TC39 Observables\n\nTo create highly dynamic animations, you may want to use streams. Take a look at the [tc39 "
  },
  {
    "path": "docs/jss-plugin-template.md",
    "chars": 746,
    "preview": "## Enables string templates\n\nAllows you to use string templates to declare CSS rules. It implements a **very naive** but"
  },
  {
    "path": "docs/jss-plugin-vendor-prefixer.md",
    "chars": 594,
    "preview": "## Add vendor prefixes in the browser\n\nThis vendor prefixer knows which properties and values are supported in the curre"
  },
  {
    "path": "docs/jss-preset-default.md",
    "chars": 951,
    "preview": "## Default preset for JSS with selected plugins\n\nPreset allows a quick setup with default settings and a [default plugin"
  },
  {
    "path": "docs/jss-syntax.md",
    "chars": 6629,
    "preview": "# Objects based styles syntax for declaring Style Sheets\n\nJSS is designed to stay as close as possible to the CSS syntax"
  },
  {
    "path": "docs/migrations.md",
    "chars": 1636,
    "preview": "# Migration guides\n\n## From v9 to v10\n\n1. New dynamic values support.\n\n   In v9, observables and function values have be"
  },
  {
    "path": "docs/performance.md",
    "chars": 1254,
    "preview": "# Performance\n\n## Advantages\n\nJSS has some performance advantages.\n\n- Incremental compilation and rendering (as soon as "
  },
  {
    "path": "docs/plugins.md",
    "chars": 5101,
    "preview": "# JSS Plugins\n\nPlugins API allows modifying style sheets at different stages. A plugin can, for example, add new style p"
  },
  {
    "path": "docs/projects.md",
    "chars": 4011,
    "preview": "# All projects using JSS\n\n## Integrations\n\n[React-JSS](./react-jss.md) - HOC interface for React with theming support.\n\n"
  },
  {
    "path": "docs/react-jss-hoc.md",
    "chars": 6748,
    "preview": "# JSS HOC for React\n\n- [Basic](#basic)\n- [Accessing the theme inside the styled component](#accessing-the-theme-inside-t"
  },
  {
    "path": "docs/react-jss-ts.md",
    "chars": 4794,
    "preview": "# Using TypeScript with React-JSS\n\nReact-JSS enables you to supply types for your `ruleNames`, `props`/`data`, and `them"
  },
  {
    "path": "docs/react-jss.md",
    "chars": 16140,
    "preview": "# JSS integration with React\n\nReact-JSS integrates [JSS](https://github.com/cssinjs/jss) with React using the new Hooks "
  },
  {
    "path": "docs/setup.md",
    "chars": 3114,
    "preview": "# Setup\n\n## Install\n\n```bash\nyarn add jss\n```\n\nAlternatively, you can use [unpkg CDN](./cdn.md).\n\n## Polyfills\n\nCheck ou"
  },
  {
    "path": "docs/ssr.md",
    "chars": 804,
    "preview": "# Server-Side Rendering\n\n1.  Render the document.\n\n    The only JSS specific thing you need to know is the [Style Sheets"
  },
  {
    "path": "docs/users.md",
    "chars": 1102,
    "preview": "# Who is using JSS\n\n[Grape](https://chatgrape.com)\n\n[Kijiji](https://www.kijiji.ca/)\n\n[Material-UI](https://material-ui."
  },
  {
    "path": "examples/angular/app.js",
    "chars": 402,
    "preview": "import jss from 'jss'\nimport angular from 'angular'\n\n// Styles\nconst styles = {\n  button1: {\n    padding: '20px',\n    ba"
  },
  {
    "path": "examples/angular/index.html",
    "chars": 314,
    "preview": "<!DOCTYPE html>\n<html ng-app=\"myApp\">\n\n<head>\n  <meta charset=\"utf-8\">\n  <title>Angular with jss</title>\n  <script src=\""
  },
  {
    "path": "examples/angular/package.json",
    "chars": 186,
    "preview": "{\n  \"name\": \"jss-angular-example\",\n  \"license\": \"ISC\",\n  \"dependencies\": {\n    \"angular\": \"^1.7.9\",\n    \"jss\": \"^10.0.3\""
  },
  {
    "path": "examples/angular5/app/app.component.ts",
    "chars": 2598,
    "preview": "import {Component, OnInit} from '@angular/core'\r\n\r\nimport jss from 'jss'\r\n\r\n@Component({\r\n  selector: 'app',\r\n  template"
  },
  {
    "path": "examples/angular5/app/app.module.ts",
    "chars": 369,
    "preview": "import {NgModule} from '@angular/core'\r\nimport {BrowserModule} from '@angular/platform-browser'\r\nimport {AppComponent} f"
  },
  {
    "path": "examples/angular5/app/main.ts",
    "chars": 242,
    "preview": "import 'zone.js'\r\nimport {platformBrowserDynamic} from '@angular/platform-browser-dynamic'\r\nimport {AppModule} from './a"
  },
  {
    "path": "examples/angular5/index.html",
    "chars": 289,
    "preview": "<!doctype html>\r\n<html>\r\n\r\n<head>\r\n    <title>JSS Angular5 example</title>\r\n    <meta charset=\"utf-8\">\r\n    <meta name=\""
  },
  {
    "path": "examples/angular5/package.json",
    "chars": 478,
    "preview": "{\n  \"name\": \"jss-angular-example\",\n  \"version\": \"1.0.0\",\n  \"license\": \"ISC\",\n  \"dependencies\": {\n    \"@angular/common\": "
  },
  {
    "path": "examples/bootstrap/app.js",
    "chars": 529,
    "preview": "import jss from 'jss'\nimport preset from 'jss-preset-default'\nimport bootstrap from './bootstrap'\nimport bootstrapTheme "
  },
  {
    "path": "examples/bootstrap/bootstrap-theme.js",
    "chars": 18767,
    "preview": "export default {\n  '@global': {\n    '.btn-default, .btn-primary, .btn-success, .btn-info, .btn-warning, .btn-danger': {\n"
  },
  {
    "path": "examples/bootstrap/bootstrap.js",
    "chars": 147831,
    "preview": "export default {\n  '@global': {\n    html: {\n      'font-size': '10px',\n      '-webkit-tap-highlight-color': 'rgba(0, 0, "
  },
  {
    "path": "examples/bootstrap/index.html",
    "chars": 305,
    "preview": "<!DOCTYPE html>\n<html>\n\n<head>\n  <meta charset=\"utf-8\">\n  <title>Bootstrap jss example</title>\n</head>\n\n<body>\n  Bootstr"
  },
  {
    "path": "examples/bootstrap/package.json",
    "chars": 222,
    "preview": "{\n  \"name\": \"jss-bootstrap-example\",\n  \"version\": \"1.0.0\",\n  \"license\": \"ISC\",\n  \"dependencies\": {\n    \"jss\": \"^10.0.3\","
  },
  {
    "path": "examples/calendar/components/calendar/index.js",
    "chars": 1307,
    "preview": "import debounce from 'lodash/debounce'\nimport jss from '../jss'\nimport * as utils from '../utils'\nimport Canvas from '.."
  },
  {
    "path": "examples/calendar/components/calendar/style.js",
    "chars": 136,
    "preview": "import conf from '../conf'\n\nexport default {\n  calendar: {\n    display: 'flex',\n    fontSize: conf.fontSize,\n    color: "
  },
  {
    "path": "examples/calendar/components/canvas/index.js",
    "chars": 966,
    "preview": "import jss from '../jss'\nimport * as utils from '../utils'\nimport style from './style'\n\nconst sheet = jss.createStyleShe"
  },
  {
    "path": "examples/calendar/components/canvas/style.js",
    "chars": 318,
    "preview": "import conf from '../conf'\n\nexport default {\n  canvas: {\n    flex: 1,\n    position: 'relative',\n    height: conf.height,"
  },
  {
    "path": "examples/calendar/components/conf/index.js",
    "chars": 175,
    "preview": "/**\n * Configuration shared between all components.\n *\n * @type {Object}\n */\nexport default {\n  fontSize: 16,\n  height: "
  },
  {
    "path": "examples/calendar/components/event/content-tpl.js",
    "chars": 337,
    "preview": "/**\n * Returns compiled html for event content.\n *\n * @param {Object} data\n * @return {String}\n */\nexport function compi"
  },
  {
    "path": "examples/calendar/components/event/index.js",
    "chars": 1259,
    "preview": "import jss from '../jss'\nimport * as utils from '../utils'\nimport * as contentTpl from './content-tpl'\nimport style from"
  },
  {
    "path": "examples/calendar/components/event/style.js",
    "chars": 705,
    "preview": "export default {\n  event: {\n    position: 'absolute',\n    background: '#fff',\n    borderLeft: '4px solid #4b6ea8',\n    b"
  },
  {
    "path": "examples/calendar/components/events-manager/distribute.js",
    "chars": 2642,
    "preview": "import * as utils from '../utils'\n\n/**\n * Check if 2 events collide in time.\n *\n * @param {Event} event1\n * @param {Even"
  },
  {
    "path": "examples/calendar/components/events-manager/index.js",
    "chars": 895,
    "preview": "import Event from '../event'\nimport distribute from './distribute'\n\n/**\n * Handles events creation and distribution.\n */"
  },
  {
    "path": "examples/calendar/components/jss.js",
    "chars": 428,
    "preview": "// Setup jss plugins.\nimport {create} from 'jss'\nimport extend from 'jss-plugin-extend'\nimport nested from 'jss-plugin-n"
  },
  {
    "path": "examples/calendar/components/timeline/index.js",
    "chars": 1889,
    "preview": "import jss from '../jss'\nimport * as utils from '../utils'\nimport * as markerTpl from './marker-tpl'\nimport {rules} from"
  },
  {
    "path": "examples/calendar/components/timeline/marker-tpl.js",
    "chars": 443,
    "preview": "/**\n * Returns compiled template. Some template engine should be used in production\n * use case.\n *\n * @param {Object} d"
  },
  {
    "path": "examples/calendar/components/timeline/style.js",
    "chars": 670,
    "preview": "import conf from '../conf'\n\nexport const width = 75\n\nexport const rules = {\n  timeline: {\n    position: 'relative',\n    "
  },
  {
    "path": "examples/calendar/components/utils/index.js",
    "chars": 532,
    "preview": "import conf from '../conf'\n\n/**\n * Create DOM node, set attributes.\n *\n * @param {String} name\n * @param {Object} [attrs"
  },
  {
    "path": "examples/calendar/index.html",
    "chars": 522,
    "preview": "<!DOCTYPE html>\n<html>\n  <head>\n    <title>Calendar</title>\n    <meta charset=\"utf-8\" />\n  </head>\n  <body>\n    This exa"
  },
  {
    "path": "examples/calendar/index.js",
    "chars": 346,
    "preview": "import conf from './components/conf'\nimport Calendar from './components/calendar'\n\nconst calendar = new Calendar(conf).c"
  },
  {
    "path": "examples/calendar/package.json",
    "chars": 408,
    "preview": "{\n  \"name\": \"jss-calendar-example\",\n  \"version\": \"1.0.0\",\n  \"license\": \"ISC\",\n  \"dependencies\": {\n    \"jss\": \"^10.0.3\",\n"
  },
  {
    "path": "examples/composition/app.js",
    "chars": 475,
    "preview": "import jss from 'jss'\nimport componentA from './component-a-style'\nimport componentB from './component-b-style'\n\nconst s"
  },
  {
    "path": "examples/composition/component-a-style.js",
    "chars": 57,
    "preview": "export default {\n  button: {\n    background: 'red'\n  }\n}\n"
  },
  {
    "path": "examples/composition/component-b-style.js",
    "chars": 54,
    "preview": "export default {\n  button: {\n    color: 'green'\n  }\n}\n"
  },
  {
    "path": "examples/composition/index.html",
    "chars": 419,
    "preview": "<!DOCTYPE html>\n<html>\n  <head>\n    <meta charset=\"utf-8\">\n    <title>Simple jss example</title>\n  </head>\n  <body>\n    "
  },
  {
    "path": "examples/composition/package.json",
    "chars": 187,
    "preview": "{\n  \"name\": \"jss-composition-example\",\n  \"version\": \"1.0.0\",\n  \"license\": \"ISC\",\n  \"dependencies\": {\n    \"jss\": \"^10.0.3"
  },
  {
    "path": "examples/dynamic-props/app.js",
    "chars": 735,
    "preview": "import jss from 'jss'\n\n// Styles\nconst styles = {\n  box: {\n    float: 'left',\n    width: '50px',\n    height: '50px',\n   "
  },
  {
    "path": "examples/dynamic-props/index.html",
    "chars": 280,
    "preview": "<!DOCTYPE html>\n<html>\n  <head>\n    <meta charset=\"utf-8\">\n    <title>Dynamic properties in jss</title>\n  </head>\n  <bod"
  },
  {
    "path": "examples/dynamic-props/package.json",
    "chars": 189,
    "preview": "{\n  \"name\": \"jss-dynamic-props-example\",\n  \"version\": \"1.0.0\",\n  \"license\": \"ISC\",\n  \"dependencies\": {\n    \"jss\": \"^10.0"
  },
  {
    "path": "examples/function-values/.babelrc",
    "chars": 332,
    "preview": "{\n  \"presets\": [\n    \"env\",\n    \"stage-0\"\n  ],\n  \"plugins\": [\n    [\n      \"transform-runtime\",\n      {\n        \"polyfill"
  },
  {
    "path": "examples/function-values/Controls.js",
    "chars": 695,
    "preview": "import React from 'react'\n\nexport default ({onAdd, amount, onChangeRenderer}) => (\n  <div>\n    <form style={{marginBotto"
  },
  {
    "path": "examples/function-values/JssAnimation.js",
    "chars": 508,
    "preview": "import {Component} from 'react'\nimport * as jssRenderer from './jssRenderer'\n\nexport default class JssAnimation extends "
  },
  {
    "path": "examples/function-values/ReactAnimation.js",
    "chars": 643,
    "preview": "import React, {Component} from 'react'\nimport reactJssRenderer from './reactJssRenderer'\nimport reactInlineRenderer from"
  },
  {
    "path": "examples/function-values/app.js",
    "chars": 990,
    "preview": "import React, {Component} from 'react'\nimport Controls from './Controls'\nimport JssAnimation from './JssAnimation'\nimpor"
  },
  {
    "path": "examples/function-values/index.html",
    "chars": 255,
    "preview": "<!DOCTYPE html>\n<html>\n  <head>\n    <meta charset=\"utf-8\">\n    <title>Function values in jss</title>\n    <style>\n      h"
  },
  {
    "path": "examples/function-values/index.js",
    "chars": 158,
    "preview": "import React from 'react'\nimport {render} from 'react-dom'\nimport App from './app'\n\nrender(<App />, document.body.append"
  },
  {
    "path": "examples/function-values/jssRenderer.js",
    "chars": 1125,
    "preview": "import jss from 'jss'\nimport preset from 'jss-preset-default'\nimport times from 'lodash/times'\nimport {getRandomColor, g"
  },
  {
    "path": "examples/function-values/package.json",
    "chars": 361,
    "preview": "{\n  \"name\": \"jss-dynamic-props-example\",\n  \"version\": \"1.0.0\",\n  \"license\": \"ISC\",\n  \"dependencies\": {\n    \"jss\": \"^10.0"
  },
  {
    "path": "examples/function-values/reactInlineRenderer.js",
    "chars": 493,
    "preview": "import React from 'react'\nimport times from 'lodash/times'\nimport {getRandomColor, getRandomTransform} from './utils'\n\ne"
  },
  {
    "path": "examples/function-values/reactJssRenderer.js",
    "chars": 839,
    "preview": "import React, {Component} from 'react'\nimport injectSheet from 'react-jss'\nimport times from 'lodash/times'\nimport {getR"
  },
  {
    "path": "examples/function-values/utils.js",
    "chars": 874,
    "preview": "import random from 'lodash/random'\nimport Stats from 'stats.js'\n\nexport const getRandomColor = () => `#${Math.floor(Math"
  },
  {
    "path": "examples/inline/app.js",
    "chars": 583,
    "preview": "import jss from 'jss'\n\n// Styles\nconst styles = {\n  button1: {\n    padding: '20px',\n    background: 'blue'\n  }\n}\n\nconst "
  },
  {
    "path": "examples/inline/index.html",
    "chars": 173,
    "preview": "<!DOCTYPE html>\n<html>\n  <head>\n    <meta charset=\"utf-8\">\n    <title>Inline styles in JSS</title>\n  </head>\n  <body>\n  "
  },
  {
    "path": "examples/inline/package.json",
    "chars": 182,
    "preview": "{\n  \"name\": \"jss-inline-example\",\n  \"version\": \"1.0.0\",\n  \"license\": \"ISC\",\n  \"dependencies\": {\n    \"jss\": \"^10.0.3\"\n  }"
  },
  {
    "path": "examples/observables/index.html",
    "chars": 257,
    "preview": "<!DOCTYPE html>\n<html>\n  <head>\n    <meta charset=\"utf-8\">\n    <title>Observable values in JSS</title>\n    <style>\n     "
  },
  {
    "path": "examples/observables/index.js",
    "chars": 2135,
    "preview": "import {fromEvent} from 'rxjs'\nimport {switchMap, map, takeUntil} from 'rxjs/operators'\nimport jss from 'jss'\nimport pre"
  },
  {
    "path": "examples/observables/package.json",
    "chars": 246,
    "preview": "{\n  \"name\": \"jss-observables-example\",\n  \"version\": \"1.0.0\",\n  \"license\": \"ISC\",\n  \"dependencies\": {\n    \"jss\": \"^10.0.3"
  },
  {
    "path": "examples/perdido/app.js",
    "chars": 1420,
    "preview": "import jss from 'jss'\nimport jssPreset from 'jss-preset-default'\nimport styles from './styles'\n\njss.setup(jssPreset())\n\n"
  },
  {
    "path": "examples/perdido/index.html",
    "chars": 3907,
    "preview": "<!DOCTYPE html>\n<html>\n  <head>\n    <title>Perdido Demo</title>\n    <meta charset=\"utf-8\" />\n  </head>\n  <body>\n    <scr"
  },
  {
    "path": "examples/perdido/package.json",
    "chars": 249,
    "preview": "{\n  \"name\": \"jss-observables-example\",\n  \"version\": \"1.0.0\",\n  \"license\": \"ISC\",\n  \"dependencies\": {\n    \"jss\": \"^10.0.3"
  },
  {
    "path": "examples/perdido/styles.js",
    "chars": 3743,
    "preview": "import perdido from 'perdido'\n\nconst blockMar = 30\n\nexport default {\n  '@global': {\n    '*, *:after, *:before': {\n      "
  },
  {
    "path": "examples/plugins/jss-plugin-camel-case/app.js",
    "chars": 430,
    "preview": "import jss from 'jss'\nimport jssPluginCamelCase from 'jss-plugin-camel-case'\n\nconst styles = {\n  button: {\n    fontSize:"
  },
  {
    "path": "examples/plugins/jss-plugin-camel-case/index.html",
    "chars": 209,
    "preview": "<!DOCTYPE html>\n<html>\n  <head>\n    <title>Example - jss-plugin-camel-case</title>\n    <meta charset=\"UTF-8\" />\n  </head"
  },
  {
    "path": "examples/plugins/jss-plugin-camel-case/package.json",
    "chars": 209,
    "preview": "{\n  \"name\": \"jss-plugin-camel-case-example\",\n  \"license\": \"ISC\",\n  \"dependencies\": {\n    \"jss\": \"^10.0.3\",\n    \"jss-plug"
  },
  {
    "path": "examples/plugins/jss-plugin-compose/app.js",
    "chars": 725,
    "preview": "import jss from 'jss'\nimport jssPluginCompose from 'jss-plugin-compose'\n\nconst styles = {\n  button: {\n    composes: 'btn"
  },
  {
    "path": "examples/plugins/jss-plugin-compose/index.html",
    "chars": 206,
    "preview": "<!DOCTYPE html>\n<html>\n  <head>\n    <title>Example - jss-plugin-compose</title>\n    <meta charset=\"UTF-8\" />\n  </head>\n "
  },
  {
    "path": "examples/plugins/jss-plugin-compose/package.json",
    "chars": 203,
    "preview": "{\n  \"name\": \"jss-plugin-compose-example\",\n  \"license\": \"ISC\",\n  \"dependencies\": {\n    \"jss\": \"^10.0.3\",\n    \"jss-plugin-"
  },
  {
    "path": "examples/plugins/jss-plugin-default-unit/app.js",
    "chars": 439,
    "preview": "import jss from 'jss'\nimport jssPluginDefaultUnit from 'jss-plugin-default-unit'\n\nconst styles = {\n  button: {\n    'font"
  },
  {
    "path": "examples/plugins/jss-plugin-default-unit/index.html",
    "chars": 211,
    "preview": "<!DOCTYPE html>\n<html>\n  <head>\n    <title>Example - jss-plugin-default-unit</title>\n    <meta charset=\"UTF-8\" />\n  </he"
  },
  {
    "path": "examples/plugins/jss-plugin-default-unit/package.json",
    "chars": 213,
    "preview": "{\n  \"name\": \"jss-plugin-default-unit-example\",\n  \"license\": \"ISC\",\n  \"dependencies\": {\n    \"jss\": \"^10.0.3\",\n    \"jss-pl"
  },
  {
    "path": "examples/plugins/jss-plugin-expand/app.js",
    "chars": 442,
    "preview": "import jss from 'jss'\nimport jssPluginExpand from 'jss-plugin-expand'\n\nconst styles = {\n  button: {\n    border: {\n      "
  },
  {
    "path": "examples/plugins/jss-plugin-expand/index.html",
    "chars": 205,
    "preview": "<!DOCTYPE html>\n<html>\n  <head>\n    <title>Example - jss-plugin-expand</title>\n    <meta charset=\"UTF-8\" />\n  </head>\n  "
  },
  {
    "path": "examples/plugins/jss-plugin-expand/package.json",
    "chars": 201,
    "preview": "{\n  \"name\": \"jss-plugin-expand-example\",\n  \"license\": \"ISC\",\n  \"dependencies\": {\n    \"jss\": \"^10.0.3\",\n    \"jss-plugin-e"
  },
  {
    "path": "examples/plugins/jss-plugin-extend/app.js",
    "chars": 602,
    "preview": "import jss from 'jss'\nimport jssPluginExtend from 'jss-plugin-extend'\n\nconst button0 = {\n  padding: '20px',\n  background"
  },
  {
    "path": "examples/plugins/jss-plugin-extend/index.html",
    "chars": 205,
    "preview": "<!DOCTYPE html>\n<html>\n  <head>\n    <title>Example - jss-plugin-extend</title>\n    <meta charset=\"UTF-8\" />\n  </head>\n  "
  },
  {
    "path": "examples/plugins/jss-plugin-extend/package.json",
    "chars": 201,
    "preview": "{\n  \"name\": \"jss-plugin-extend-example\",\n  \"license\": \"ISC\",\n  \"dependencies\": {\n    \"jss\": \"^10.0.3\",\n    \"jss-plugin-e"
  },
  {
    "path": "examples/plugins/jss-plugin-global/app.js",
    "chars": 414,
    "preview": "import jss from 'jss'\nimport jssPluginGlobal from 'jss-plugin-global'\n\nconst styles = {\n  '@global': {\n    body: {\n     "
  },
  {
    "path": "examples/plugins/jss-plugin-global/index.html",
    "chars": 205,
    "preview": "<!DOCTYPE html>\n<html>\n  <head>\n    <title>Example - jss-plugin-global</title>\n    <meta charset=\"UTF-8\" />\n  </head>\n  "
  },
  {
    "path": "examples/plugins/jss-plugin-global/package.json",
    "chars": 201,
    "preview": "{\n  \"name\": \"jss-plugin-global-example\",\n  \"license\": \"ISC\",\n  \"dependencies\": {\n    \"jss\": \"^10.0.3\",\n    \"jss-plugin-g"
  },
  {
    "path": "examples/plugins/jss-plugin-isolate/app.js",
    "chars": 506,
    "preview": "import jss from 'jss'\nimport jssPluginIsolate from 'jss-plugin-isolate'\n\nconst styles = {\n  button: {\n    'background-co"
  },
  {
    "path": "examples/plugins/jss-plugin-isolate/index.html",
    "chars": 206,
    "preview": "<!DOCTYPE html>\n<html>\n  <head>\n    <title>Example - jss-plugin-isolate</title>\n    <meta charset=\"UTF-8\" />\n  </head>\n "
  },
  {
    "path": "examples/plugins/jss-plugin-isolate/package.json",
    "chars": 203,
    "preview": "{\n  \"name\": \"jss-plugin-isolate-example\",\n  \"license\": \"ISC\",\n  \"dependencies\": {\n    \"jss\": \"^10.0.3\",\n    \"jss-plugin-"
  },
  {
    "path": "examples/plugins/jss-plugin-nested/app.js",
    "chars": 619,
    "preview": "import jss from 'jss'\nimport jssPluginNested from 'jss-plugin-nested'\n\nconst styles = {\n  square: {\n    float: 'left',\n "
  },
  {
    "path": "examples/plugins/jss-plugin-nested/index.html",
    "chars": 205,
    "preview": "<!DOCTYPE html>\n<html>\n  <head>\n    <title>Example - jss-plugin-nested</title>\n    <meta charset=\"UTF-8\" />\n  </head>\n  "
  },
  {
    "path": "examples/plugins/jss-plugin-nested/package.json",
    "chars": 201,
    "preview": "{\n  \"name\": \"jss-plugin-nested-example\",\n  \"license\": \"ISC\",\n  \"dependencies\": {\n    \"jss\": \"^10.0.3\",\n    \"jss-plugin-n"
  },
  {
    "path": "examples/plugins/jss-plugin-props-sort/app.js",
    "chars": 449,
    "preview": "import jss from 'jss'\nimport jssPluginPropsSort from 'jss-plugin-props-sort'\n\n// Styles\nconst styles = {\n  button: {\n   "
  },
  {
    "path": "examples/plugins/jss-plugin-props-sort/index.html",
    "chars": 209,
    "preview": "<!DOCTYPE html>\n<html>\n  <head>\n    <title>Example - jss-plugin-props-sort</title>\n    <meta charset=\"UTF-8\" />\n  </head"
  },
  {
    "path": "examples/plugins/jss-plugin-props-sort/package.json",
    "chars": 209,
    "preview": "{\n  \"name\": \"jss-plugin-props-sort-example\",\n  \"license\": \"ISC\",\n  \"dependencies\": {\n    \"jss\": \"^10.0.3\",\n    \"jss-plug"
  },
  {
    "path": "examples/plugins/jss-plugin-rule-value-function/app.js",
    "chars": 474,
    "preview": "import jss from 'jss'\nimport jssPluginRuleValueFunction from 'jss-plugin-rule-value-function'\n\nconst styles = {\n  button"
  },
  {
    "path": "examples/plugins/jss-plugin-rule-value-function/index.html",
    "chars": 218,
    "preview": "<!DOCTYPE html>\n<html>\n  <head>\n    <title>Example - jss-plugin-rule-value-function</title>\n    <meta charset=\"UTF-8\" />"
  },
  {
    "path": "examples/plugins/jss-plugin-rule-value-function/package.json",
    "chars": 227,
    "preview": "{\n  \"name\": \"jss-plugin-rule-value-function-example\",\n  \"license\": \"ISC\",\n  \"dependencies\": {\n    \"jss\": \"^10.0.3\",\n    "
  },
  {
    "path": "examples/plugins/jss-plugin-rule-value-observable/app.js",
    "chars": 524,
    "preview": "import jss from 'jss'\nimport {Observable} from 'rxjs'\nimport jssPluginRuleValueObservable from 'jss-plugin-rule-value-ob"
  },
  {
    "path": "examples/plugins/jss-plugin-rule-value-observable/index.html",
    "chars": 220,
    "preview": "<!DOCTYPE html>\n<html>\n  <head>\n    <title>Example - jss-plugin-rule-value-observable</title>\n    <meta charset=\"UTF-8\" "
  },
  {
    "path": "examples/plugins/jss-plugin-rule-value-observable/package.json",
    "chars": 252,
    "preview": "{\n  \"name\": \"jss-plugin-rule-value-observable-example\",\n  \"license\": \"ISC\",\n  \"dependencies\": {\n    \"jss\": \"^10.0.3\",\n  "
  },
  {
    "path": "examples/plugins/jss-plugin-template/app.js",
    "chars": 690,
    "preview": "import jss from 'jss'\nimport jssPluginTemplate from 'jss-plugin-template'\n\n// Styles\nconst styles = {\n  '@keyframes rota"
  },
  {
    "path": "examples/plugins/jss-plugin-template/index.html",
    "chars": 207,
    "preview": "<!DOCTYPE html>\n<html>\n  <head>\n    <title>Example - jss-plugin-template</title>\n    <meta charset=\"UTF-8\" />\n  </head>\n"
  },
  {
    "path": "examples/plugins/jss-plugin-template/package.json",
    "chars": 205,
    "preview": "{\n  \"name\": \"jss-plugin-template-example\",\n  \"license\": \"ISC\",\n  \"dependencies\": {\n    \"jss\": \"^10.0.3\",\n    \"jss-plugin"
  },
  {
    "path": "examples/plugins/jss-plugin-vendor-prefixer/app.js",
    "chars": 423,
    "preview": "import jss from 'jss'\nimport jssPluginVendorPrefixer from 'jss-plugin-vendor-prefixer'\n\nconst styles = {\n  button: {\n   "
  },
  {
    "path": "examples/plugins/jss-plugin-vendor-prefixer/index.html",
    "chars": 214,
    "preview": "<!DOCTYPE html>\n<html>\n  <head>\n    <title>Example - jss-plugin-vendor-prefixer</title>\n    <meta charset=\"UTF-8\" />\n  <"
  },
  {
    "path": "examples/plugins/jss-plugin-vendor-prefixer/package.json",
    "chars": 219,
    "preview": "{\n  \"name\": \"jss-plugin-vendor-prefixer-example\",\n  \"license\": \"ISC\",\n  \"dependencies\": {\n    \"jss\": \"^10.0.3\",\n    \"jss"
  },
  {
    "path": "examples/react-ssr/client.js",
    "chars": 347,
    "preview": "import React from 'react'\nimport {render} from 'react-dom'\nimport Button from './src/Button'\n\nrender(<Button />, documen"
  },
  {
    "path": "examples/react-ssr/package.json",
    "chars": 631,
    "preview": "{\n  \"name\": \"jss-react-ssr-example\",\n  \"version\": \"1.0.0\",\n  \"license\": \"ISC\",\n  \"main\": \"server.js\",\n  \"scripts\": {\n   "
  },
  {
    "path": "examples/react-ssr/sandbox.config.json",
    "chars": 111,
    "preview": "{\n  \"infiniteLoopProtection\": true,\n  \"hardReloadOnChange\": false,\n  \"view\": \"browser\",\n  \"template\": \"node\"\n}\n"
  },
  {
    "path": "examples/react-ssr/server.js",
    "chars": 428,
    "preview": "require('@babel/register')({\n  presets: ['@babel/preset-env', '@babel/preset-react']\n})\n\nconst express = require('expres"
  },
  {
    "path": "examples/react-ssr/src/Button.js",
    "chars": 292,
    "preview": "import React from 'react'\nimport injectSheet from 'react-jss'\n\nconst styles = {\n  button: {\n    color: 'green'\n  }\n}\n\nfu"
  },
  {
    "path": "examples/react-ssr/ssr.js",
    "chars": 747,
    "preview": "import React from 'react'\nimport {renderToString} from 'react-dom/server'\nimport {JssProvider, SheetsRegistry} from 'rea"
  },
  {
    "path": "examples/react-ssr/static/client.js",
    "chars": 402841,
    "preview": "parcelRequire = (function(e, r, t, n) {\n  var i,\n    o = 'function' == typeof parcelRequire && parcelRequire,\n    u = 'f"
  },
  {
    "path": "examples/swinging-cat/index.html",
    "chars": 465,
    "preview": "<!DOCTYPE html>\n<html>\n  <head>\n    <meta charset=\"utf-8\">\n    <title>Swinging cat</title>\n    <style>\n      html, body "
  },
  {
    "path": "examples/swinging-cat/index.js",
    "chars": 96,
    "preview": "import './src/globalStyles'\nimport scene from './src/scene'\n\ndocument.body.appendChild(scene())\n"
  },
  {
    "path": "examples/swinging-cat/package.json",
    "chars": 225,
    "preview": "{\n  \"name\": \"jss-swinging-cat-example\",\n  \"version\": \"1.0.0\",\n  \"license\": \"ISC\",\n  \"dependencies\": {\n    \"jss\": \"^10.0."
  },
  {
    "path": "examples/swinging-cat/src/ear.js",
    "chars": 1085,
    "preview": "import jss from './jss'\n\nconst styles = {\n  catEar: {\n    width: 20,\n    height: '100%',\n    position: 'absolute',\n    b"
  },
  {
    "path": "examples/swinging-cat/src/face.js",
    "chars": 3183,
    "preview": "import jss from './jss'\nimport * as theme from './theme'\nimport sheet from './globalStyles'\n\nconst styles = {\n  catFace:"
  },
  {
    "path": "examples/swinging-cat/src/globalStyles.js",
    "chars": 1420,
    "preview": "import jss from './jss'\nimport * as theme from './theme'\nimport keyframes from './keyframes'\n\nconst styles = {\n  '@globa"
  },
  {
    "path": "examples/swinging-cat/src/hand.js",
    "chars": 785,
    "preview": "import jss from './jss'\nimport * as theme from './theme'\n\nconst styles = {\n  catHand: {\n    position: 'absolute',\n    wi"
  },
  {
    "path": "examples/swinging-cat/src/jss.js",
    "chars": 98,
    "preview": "import jss from 'jss'\nimport preset from 'jss-preset-default'\n\nexport default jss.setup(preset())\n"
  },
  {
    "path": "examples/swinging-cat/src/keyframes.js",
    "chars": 3762,
    "preview": "export default {\n  bob: {\n    '0%': {\n      transform: 'translateY(0.4rem)'\n    },\n    '6.25%': {\n      transform: 'tran"
  },
  {
    "path": "examples/swinging-cat/src/leg.js",
    "chars": 1310,
    "preview": "import jss from './jss'\nimport * as theme from './theme'\nimport sheet from './globalStyles'\n\nconst styles = {\n  catLower"
  },
  {
    "path": "examples/swinging-cat/src/lowerBody.js",
    "chars": 1206,
    "preview": "import jss from './jss'\nimport * as theme from './theme'\nimport leg from './leg'\nimport tail from './tail'\nimport sheet "
  },
  {
    "path": "examples/swinging-cat/src/scene.js",
    "chars": 1668,
    "preview": "import jss from './jss'\nimport * as theme from './theme'\nimport yarn from './yarn'\nimport upperBody from './upperBody'\ni"
  },
  {
    "path": "examples/swinging-cat/src/tail.js",
    "chars": 969,
    "preview": "import jss from './jss'\nimport * as theme from './theme'\nimport sheet from './globalStyles'\n\nconst styles = {\n  catTail:"
  },
  {
    "path": "examples/swinging-cat/src/theme.js",
    "chars": 436,
    "preview": "export const colorBg = '#1F1F3C'\nexport const colorFurLight = '#D5E8F8'\nexport const colorFurDark = '#8B9BD9'\nexport con"
  },
  {
    "path": "examples/swinging-cat/src/upperBody.js",
    "chars": 981,
    "preview": "import jss from './jss'\nimport * as theme from './theme'\nimport face from './face'\nimport hand from './hand'\nimport ear "
  },
  {
    "path": "examples/swinging-cat/src/yarn.js",
    "chars": 853,
    "preview": "import jss from './jss'\nimport * as theme from './theme'\n\nconst styles = {\n  yarn: {\n    position: 'absolute',\n    top: "
  },
  {
    "path": "examples/swinging-cat-rx/index.html",
    "chars": 494,
    "preview": "<!DOCTYPE html>\n<html>\n  <head>\n    <meta charset=\"utf-8\">\n    <title>Swinging cat RX</title>\n    <style>\n      html, bo"
  },
  {
    "path": "examples/swinging-cat-rx/index.js",
    "chars": 142,
    "preview": "import './src/globalStyles'\nimport scene from './src/scene'\nimport {setup} from './src/animation'\n\ndocument.body.appendC"
  },
  {
    "path": "examples/swinging-cat-rx/package.json",
    "chars": 305,
    "preview": "{\n  \"name\": \"jss-swinging-cat-rx-example\",\n  \"version\": \"1.0.0\",\n  \"license\": \"ISC\",\n  \"dependencies\": {\n    \"dynamics.j"
  },
  {
    "path": "examples/swinging-cat-rx/src/animation.js",
    "chars": 2260,
    "preview": "import {fromEventPattern, of, interval, animationFrame, combineLatest, Subject} from 'rxjs'\nimport {switchMap, startWith"
  },
  {
    "path": "examples/swinging-cat-rx/src/ear.js",
    "chars": 1085,
    "preview": "import jss from './jss'\n\nconst styles = {\n  catEar: {\n    width: 20,\n    height: '100%',\n    position: 'absolute',\n    b"
  },
  {
    "path": "examples/swinging-cat-rx/src/face.js",
    "chars": 3625,
    "preview": "import {map} from 'rxjs/operators'\nimport jss from './jss'\nimport * as theme from './theme'\nimport {\n  swingAnimation$,\n"
  },
  {
    "path": "examples/swinging-cat-rx/src/globalStyles.js",
    "chars": 809,
    "preview": "import jss from './jss'\nimport * as theme from './theme'\n\nconst styles = {\n  '@global': {\n    body: {\n      height: '100"
  },
  {
    "path": "examples/swinging-cat-rx/src/hand.js",
    "chars": 803,
    "preview": "import jss from './jss'\nimport * as theme from './theme'\n\nconst styles = {\n  catHand: {\n    position: 'absolute',\n    wi"
  },
  {
    "path": "examples/swinging-cat-rx/src/jss.js",
    "chars": 98,
    "preview": "import jss from 'jss'\nimport preset from 'jss-preset-default'\n\nexport default jss.setup(preset())\n"
  },
  {
    "path": "examples/swinging-cat-rx/src/leg.js",
    "chars": 1370,
    "preview": "import {delay} from 'rxjs/operators'\nimport jss from './jss'\nimport * as theme from './theme'\nimport {swingAnimation$} f"
  },
  {
    "path": "examples/swinging-cat-rx/src/lowerBody.js",
    "chars": 1171,
    "preview": "import {delay} from 'rxjs/operators'\nimport jss from './jss'\nimport * as theme from './theme'\nimport leg from './leg'\nim"
  },
  {
    "path": "examples/swinging-cat-rx/src/scene.js",
    "chars": 1626,
    "preview": "import {delay} from 'rxjs/operators'\nimport jss from './jss'\nimport * as theme from './theme'\nimport yarn from './yarn'\n"
  },
  {
    "path": "examples/swinging-cat-rx/src/tail.js",
    "chars": 1005,
    "preview": "import jss from './jss'\nimport * as theme from './theme'\nimport {swingAnimation$} from './animation'\n\nconst styles = {\n "
  },
  {
    "path": "examples/swinging-cat-rx/src/theme.js",
    "chars": 335,
    "preview": "export const colorBg = '#1F1F3C'\nexport const colorFurLight = '#D5E8F8'\nexport const colorFurDark = '#8B9BD9'\nexport con"
  },
  {
    "path": "examples/swinging-cat-rx/src/upperBody.js",
    "chars": 1005,
    "preview": "import jss from './jss'\nimport * as theme from './theme'\nimport face from './face'\nimport hand from './hand'\nimport ear "
  },
  {
    "path": "examples/swinging-cat-rx/src/yarn.js",
    "chars": 883,
    "preview": "import jss from './jss'\nimport * as theme from './theme'\n\nconst styles = {\n  yarn: {\n    position: 'absolute',\n    top: "
  },
  {
    "path": "flow-typed/css.js",
    "chars": 182,
    "preview": "interface CSSOM {\n  px(val: number | string): {};\n  percent(val: number | string): {};\n  ms(val: number | string): {};\n "
  },
  {
    "path": "flow-typed/mocha.js",
    "chars": 138,
    "preview": "declare function describe(string, Function): void\ndeclare function it(string, Function): void\ndeclare function beforeEac"
  },
  {
    "path": "karma.conf.js",
    "chars": 2182,
    "preview": "const webpack = require('./webpack.config')\nconst browsers = require('./browsers')\n\nconst isBench = process.env.BENCHMAR"
  }
]

// ... and 330 more files (download for full content)

About this extraction

This page contains the full source code of the cssinjs/jss GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 530 files (7.2 MB), approximately 1.9M tokens, and a symbol index with 5179 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.

Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.

Copied to clipboard!