diff --git a/.eslintignore b/.eslintignore
new file mode 100644
index 0000000..1521c8b
--- /dev/null
+++ b/.eslintignore
@@ -0,0 +1 @@
+dist
diff --git a/.eslintrc.js b/.eslintrc.js
new file mode 100644
index 0000000..3139d9b
--- /dev/null
+++ b/.eslintrc.js
@@ -0,0 +1,22 @@
+module.exports = {
+ root: true,
+ parser: "@typescript-eslint/parser", // Specifies the ESLint parser
+ extends: [
+ "plugin:@typescript-eslint/recommended", // Uses the recommended rules from the @typescript-eslint/eslint-plugin
+ "prettier/@typescript-eslint", // Uses eslint-config-prettier to disable ESLint rules from @typescript-eslint/eslint-plugin that would conflict with prettier
+ "plugin:prettier/recommended", // Enables eslint-plugin-prettier and eslint-config-prettier. This will display prettier errors as ESLint errors. Make sure this is always the last configuration in the extends array.
+ ],
+ parserOptions: {
+ ecmaVersion: 2018, // Allows for the parsing of modern ECMAScript features
+ sourceType: "module", // Allows for the use of imports
+ },
+ rules: {
+ // Place to specify ESLint rules. Can be used to overwrite rules specified from the extended configs
+ // e.g. "@typescript-eslint/explicit-function-return-type": "off",
+ },
+ env: {
+ es6: true,
+ node: true,
+ jest: true,
+ },
+};
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..4c4b4f3
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,18 @@
+name: tests
+on:
+ push:
+ branches:
+ - main
+ pull_request:
+ branches:
+ - main
+jobs:
+ test:
+ name: test
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v2
+ - uses: actions/setup-node@v1
+ - run: npm ci
+ - run: npm run lint
+ - run: npm run test
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 0000000..2a18008
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,41 @@
+name: release v2
+on:
+ push:
+ branches:
+ - main
+
+ # Trigger release manually
+ workflow_dispatch:
+
+jobs:
+ release:
+ name: release
+ runs-on: ubuntu-latest
+ steps:
+ - name: Ensure v2.x exists
+ continue-on-error: true
+ env:
+ GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+ run: |
+ export SHA=$( gh api \
+ /repos/$GITHUB_REPOSITORY/git/refs/heads/main \
+ | jq --raw-output '.object.sha' )
+ gh api /repos/$GITHUB_REPOSITORY/git/refs \
+ --field sha="$SHA" \
+ --field ref="refs/heads/v2.x"
+ - uses: actions/checkout@v2
+ - uses: actions/setup-node@v1
+ - run: npm ci
+ - run: npm run build
+ - uses: ./
+ env:
+ GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+ with:
+ files: |
+ dist/index.js
+ commit-message: Add dist/index.js
+ ref: refs/heads/v2.x
+ - uses: actions/upload-artifact@v2
+ with:
+ name: build
+ path: dist/index.js
diff --git a/.github/workflows/verified-commit.yml b/.github/workflows/verified-commit.yml
deleted file mode 100644
index 968ab42..0000000
--- a/.github/workflows/verified-commit.yml
+++ /dev/null
@@ -1,40 +0,0 @@
-name: Verified Commit Demo
-
-# npx trigger-repository-dispatch --nwo=swinton/verified-commit --event-type=demo
-on:
- workflow_dispatch:
- repository_dispatch:
- types: [demo]
-
-jobs:
- demo:
- name: Demo
- runs-on: ubuntu-latest
- steps:
-
- - name: Context
- env:
- GITHUB_CONTEXT: ${{ toJson(github) }}
- run: |
- echo "$GITHUB_CONTEXT"
-
- - name: Checkout
- uses: actions/checkout@v2
-
- - name: Create file
- run: |
- dd if=/dev/urandom count=1 > myfile
-
- - name: Commit file
- uses: ./
- env:
- GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
- with:
- path: ./myfile
-
- - name: Inspect environment
- run: |
- echo HEAD_SHA=$HEAD_SHA
- echo BASE_TREE_SHA=$BASE_TREE_SHA
- echo BLOB_SHA=$BLOB_SHA
- echo TREE_SHA=$TREE_SHA
diff --git a/.gitignore b/.gitignore
index 7a6353d..e3c5d61 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,118 @@
.envrc
+
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+
+# Diagnostic reports (https://nodejs.org/api/report.html)
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+*.lcov
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (https://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Snowpack dependency directory (https://snowpack.dev/)
+web_modules/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Microbundle cache
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variables file
+.env
+.env.test
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# Next.js build output
+.next
+out
+
+# Nuxt.js build / generate output
+.nuxt
+dist
+
+# Gatsby files
+.cache/
+# Comment in the public line in if your project uses Gatsby and not Next.js
+# https://nextjs.org/blog/next-9-1#public-directory-support
+# public
+
+# vuepress build output
+.vuepress/dist
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# TernJS port file
+.tern-port
+
+# Stores VSCode versions used for testing VSCode extensions
+.vscode-test
+
+# yarn v2
+.yarn/cache
+.yarn/unplugged
+.yarn/build-state.yml
+.yarn/install-state.gz
+.pnp.*
diff --git a/README.md b/README.md
index 05b0251..05269ca 100644
--- a/README.md
+++ b/README.md
@@ -1,22 +1,54 @@
# Commit
-> Create a commit with GitHub Actions
+> :white_check_mark: Create a _verified_ commit with GitHub Actions
-## :warning: Warning
-This action is still in development and the experience is subject to change. Use at your own risk.
+  [](https://github.com/prettier/prettier)
## About
-This action allows you to create a commit with GitHub Actions. Commits created with this aciton will be marked as _verified_.
+This action allows you to create a commit with GitHub Actions. Commits created with this actions will be marked as _verified_.
+
+
## Usage
In your workflow, to commit a file `./myfile`, include a step like this:
```yaml
- name: Commit file
- uses: swinton/commit@v0
+ uses: swinton/commit@v2.x
+ env:
+ GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+ with:
+ files: |
+ myfile
+ commit-message: Committing ./myfile
+ ref: refs/heads/my-branch
+```
+
+Note, the `GH_TOKEN` environment variable is _required_, since commits are created using GitHub's [Git Database API](https://docs.github.com/rest/reference/git).
+
+To commit multiple files in a single commit, pass each file on a newline to the `files` input:
+
+```yaml
+ - name: Commit files
+ uses: swinton/commit@v2.x
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with:
- path: ./myfile
+ files: |
+ path/to/myfile1
+ path/to/myfile2
+ path/to/myfile3
+ commit-message: Committing files
+ ref: refs/heads/my-branch
```
-Note, the `GH_TOKEN` environment variable is required, since commits are created using GitHub's [Git Database API](https://docs.github.com/rest/reference/git).
+## Inputs
+The following inputs are _required_:
+
+- `files`: Newline-separated list of files to be committed, relative to root of repository, e.g. myfile1
myfile2
...
myfileN
+- `commit-message`: Commit message to be used, e.g. `Add ./myfile`
+- `ref`: Fully qualified name of reference to be updated with commit, e.g. `refs/heads/production`. This reference _must_ already exist. Defaults to the repository's default branch ref.
+
+## Outputs
+This action provides the following outputs:
+
+- `commit-sha`: SHA of created commit
diff --git a/action.yml b/action.yml
index ded1313..78105f1 100644
--- a/action.yml
+++ b/action.yml
@@ -1,23 +1,30 @@
name: Verified commit
description: GitHub Action to create verified commits
inputs:
- path:
- description: Filesystem path of file to be committed
+ files:
+ description: |
+ Newline-separated list of files to be committed, relative to root of repository.
required: true
+ workspace:
+ description: |
+ Base directory containing files to be committed, defaults to the GitHub workspace directory path, $GITHUB_WORKSPACE.
+ required: false
+ default: ''
+ commit-message:
+ description: |
+ Commit message to be used
+ required: true
+ ref:
+ description: |
+ Reference to be updated with commit. This reference must already exist. Defaults to the repository's default branch ref.
+ required: false
+ default: ''
+outputs:
+ commit-sha:
+ description: SHA of created commit
runs:
- using: composite
- steps:
- # Get object ids: head commit sha, tree sha
- - shell: bash
- run: ./get-oids.sh
-
- # Create blob
- - shell: bash
- run: ./create-blob.sh "${{ inputs.path }}"
-
- # Create tree
- - shell: bash
- run: ./create-tree.sh
+ using: node12
+ main: dist/index.js
branding:
icon: git-commit
color: purple
diff --git a/create-blob.sh b/create-blob.sh
deleted file mode 100755
index 48bfde6..0000000
--- a/create-blob.sh
+++ /dev/null
@@ -1,26 +0,0 @@
-#!/bin/bash
-set -e
-
-# Path to file containing blob contents
-path="${1}"
-
-# Encode blob contents
-content=$( mktemp )
-base64 -i "${path}" | jq --raw-input '.' > $content
-
-# Generate payload
-payload=$( mktemp )
-jq --null-input \
- --arg encoding "base64" \
- --slurpfile content "$content" \
- '{"content": $content[0], "encoding": $encoding}' > $payload
-
-# Create blob
-response=$( curl --request POST \
- --url https://api.github.com/repos/$GITHUB_REPOSITORY/git/blobs \
- --header "authorization: Bearer $GH_TOKEN" \
- --header 'content-type: application/json' \
- --data @$payload )
-
-# Export environment variables with object ids
-echo BLOB_SHA=$( jq -r '.sha' <<< "${response}" ) >> $GITHUB_ENV
diff --git a/create-tree.sh b/create-tree.sh
deleted file mode 100644
index b78525b..0000000
--- a/create-tree.sh
+++ /dev/null
@@ -1,19 +0,0 @@
-#!/bin/bash
-set -e
-
-# Generate payload
-payload=$( mktemp )
-jq --null-input \
- --arg blob_sha "$BLOB_SHA" \
- --arg base_tree "$BASE_TREE_SHA" \
- '{"tree": [{"path": "extra", "mode": "100644", "type": "blob", "sha": $blob_sha}], "base_tree": $base_tree}' > $payload
-
-# Create tree
-response=$( curl --request POST \
- --url https://api.github.com/repos/$GITHUB_REPOSITORY/git/trees \
- --header "authorization: Bearer $GH_TOKEN" \
- --header 'content-type: application/json' \
- --data @$payload )
-
-# Export environment variables with object ids
-echo TREE_SHA=$( jq -r '.sha' <<< "${response}" ) >> $GITHUB_ENV
diff --git a/debug.sh b/debug.sh
deleted file mode 100755
index 0d874aa..0000000
--- a/debug.sh
+++ /dev/null
@@ -1,4 +0,0 @@
-#!/bin/bash
-set -e
-
-exit 0
diff --git a/dist/index.js b/dist/index.js
new file mode 100644
index 0000000..6f60dda
--- /dev/null
+++ b/dist/index.js
@@ -0,0 +1,8535 @@
+module.exports =
+/******/ (() => { // webpackBootstrap
+/******/ var __webpack_modules__ = ({
+
+/***/ 7351:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __importStar = (this && this.__importStar) || function (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;
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const os = __importStar(__webpack_require__(2087));
+const utils_1 = __webpack_require__(5278);
+/**
+ * Commands
+ *
+ * Command Format:
+ * ::name key=value,key=value::message
+ *
+ * Examples:
+ * ::warning::This is the message
+ * ::set-env name=MY_VAR::some value
+ */
+function issueCommand(command, properties, message) {
+ const cmd = new Command(command, properties, message);
+ process.stdout.write(cmd.toString() + os.EOL);
+}
+exports.issueCommand = issueCommand;
+function issue(name, message = '') {
+ issueCommand(name, {}, message);
+}
+exports.issue = issue;
+const CMD_STRING = '::';
+class Command {
+ constructor(command, properties, message) {
+ if (!command) {
+ command = 'missing.command';
+ }
+ this.command = command;
+ this.properties = properties;
+ this.message = message;
+ }
+ toString() {
+ let cmdStr = CMD_STRING + this.command;
+ if (this.properties && Object.keys(this.properties).length > 0) {
+ cmdStr += ' ';
+ let first = true;
+ for (const key in this.properties) {
+ if (this.properties.hasOwnProperty(key)) {
+ const val = this.properties[key];
+ if (val) {
+ if (first) {
+ first = false;
+ }
+ else {
+ cmdStr += ',';
+ }
+ cmdStr += `${key}=${escapeProperty(val)}`;
+ }
+ }
+ }
+ }
+ cmdStr += `${CMD_STRING}${escapeData(this.message)}`;
+ return cmdStr;
+ }
+}
+function escapeData(s) {
+ return utils_1.toCommandValue(s)
+ .replace(/%/g, '%25')
+ .replace(/\r/g, '%0D')
+ .replace(/\n/g, '%0A');
+}
+function escapeProperty(s) {
+ return utils_1.toCommandValue(s)
+ .replace(/%/g, '%25')
+ .replace(/\r/g, '%0D')
+ .replace(/\n/g, '%0A')
+ .replace(/:/g, '%3A')
+ .replace(/,/g, '%2C');
+}
+//# sourceMappingURL=command.js.map
+
+/***/ }),
+
+/***/ 2186:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+ 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) : adopt(result.value).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+var __importStar = (this && this.__importStar) || function (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;
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const command_1 = __webpack_require__(7351);
+const file_command_1 = __webpack_require__(717);
+const utils_1 = __webpack_require__(5278);
+const os = __importStar(__webpack_require__(2087));
+const path = __importStar(__webpack_require__(5622));
+/**
+ * The code to exit an action
+ */
+var ExitCode;
+(function (ExitCode) {
+ /**
+ * A code indicating that the action was successful
+ */
+ ExitCode[ExitCode["Success"] = 0] = "Success";
+ /**
+ * A code indicating that the action was a failure
+ */
+ ExitCode[ExitCode["Failure"] = 1] = "Failure";
+})(ExitCode = exports.ExitCode || (exports.ExitCode = {}));
+//-----------------------------------------------------------------------
+// Variables
+//-----------------------------------------------------------------------
+/**
+ * Sets env variable for this action and future actions in the job
+ * @param name the name of the variable to set
+ * @param val the value of the variable. Non-string values will be converted to a string via JSON.stringify
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function exportVariable(name, val) {
+ const convertedVal = utils_1.toCommandValue(val);
+ process.env[name] = convertedVal;
+ const filePath = process.env['GITHUB_ENV'] || '';
+ if (filePath) {
+ const delimiter = '_GitHubActionsFileCommandDelimeter_';
+ const commandValue = `${name}<<${delimiter}${os.EOL}${convertedVal}${os.EOL}${delimiter}`;
+ file_command_1.issueCommand('ENV', commandValue);
+ }
+ else {
+ command_1.issueCommand('set-env', { name }, convertedVal);
+ }
+}
+exports.exportVariable = exportVariable;
+/**
+ * Registers a secret which will get masked from logs
+ * @param secret value of the secret
+ */
+function setSecret(secret) {
+ command_1.issueCommand('add-mask', {}, secret);
+}
+exports.setSecret = setSecret;
+/**
+ * Prepends inputPath to the PATH (for this action and future actions)
+ * @param inputPath
+ */
+function addPath(inputPath) {
+ const filePath = process.env['GITHUB_PATH'] || '';
+ if (filePath) {
+ file_command_1.issueCommand('PATH', inputPath);
+ }
+ else {
+ command_1.issueCommand('add-path', {}, inputPath);
+ }
+ process.env['PATH'] = `${inputPath}${path.delimiter}${process.env['PATH']}`;
+}
+exports.addPath = addPath;
+/**
+ * Gets the value of an input. The value is also trimmed.
+ *
+ * @param name name of the input to get
+ * @param options optional. See InputOptions.
+ * @returns string
+ */
+function getInput(name, options) {
+ const val = process.env[`INPUT_${name.replace(/ /g, '_').toUpperCase()}`] || '';
+ if (options && options.required && !val) {
+ throw new Error(`Input required and not supplied: ${name}`);
+ }
+ return val.trim();
+}
+exports.getInput = getInput;
+/**
+ * Sets the value of an output.
+ *
+ * @param name name of the output to set
+ * @param value value to store. Non-string values will be converted to a string via JSON.stringify
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function setOutput(name, value) {
+ command_1.issueCommand('set-output', { name }, value);
+}
+exports.setOutput = setOutput;
+/**
+ * Enables or disables the echoing of commands into stdout for the rest of the step.
+ * Echoing is disabled by default if ACTIONS_STEP_DEBUG is not set.
+ *
+ */
+function setCommandEcho(enabled) {
+ command_1.issue('echo', enabled ? 'on' : 'off');
+}
+exports.setCommandEcho = setCommandEcho;
+//-----------------------------------------------------------------------
+// Results
+//-----------------------------------------------------------------------
+/**
+ * Sets the action status to failed.
+ * When the action exits it will be with an exit code of 1
+ * @param message add error issue message
+ */
+function setFailed(message) {
+ process.exitCode = ExitCode.Failure;
+ error(message);
+}
+exports.setFailed = setFailed;
+//-----------------------------------------------------------------------
+// Logging Commands
+//-----------------------------------------------------------------------
+/**
+ * Gets whether Actions Step Debug is on or not
+ */
+function isDebug() {
+ return process.env['RUNNER_DEBUG'] === '1';
+}
+exports.isDebug = isDebug;
+/**
+ * Writes debug message to user log
+ * @param message debug message
+ */
+function debug(message) {
+ command_1.issueCommand('debug', {}, message);
+}
+exports.debug = debug;
+/**
+ * Adds an error issue
+ * @param message error issue message. Errors will be converted to string via toString()
+ */
+function error(message) {
+ command_1.issue('error', message instanceof Error ? message.toString() : message);
+}
+exports.error = error;
+/**
+ * Adds an warning issue
+ * @param message warning issue message. Errors will be converted to string via toString()
+ */
+function warning(message) {
+ command_1.issue('warning', message instanceof Error ? message.toString() : message);
+}
+exports.warning = warning;
+/**
+ * Writes info to log with console.log.
+ * @param message info message
+ */
+function info(message) {
+ process.stdout.write(message + os.EOL);
+}
+exports.info = info;
+/**
+ * Begin an output group.
+ *
+ * Output until the next `groupEnd` will be foldable in this group
+ *
+ * @param name The name of the output group
+ */
+function startGroup(name) {
+ command_1.issue('group', name);
+}
+exports.startGroup = startGroup;
+/**
+ * End an output group.
+ */
+function endGroup() {
+ command_1.issue('endgroup');
+}
+exports.endGroup = endGroup;
+/**
+ * Wrap an asynchronous function call in a group.
+ *
+ * Returns the same type as the function itself.
+ *
+ * @param name The name of the group
+ * @param fn The function to wrap in the group
+ */
+function group(name, fn) {
+ return __awaiter(this, void 0, void 0, function* () {
+ startGroup(name);
+ let result;
+ try {
+ result = yield fn();
+ }
+ finally {
+ endGroup();
+ }
+ return result;
+ });
+}
+exports.group = group;
+//-----------------------------------------------------------------------
+// Wrapper action state
+//-----------------------------------------------------------------------
+/**
+ * Saves state for current action, the state can only be retrieved by this action's post job execution.
+ *
+ * @param name name of the state to store
+ * @param value value to store. Non-string values will be converted to a string via JSON.stringify
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function saveState(name, value) {
+ command_1.issueCommand('save-state', { name }, value);
+}
+exports.saveState = saveState;
+/**
+ * Gets the value of an state set by this action's main execution.
+ *
+ * @param name name of the state to get
+ * @returns string
+ */
+function getState(name) {
+ return process.env[`STATE_${name}`] || '';
+}
+exports.getState = getState;
+//# sourceMappingURL=core.js.map
+
+/***/ }),
+
+/***/ 717:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+// For internal use, subject to change.
+var __importStar = (this && this.__importStar) || function (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;
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+// We use any as a valid input type
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const fs = __importStar(__webpack_require__(5747));
+const os = __importStar(__webpack_require__(2087));
+const utils_1 = __webpack_require__(5278);
+function issueCommand(command, message) {
+ const filePath = process.env[`GITHUB_${command}`];
+ if (!filePath) {
+ throw new Error(`Unable to find environment variable for file command ${command}`);
+ }
+ if (!fs.existsSync(filePath)) {
+ throw new Error(`Missing file at path: ${filePath}`);
+ }
+ fs.appendFileSync(filePath, `${utils_1.toCommandValue(message)}${os.EOL}`, {
+ encoding: 'utf8'
+ });
+}
+exports.issueCommand = issueCommand;
+//# sourceMappingURL=file-command.js.map
+
+/***/ }),
+
+/***/ 5278:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+// We use any as a valid input type
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+/**
+ * Sanitizes an input into a string so it can be passed into issueCommand safely
+ * @param input input to sanitize into a string
+ */
+function toCommandValue(input) {
+ if (input === null || input === undefined) {
+ return '';
+ }
+ else if (typeof input === 'string' || input instanceof String) {
+ return input;
+ }
+ return JSON.stringify(input);
+}
+exports.toCommandValue = toCommandValue;
+//# sourceMappingURL=utils.js.map
+
+/***/ }),
+
+/***/ 6545:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+module.exports = __webpack_require__(2618);
+
+/***/ }),
+
+/***/ 8104:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+var utils = __webpack_require__(328);
+var settle = __webpack_require__(3211);
+var buildFullPath = __webpack_require__(1934);
+var buildURL = __webpack_require__(646);
+var http = __webpack_require__(8605);
+var https = __webpack_require__(7211);
+var httpFollow = __webpack_require__(7707).http;
+var httpsFollow = __webpack_require__(7707).https;
+var url = __webpack_require__(8835);
+var zlib = __webpack_require__(8761);
+var pkg = __webpack_require__(696);
+var createError = __webpack_require__(5226);
+var enhanceError = __webpack_require__(1516);
+
+var isHttps = /https:?/;
+
+/*eslint consistent-return:0*/
+module.exports = function httpAdapter(config) {
+ return new Promise(function dispatchHttpRequest(resolvePromise, rejectPromise) {
+ var resolve = function resolve(value) {
+ resolvePromise(value);
+ };
+ var reject = function reject(value) {
+ rejectPromise(value);
+ };
+ var data = config.data;
+ var headers = config.headers;
+
+ // Set User-Agent (required by some servers)
+ // Only set header if it hasn't been set in config
+ // See https://github.com/axios/axios/issues/69
+ if (!headers['User-Agent'] && !headers['user-agent']) {
+ headers['User-Agent'] = 'axios/' + pkg.version;
+ }
+
+ if (data && !utils.isStream(data)) {
+ if (Buffer.isBuffer(data)) {
+ // Nothing to do...
+ } else if (utils.isArrayBuffer(data)) {
+ data = Buffer.from(new Uint8Array(data));
+ } else if (utils.isString(data)) {
+ data = Buffer.from(data, 'utf-8');
+ } else {
+ return reject(createError(
+ 'Data after transformation must be a string, an ArrayBuffer, a Buffer, or a Stream',
+ config
+ ));
+ }
+
+ // Add Content-Length header if data exists
+ headers['Content-Length'] = data.length;
+ }
+
+ // HTTP basic authentication
+ var auth = undefined;
+ if (config.auth) {
+ var username = config.auth.username || '';
+ var password = config.auth.password || '';
+ auth = username + ':' + password;
+ }
+
+ // Parse url
+ var fullPath = buildFullPath(config.baseURL, config.url);
+ var parsed = url.parse(fullPath);
+ var protocol = parsed.protocol || 'http:';
+
+ if (!auth && parsed.auth) {
+ var urlAuth = parsed.auth.split(':');
+ var urlUsername = urlAuth[0] || '';
+ var urlPassword = urlAuth[1] || '';
+ auth = urlUsername + ':' + urlPassword;
+ }
+
+ if (auth) {
+ delete headers.Authorization;
+ }
+
+ var isHttpsRequest = isHttps.test(protocol);
+ var agent = isHttpsRequest ? config.httpsAgent : config.httpAgent;
+
+ var options = {
+ path: buildURL(parsed.path, config.params, config.paramsSerializer).replace(/^\?/, ''),
+ method: config.method.toUpperCase(),
+ headers: headers,
+ agent: agent,
+ agents: { http: config.httpAgent, https: config.httpsAgent },
+ auth: auth
+ };
+
+ if (config.socketPath) {
+ options.socketPath = config.socketPath;
+ } else {
+ options.hostname = parsed.hostname;
+ options.port = parsed.port;
+ }
+
+ var proxy = config.proxy;
+ if (!proxy && proxy !== false) {
+ var proxyEnv = protocol.slice(0, -1) + '_proxy';
+ var proxyUrl = process.env[proxyEnv] || process.env[proxyEnv.toUpperCase()];
+ if (proxyUrl) {
+ var parsedProxyUrl = url.parse(proxyUrl);
+ var noProxyEnv = process.env.no_proxy || process.env.NO_PROXY;
+ var shouldProxy = true;
+
+ if (noProxyEnv) {
+ var noProxy = noProxyEnv.split(',').map(function trim(s) {
+ return s.trim();
+ });
+
+ shouldProxy = !noProxy.some(function proxyMatch(proxyElement) {
+ if (!proxyElement) {
+ return false;
+ }
+ if (proxyElement === '*') {
+ return true;
+ }
+ if (proxyElement[0] === '.' &&
+ parsed.hostname.substr(parsed.hostname.length - proxyElement.length) === proxyElement) {
+ return true;
+ }
+
+ return parsed.hostname === proxyElement;
+ });
+ }
+
+
+ if (shouldProxy) {
+ proxy = {
+ host: parsedProxyUrl.hostname,
+ port: parsedProxyUrl.port
+ };
+
+ if (parsedProxyUrl.auth) {
+ var proxyUrlAuth = parsedProxyUrl.auth.split(':');
+ proxy.auth = {
+ username: proxyUrlAuth[0],
+ password: proxyUrlAuth[1]
+ };
+ }
+ }
+ }
+ }
+
+ if (proxy) {
+ options.hostname = proxy.host;
+ options.host = proxy.host;
+ options.headers.host = parsed.hostname + (parsed.port ? ':' + parsed.port : '');
+ options.port = proxy.port;
+ options.path = protocol + '//' + parsed.hostname + (parsed.port ? ':' + parsed.port : '') + options.path;
+
+ // Basic proxy authorization
+ if (proxy.auth) {
+ var base64 = Buffer.from(proxy.auth.username + ':' + proxy.auth.password, 'utf8').toString('base64');
+ options.headers['Proxy-Authorization'] = 'Basic ' + base64;
+ }
+ }
+
+ var transport;
+ var isHttpsProxy = isHttpsRequest && (proxy ? isHttps.test(proxy.protocol) : true);
+ if (config.transport) {
+ transport = config.transport;
+ } else if (config.maxRedirects === 0) {
+ transport = isHttpsProxy ? https : http;
+ } else {
+ if (config.maxRedirects) {
+ options.maxRedirects = config.maxRedirects;
+ }
+ transport = isHttpsProxy ? httpsFollow : httpFollow;
+ }
+
+ if (config.maxBodyLength > -1) {
+ options.maxBodyLength = config.maxBodyLength;
+ }
+
+ // Create the request
+ var req = transport.request(options, function handleResponse(res) {
+ if (req.aborted) return;
+
+ // uncompress the response body transparently if required
+ var stream = res;
+
+ // return the last request in case of redirects
+ var lastRequest = res.req || req;
+
+
+ // if no content, is HEAD request or decompress disabled we should not decompress
+ if (res.statusCode !== 204 && lastRequest.method !== 'HEAD' && config.decompress !== false) {
+ switch (res.headers['content-encoding']) {
+ /*eslint default-case:0*/
+ case 'gzip':
+ case 'compress':
+ case 'deflate':
+ // add the unzipper to the body stream processing pipeline
+ stream = stream.pipe(zlib.createUnzip());
+
+ // remove the content-encoding in order to not confuse downstream operations
+ delete res.headers['content-encoding'];
+ break;
+ }
+ }
+
+ var response = {
+ status: res.statusCode,
+ statusText: res.statusMessage,
+ headers: res.headers,
+ config: config,
+ request: lastRequest
+ };
+
+ if (config.responseType === 'stream') {
+ response.data = stream;
+ settle(resolve, reject, response);
+ } else {
+ var responseBuffer = [];
+ stream.on('data', function handleStreamData(chunk) {
+ responseBuffer.push(chunk);
+
+ // make sure the content length is not over the maxContentLength if specified
+ if (config.maxContentLength > -1 && Buffer.concat(responseBuffer).length > config.maxContentLength) {
+ stream.destroy();
+ reject(createError('maxContentLength size of ' + config.maxContentLength + ' exceeded',
+ config, null, lastRequest));
+ }
+ });
+
+ stream.on('error', function handleStreamError(err) {
+ if (req.aborted) return;
+ reject(enhanceError(err, config, null, lastRequest));
+ });
+
+ stream.on('end', function handleStreamEnd() {
+ var responseData = Buffer.concat(responseBuffer);
+ if (config.responseType !== 'arraybuffer') {
+ responseData = responseData.toString(config.responseEncoding);
+ if (!config.responseEncoding || config.responseEncoding === 'utf8') {
+ responseData = utils.stripBOM(responseData);
+ }
+ }
+
+ response.data = responseData;
+ settle(resolve, reject, response);
+ });
+ }
+ });
+
+ // Handle errors
+ req.on('error', function handleRequestError(err) {
+ if (req.aborted && err.code !== 'ERR_FR_TOO_MANY_REDIRECTS') return;
+ reject(enhanceError(err, config, null, req));
+ });
+
+ // Handle request timeout
+ if (config.timeout) {
+ // Sometime, the response will be very slow, and does not respond, the connect event will be block by event loop system.
+ // And timer callback will be fired, and abort() will be invoked before connection, then get "socket hang up" and code ECONNRESET.
+ // At this time, if we have a large number of request, nodejs will hang up some socket on background. and the number will up and up.
+ // And then these socket which be hang up will devoring CPU little by little.
+ // ClientRequest.setTimeout will be fired on the specify milliseconds, and can make sure that abort() will be fired after connect.
+ req.setTimeout(config.timeout, function handleRequestTimeout() {
+ req.abort();
+ reject(createError('timeout of ' + config.timeout + 'ms exceeded', config, 'ECONNABORTED', req));
+ });
+ }
+
+ if (config.cancelToken) {
+ // Handle cancellation
+ config.cancelToken.promise.then(function onCanceled(cancel) {
+ if (req.aborted) return;
+
+ req.abort();
+ reject(cancel);
+ });
+ }
+
+ // Send the request
+ if (utils.isStream(data)) {
+ data.on('error', function handleStreamError(err) {
+ reject(enhanceError(err, config, null, req));
+ }).pipe(req);
+ } else {
+ req.end(data);
+ }
+ });
+};
+
+
+/***/ }),
+
+/***/ 3454:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+var utils = __webpack_require__(328);
+var settle = __webpack_require__(3211);
+var cookies = __webpack_require__(1545);
+var buildURL = __webpack_require__(646);
+var buildFullPath = __webpack_require__(1934);
+var parseHeaders = __webpack_require__(6455);
+var isURLSameOrigin = __webpack_require__(3608);
+var createError = __webpack_require__(5226);
+
+module.exports = function xhrAdapter(config) {
+ return new Promise(function dispatchXhrRequest(resolve, reject) {
+ var requestData = config.data;
+ var requestHeaders = config.headers;
+
+ if (utils.isFormData(requestData)) {
+ delete requestHeaders['Content-Type']; // Let the browser set it
+ }
+
+ var request = new XMLHttpRequest();
+
+ // HTTP basic authentication
+ if (config.auth) {
+ var username = config.auth.username || '';
+ var password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : '';
+ requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);
+ }
+
+ var fullPath = buildFullPath(config.baseURL, config.url);
+ request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);
+
+ // Set the request timeout in MS
+ request.timeout = config.timeout;
+
+ // Listen for ready state
+ request.onreadystatechange = function handleLoad() {
+ if (!request || request.readyState !== 4) {
+ return;
+ }
+
+ // The request errored out and we didn't get a response, this will be
+ // handled by onerror instead
+ // With one exception: request that using file: protocol, most browsers
+ // will return status as 0 even though it's a successful request
+ if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {
+ return;
+ }
+
+ // Prepare the response
+ var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;
+ var responseData = !config.responseType || config.responseType === 'text' ? request.responseText : request.response;
+ var response = {
+ data: responseData,
+ status: request.status,
+ statusText: request.statusText,
+ headers: responseHeaders,
+ config: config,
+ request: request
+ };
+
+ settle(resolve, reject, response);
+
+ // Clean up request
+ request = null;
+ };
+
+ // Handle browser request cancellation (as opposed to a manual cancellation)
+ request.onabort = function handleAbort() {
+ if (!request) {
+ return;
+ }
+
+ reject(createError('Request aborted', config, 'ECONNABORTED', request));
+
+ // Clean up request
+ request = null;
+ };
+
+ // Handle low level network errors
+ request.onerror = function handleError() {
+ // Real errors are hidden from us by the browser
+ // onerror should only fire if it's a network error
+ reject(createError('Network Error', config, null, request));
+
+ // Clean up request
+ request = null;
+ };
+
+ // Handle timeout
+ request.ontimeout = function handleTimeout() {
+ var timeoutErrorMessage = 'timeout of ' + config.timeout + 'ms exceeded';
+ if (config.timeoutErrorMessage) {
+ timeoutErrorMessage = config.timeoutErrorMessage;
+ }
+ reject(createError(timeoutErrorMessage, config, 'ECONNABORTED',
+ request));
+
+ // Clean up request
+ request = null;
+ };
+
+ // Add xsrf header
+ // This is only done if running in a standard browser environment.
+ // Specifically not if we're in a web worker, or react-native.
+ if (utils.isStandardBrowserEnv()) {
+ // Add xsrf header
+ var xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath)) && config.xsrfCookieName ?
+ cookies.read(config.xsrfCookieName) :
+ undefined;
+
+ if (xsrfValue) {
+ requestHeaders[config.xsrfHeaderName] = xsrfValue;
+ }
+ }
+
+ // Add headers to the request
+ if ('setRequestHeader' in request) {
+ utils.forEach(requestHeaders, function setRequestHeader(val, key) {
+ if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {
+ // Remove Content-Type if data is undefined
+ delete requestHeaders[key];
+ } else {
+ // Otherwise add header to the request
+ request.setRequestHeader(key, val);
+ }
+ });
+ }
+
+ // Add withCredentials to request if needed
+ if (!utils.isUndefined(config.withCredentials)) {
+ request.withCredentials = !!config.withCredentials;
+ }
+
+ // Add responseType to request if needed
+ if (config.responseType) {
+ try {
+ request.responseType = config.responseType;
+ } catch (e) {
+ // Expected DOMException thrown by browsers not compatible XMLHttpRequest Level 2.
+ // But, this can be suppressed for 'json' type as it can be parsed by default 'transformResponse' function.
+ if (config.responseType !== 'json') {
+ throw e;
+ }
+ }
+ }
+
+ // Handle progress if needed
+ if (typeof config.onDownloadProgress === 'function') {
+ request.addEventListener('progress', config.onDownloadProgress);
+ }
+
+ // Not all browsers support upload events
+ if (typeof config.onUploadProgress === 'function' && request.upload) {
+ request.upload.addEventListener('progress', config.onUploadProgress);
+ }
+
+ if (config.cancelToken) {
+ // Handle cancellation
+ config.cancelToken.promise.then(function onCanceled(cancel) {
+ if (!request) {
+ return;
+ }
+
+ request.abort();
+ reject(cancel);
+ // Clean up request
+ request = null;
+ });
+ }
+
+ if (!requestData) {
+ requestData = null;
+ }
+
+ // Send the request
+ request.send(requestData);
+ });
+};
+
+
+/***/ }),
+
+/***/ 2618:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+var utils = __webpack_require__(328);
+var bind = __webpack_require__(7065);
+var Axios = __webpack_require__(8178);
+var mergeConfig = __webpack_require__(4831);
+var defaults = __webpack_require__(8190);
+
+/**
+ * Create an instance of Axios
+ *
+ * @param {Object} defaultConfig The default config for the instance
+ * @return {Axios} A new instance of Axios
+ */
+function createInstance(defaultConfig) {
+ var context = new Axios(defaultConfig);
+ var instance = bind(Axios.prototype.request, context);
+
+ // Copy axios.prototype to instance
+ utils.extend(instance, Axios.prototype, context);
+
+ // Copy context to instance
+ utils.extend(instance, context);
+
+ return instance;
+}
+
+// Create the default instance to be exported
+var axios = createInstance(defaults);
+
+// Expose Axios class to allow class inheritance
+axios.Axios = Axios;
+
+// Factory for creating new instances
+axios.create = function create(instanceConfig) {
+ return createInstance(mergeConfig(axios.defaults, instanceConfig));
+};
+
+// Expose Cancel & CancelToken
+axios.Cancel = __webpack_require__(8875);
+axios.CancelToken = __webpack_require__(1587);
+axios.isCancel = __webpack_require__(4057);
+
+// Expose all/spread
+axios.all = function all(promises) {
+ return Promise.all(promises);
+};
+axios.spread = __webpack_require__(4850);
+
+module.exports = axios;
+
+// Allow use of default import syntax in TypeScript
+module.exports.default = axios;
+
+
+/***/ }),
+
+/***/ 8875:
+/***/ ((module) => {
+
+"use strict";
+
+
+/**
+ * A `Cancel` is an object that is thrown when an operation is canceled.
+ *
+ * @class
+ * @param {string=} message The message.
+ */
+function Cancel(message) {
+ this.message = message;
+}
+
+Cancel.prototype.toString = function toString() {
+ return 'Cancel' + (this.message ? ': ' + this.message : '');
+};
+
+Cancel.prototype.__CANCEL__ = true;
+
+module.exports = Cancel;
+
+
+/***/ }),
+
+/***/ 1587:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+var Cancel = __webpack_require__(8875);
+
+/**
+ * A `CancelToken` is an object that can be used to request cancellation of an operation.
+ *
+ * @class
+ * @param {Function} executor The executor function.
+ */
+function CancelToken(executor) {
+ if (typeof executor !== 'function') {
+ throw new TypeError('executor must be a function.');
+ }
+
+ var resolvePromise;
+ this.promise = new Promise(function promiseExecutor(resolve) {
+ resolvePromise = resolve;
+ });
+
+ var token = this;
+ executor(function cancel(message) {
+ if (token.reason) {
+ // Cancellation has already been requested
+ return;
+ }
+
+ token.reason = new Cancel(message);
+ resolvePromise(token.reason);
+ });
+}
+
+/**
+ * Throws a `Cancel` if cancellation has been requested.
+ */
+CancelToken.prototype.throwIfRequested = function throwIfRequested() {
+ if (this.reason) {
+ throw this.reason;
+ }
+};
+
+/**
+ * Returns an object that contains a new `CancelToken` and a function that, when called,
+ * cancels the `CancelToken`.
+ */
+CancelToken.source = function source() {
+ var cancel;
+ var token = new CancelToken(function executor(c) {
+ cancel = c;
+ });
+ return {
+ token: token,
+ cancel: cancel
+ };
+};
+
+module.exports = CancelToken;
+
+
+/***/ }),
+
+/***/ 4057:
+/***/ ((module) => {
+
+"use strict";
+
+
+module.exports = function isCancel(value) {
+ return !!(value && value.__CANCEL__);
+};
+
+
+/***/ }),
+
+/***/ 8178:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+var utils = __webpack_require__(328);
+var buildURL = __webpack_require__(646);
+var InterceptorManager = __webpack_require__(3214);
+var dispatchRequest = __webpack_require__(5062);
+var mergeConfig = __webpack_require__(4831);
+
+/**
+ * Create a new instance of Axios
+ *
+ * @param {Object} instanceConfig The default config for the instance
+ */
+function Axios(instanceConfig) {
+ this.defaults = instanceConfig;
+ this.interceptors = {
+ request: new InterceptorManager(),
+ response: new InterceptorManager()
+ };
+}
+
+/**
+ * Dispatch a request
+ *
+ * @param {Object} config The config specific for this request (merged with this.defaults)
+ */
+Axios.prototype.request = function request(config) {
+ /*eslint no-param-reassign:0*/
+ // Allow for axios('example/url'[, config]) a la fetch API
+ if (typeof config === 'string') {
+ config = arguments[1] || {};
+ config.url = arguments[0];
+ } else {
+ config = config || {};
+ }
+
+ config = mergeConfig(this.defaults, config);
+
+ // Set config.method
+ if (config.method) {
+ config.method = config.method.toLowerCase();
+ } else if (this.defaults.method) {
+ config.method = this.defaults.method.toLowerCase();
+ } else {
+ config.method = 'get';
+ }
+
+ // Hook up interceptors middleware
+ var chain = [dispatchRequest, undefined];
+ var promise = Promise.resolve(config);
+
+ this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
+ chain.unshift(interceptor.fulfilled, interceptor.rejected);
+ });
+
+ this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
+ chain.push(interceptor.fulfilled, interceptor.rejected);
+ });
+
+ while (chain.length) {
+ promise = promise.then(chain.shift(), chain.shift());
+ }
+
+ return promise;
+};
+
+Axios.prototype.getUri = function getUri(config) {
+ config = mergeConfig(this.defaults, config);
+ return buildURL(config.url, config.params, config.paramsSerializer).replace(/^\?/, '');
+};
+
+// Provide aliases for supported request methods
+utils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {
+ /*eslint func-names:0*/
+ Axios.prototype[method] = function(url, config) {
+ return this.request(mergeConfig(config || {}, {
+ method: method,
+ url: url,
+ data: (config || {}).data
+ }));
+ };
+});
+
+utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
+ /*eslint func-names:0*/
+ Axios.prototype[method] = function(url, data, config) {
+ return this.request(mergeConfig(config || {}, {
+ method: method,
+ url: url,
+ data: data
+ }));
+ };
+});
+
+module.exports = Axios;
+
+
+/***/ }),
+
+/***/ 3214:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+var utils = __webpack_require__(328);
+
+function InterceptorManager() {
+ this.handlers = [];
+}
+
+/**
+ * Add a new interceptor to the stack
+ *
+ * @param {Function} fulfilled The function to handle `then` for a `Promise`
+ * @param {Function} rejected The function to handle `reject` for a `Promise`
+ *
+ * @return {Number} An ID used to remove interceptor later
+ */
+InterceptorManager.prototype.use = function use(fulfilled, rejected) {
+ this.handlers.push({
+ fulfilled: fulfilled,
+ rejected: rejected
+ });
+ return this.handlers.length - 1;
+};
+
+/**
+ * Remove an interceptor from the stack
+ *
+ * @param {Number} id The ID that was returned by `use`
+ */
+InterceptorManager.prototype.eject = function eject(id) {
+ if (this.handlers[id]) {
+ this.handlers[id] = null;
+ }
+};
+
+/**
+ * Iterate over all the registered interceptors
+ *
+ * This method is particularly useful for skipping over any
+ * interceptors that may have become `null` calling `eject`.
+ *
+ * @param {Function} fn The function to call for each interceptor
+ */
+InterceptorManager.prototype.forEach = function forEach(fn) {
+ utils.forEach(this.handlers, function forEachHandler(h) {
+ if (h !== null) {
+ fn(h);
+ }
+ });
+};
+
+module.exports = InterceptorManager;
+
+
+/***/ }),
+
+/***/ 1934:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+var isAbsoluteURL = __webpack_require__(1301);
+var combineURLs = __webpack_require__(7189);
+
+/**
+ * Creates a new URL by combining the baseURL with the requestedURL,
+ * only when the requestedURL is not already an absolute URL.
+ * If the requestURL is absolute, this function returns the requestedURL untouched.
+ *
+ * @param {string} baseURL The base URL
+ * @param {string} requestedURL Absolute or relative URL to combine
+ * @returns {string} The combined full path
+ */
+module.exports = function buildFullPath(baseURL, requestedURL) {
+ if (baseURL && !isAbsoluteURL(requestedURL)) {
+ return combineURLs(baseURL, requestedURL);
+ }
+ return requestedURL;
+};
+
+
+/***/ }),
+
+/***/ 5226:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+var enhanceError = __webpack_require__(1516);
+
+/**
+ * Create an Error with the specified message, config, error code, request and response.
+ *
+ * @param {string} message The error message.
+ * @param {Object} config The config.
+ * @param {string} [code] The error code (for example, 'ECONNABORTED').
+ * @param {Object} [request] The request.
+ * @param {Object} [response] The response.
+ * @returns {Error} The created error.
+ */
+module.exports = function createError(message, config, code, request, response) {
+ var error = new Error(message);
+ return enhanceError(error, config, code, request, response);
+};
+
+
+/***/ }),
+
+/***/ 5062:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+var utils = __webpack_require__(328);
+var transformData = __webpack_require__(9812);
+var isCancel = __webpack_require__(4057);
+var defaults = __webpack_require__(8190);
+
+/**
+ * Throws a `Cancel` if cancellation has been requested.
+ */
+function throwIfCancellationRequested(config) {
+ if (config.cancelToken) {
+ config.cancelToken.throwIfRequested();
+ }
+}
+
+/**
+ * Dispatch a request to the server using the configured adapter.
+ *
+ * @param {object} config The config that is to be used for the request
+ * @returns {Promise} The Promise to be fulfilled
+ */
+module.exports = function dispatchRequest(config) {
+ throwIfCancellationRequested(config);
+
+ // Ensure headers exist
+ config.headers = config.headers || {};
+
+ // Transform request data
+ config.data = transformData(
+ config.data,
+ config.headers,
+ config.transformRequest
+ );
+
+ // Flatten headers
+ config.headers = utils.merge(
+ config.headers.common || {},
+ config.headers[config.method] || {},
+ config.headers
+ );
+
+ utils.forEach(
+ ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],
+ function cleanHeaderConfig(method) {
+ delete config.headers[method];
+ }
+ );
+
+ var adapter = config.adapter || defaults.adapter;
+
+ return adapter(config).then(function onAdapterResolution(response) {
+ throwIfCancellationRequested(config);
+
+ // Transform response data
+ response.data = transformData(
+ response.data,
+ response.headers,
+ config.transformResponse
+ );
+
+ return response;
+ }, function onAdapterRejection(reason) {
+ if (!isCancel(reason)) {
+ throwIfCancellationRequested(config);
+
+ // Transform response data
+ if (reason && reason.response) {
+ reason.response.data = transformData(
+ reason.response.data,
+ reason.response.headers,
+ config.transformResponse
+ );
+ }
+ }
+
+ return Promise.reject(reason);
+ });
+};
+
+
+/***/ }),
+
+/***/ 1516:
+/***/ ((module) => {
+
+"use strict";
+
+
+/**
+ * Update an Error with the specified config, error code, and response.
+ *
+ * @param {Error} error The error to update.
+ * @param {Object} config The config.
+ * @param {string} [code] The error code (for example, 'ECONNABORTED').
+ * @param {Object} [request] The request.
+ * @param {Object} [response] The response.
+ * @returns {Error} The error.
+ */
+module.exports = function enhanceError(error, config, code, request, response) {
+ error.config = config;
+ if (code) {
+ error.code = code;
+ }
+
+ error.request = request;
+ error.response = response;
+ error.isAxiosError = true;
+
+ error.toJSON = function toJSON() {
+ return {
+ // Standard
+ message: this.message,
+ name: this.name,
+ // Microsoft
+ description: this.description,
+ number: this.number,
+ // Mozilla
+ fileName: this.fileName,
+ lineNumber: this.lineNumber,
+ columnNumber: this.columnNumber,
+ stack: this.stack,
+ // Axios
+ config: this.config,
+ code: this.code
+ };
+ };
+ return error;
+};
+
+
+/***/ }),
+
+/***/ 4831:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+var utils = __webpack_require__(328);
+
+/**
+ * Config-specific merge-function which creates a new config-object
+ * by merging two configuration objects together.
+ *
+ * @param {Object} config1
+ * @param {Object} config2
+ * @returns {Object} New object resulting from merging config2 to config1
+ */
+module.exports = function mergeConfig(config1, config2) {
+ // eslint-disable-next-line no-param-reassign
+ config2 = config2 || {};
+ var config = {};
+
+ var valueFromConfig2Keys = ['url', 'method', 'data'];
+ var mergeDeepPropertiesKeys = ['headers', 'auth', 'proxy', 'params'];
+ var defaultToConfig2Keys = [
+ 'baseURL', 'transformRequest', 'transformResponse', 'paramsSerializer',
+ 'timeout', 'timeoutMessage', 'withCredentials', 'adapter', 'responseType', 'xsrfCookieName',
+ 'xsrfHeaderName', 'onUploadProgress', 'onDownloadProgress', 'decompress',
+ 'maxContentLength', 'maxBodyLength', 'maxRedirects', 'transport', 'httpAgent',
+ 'httpsAgent', 'cancelToken', 'socketPath', 'responseEncoding'
+ ];
+ var directMergeKeys = ['validateStatus'];
+
+ function getMergedValue(target, source) {
+ if (utils.isPlainObject(target) && utils.isPlainObject(source)) {
+ return utils.merge(target, source);
+ } else if (utils.isPlainObject(source)) {
+ return utils.merge({}, source);
+ } else if (utils.isArray(source)) {
+ return source.slice();
+ }
+ return source;
+ }
+
+ function mergeDeepProperties(prop) {
+ if (!utils.isUndefined(config2[prop])) {
+ config[prop] = getMergedValue(config1[prop], config2[prop]);
+ } else if (!utils.isUndefined(config1[prop])) {
+ config[prop] = getMergedValue(undefined, config1[prop]);
+ }
+ }
+
+ utils.forEach(valueFromConfig2Keys, function valueFromConfig2(prop) {
+ if (!utils.isUndefined(config2[prop])) {
+ config[prop] = getMergedValue(undefined, config2[prop]);
+ }
+ });
+
+ utils.forEach(mergeDeepPropertiesKeys, mergeDeepProperties);
+
+ utils.forEach(defaultToConfig2Keys, function defaultToConfig2(prop) {
+ if (!utils.isUndefined(config2[prop])) {
+ config[prop] = getMergedValue(undefined, config2[prop]);
+ } else if (!utils.isUndefined(config1[prop])) {
+ config[prop] = getMergedValue(undefined, config1[prop]);
+ }
+ });
+
+ utils.forEach(directMergeKeys, function merge(prop) {
+ if (prop in config2) {
+ config[prop] = getMergedValue(config1[prop], config2[prop]);
+ } else if (prop in config1) {
+ config[prop] = getMergedValue(undefined, config1[prop]);
+ }
+ });
+
+ var axiosKeys = valueFromConfig2Keys
+ .concat(mergeDeepPropertiesKeys)
+ .concat(defaultToConfig2Keys)
+ .concat(directMergeKeys);
+
+ var otherKeys = Object
+ .keys(config1)
+ .concat(Object.keys(config2))
+ .filter(function filterAxiosKeys(key) {
+ return axiosKeys.indexOf(key) === -1;
+ });
+
+ utils.forEach(otherKeys, mergeDeepProperties);
+
+ return config;
+};
+
+
+/***/ }),
+
+/***/ 3211:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+var createError = __webpack_require__(5226);
+
+/**
+ * Resolve or reject a Promise based on response status.
+ *
+ * @param {Function} resolve A function that resolves the promise.
+ * @param {Function} reject A function that rejects the promise.
+ * @param {object} response The response.
+ */
+module.exports = function settle(resolve, reject, response) {
+ var validateStatus = response.config.validateStatus;
+ if (!response.status || !validateStatus || validateStatus(response.status)) {
+ resolve(response);
+ } else {
+ reject(createError(
+ 'Request failed with status code ' + response.status,
+ response.config,
+ null,
+ response.request,
+ response
+ ));
+ }
+};
+
+
+/***/ }),
+
+/***/ 9812:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+var utils = __webpack_require__(328);
+
+/**
+ * Transform the data for a request or a response
+ *
+ * @param {Object|String} data The data to be transformed
+ * @param {Array} headers The headers for the request or response
+ * @param {Array|Function} fns A single function or Array of functions
+ * @returns {*} The resulting transformed data
+ */
+module.exports = function transformData(data, headers, fns) {
+ /*eslint no-param-reassign:0*/
+ utils.forEach(fns, function transform(fn) {
+ data = fn(data, headers);
+ });
+
+ return data;
+};
+
+
+/***/ }),
+
+/***/ 8190:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+var utils = __webpack_require__(328);
+var normalizeHeaderName = __webpack_require__(6240);
+
+var DEFAULT_CONTENT_TYPE = {
+ 'Content-Type': 'application/x-www-form-urlencoded'
+};
+
+function setContentTypeIfUnset(headers, value) {
+ if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {
+ headers['Content-Type'] = value;
+ }
+}
+
+function getDefaultAdapter() {
+ var adapter;
+ if (typeof XMLHttpRequest !== 'undefined') {
+ // For browsers use XHR adapter
+ adapter = __webpack_require__(3454);
+ } else if (typeof process !== 'undefined' && Object.prototype.toString.call(process) === '[object process]') {
+ // For node use HTTP adapter
+ adapter = __webpack_require__(8104);
+ }
+ return adapter;
+}
+
+var defaults = {
+ adapter: getDefaultAdapter(),
+
+ transformRequest: [function transformRequest(data, headers) {
+ normalizeHeaderName(headers, 'Accept');
+ normalizeHeaderName(headers, 'Content-Type');
+ if (utils.isFormData(data) ||
+ utils.isArrayBuffer(data) ||
+ utils.isBuffer(data) ||
+ utils.isStream(data) ||
+ utils.isFile(data) ||
+ utils.isBlob(data)
+ ) {
+ return data;
+ }
+ if (utils.isArrayBufferView(data)) {
+ return data.buffer;
+ }
+ if (utils.isURLSearchParams(data)) {
+ setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');
+ return data.toString();
+ }
+ if (utils.isObject(data)) {
+ setContentTypeIfUnset(headers, 'application/json;charset=utf-8');
+ return JSON.stringify(data);
+ }
+ return data;
+ }],
+
+ transformResponse: [function transformResponse(data) {
+ /*eslint no-param-reassign:0*/
+ if (typeof data === 'string') {
+ try {
+ data = JSON.parse(data);
+ } catch (e) { /* Ignore */ }
+ }
+ return data;
+ }],
+
+ /**
+ * A timeout in milliseconds to abort a request. If set to 0 (default) a
+ * timeout is not created.
+ */
+ timeout: 0,
+
+ xsrfCookieName: 'XSRF-TOKEN',
+ xsrfHeaderName: 'X-XSRF-TOKEN',
+
+ maxContentLength: -1,
+ maxBodyLength: -1,
+
+ validateStatus: function validateStatus(status) {
+ return status >= 200 && status < 300;
+ }
+};
+
+defaults.headers = {
+ common: {
+ 'Accept': 'application/json, text/plain, */*'
+ }
+};
+
+utils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {
+ defaults.headers[method] = {};
+});
+
+utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
+ defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);
+});
+
+module.exports = defaults;
+
+
+/***/ }),
+
+/***/ 7065:
+/***/ ((module) => {
+
+"use strict";
+
+
+module.exports = function bind(fn, thisArg) {
+ return function wrap() {
+ var args = new Array(arguments.length);
+ for (var i = 0; i < args.length; i++) {
+ args[i] = arguments[i];
+ }
+ return fn.apply(thisArg, args);
+ };
+};
+
+
+/***/ }),
+
+/***/ 646:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+var utils = __webpack_require__(328);
+
+function encode(val) {
+ return encodeURIComponent(val).
+ replace(/%3A/gi, ':').
+ replace(/%24/g, '$').
+ replace(/%2C/gi, ',').
+ replace(/%20/g, '+').
+ replace(/%5B/gi, '[').
+ replace(/%5D/gi, ']');
+}
+
+/**
+ * Build a URL by appending params to the end
+ *
+ * @param {string} url The base of the url (e.g., http://www.google.com)
+ * @param {object} [params] The params to be appended
+ * @returns {string} The formatted url
+ */
+module.exports = function buildURL(url, params, paramsSerializer) {
+ /*eslint no-param-reassign:0*/
+ if (!params) {
+ return url;
+ }
+
+ var serializedParams;
+ if (paramsSerializer) {
+ serializedParams = paramsSerializer(params);
+ } else if (utils.isURLSearchParams(params)) {
+ serializedParams = params.toString();
+ } else {
+ var parts = [];
+
+ utils.forEach(params, function serialize(val, key) {
+ if (val === null || typeof val === 'undefined') {
+ return;
+ }
+
+ if (utils.isArray(val)) {
+ key = key + '[]';
+ } else {
+ val = [val];
+ }
+
+ utils.forEach(val, function parseValue(v) {
+ if (utils.isDate(v)) {
+ v = v.toISOString();
+ } else if (utils.isObject(v)) {
+ v = JSON.stringify(v);
+ }
+ parts.push(encode(key) + '=' + encode(v));
+ });
+ });
+
+ serializedParams = parts.join('&');
+ }
+
+ if (serializedParams) {
+ var hashmarkIndex = url.indexOf('#');
+ if (hashmarkIndex !== -1) {
+ url = url.slice(0, hashmarkIndex);
+ }
+
+ url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;
+ }
+
+ return url;
+};
+
+
+/***/ }),
+
+/***/ 7189:
+/***/ ((module) => {
+
+"use strict";
+
+
+/**
+ * Creates a new URL by combining the specified URLs
+ *
+ * @param {string} baseURL The base URL
+ * @param {string} relativeURL The relative URL
+ * @returns {string} The combined URL
+ */
+module.exports = function combineURLs(baseURL, relativeURL) {
+ return relativeURL
+ ? baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '')
+ : baseURL;
+};
+
+
+/***/ }),
+
+/***/ 1545:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+var utils = __webpack_require__(328);
+
+module.exports = (
+ utils.isStandardBrowserEnv() ?
+
+ // Standard browser envs support document.cookie
+ (function standardBrowserEnv() {
+ return {
+ write: function write(name, value, expires, path, domain, secure) {
+ var cookie = [];
+ cookie.push(name + '=' + encodeURIComponent(value));
+
+ if (utils.isNumber(expires)) {
+ cookie.push('expires=' + new Date(expires).toGMTString());
+ }
+
+ if (utils.isString(path)) {
+ cookie.push('path=' + path);
+ }
+
+ if (utils.isString(domain)) {
+ cookie.push('domain=' + domain);
+ }
+
+ if (secure === true) {
+ cookie.push('secure');
+ }
+
+ document.cookie = cookie.join('; ');
+ },
+
+ read: function read(name) {
+ var match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));
+ return (match ? decodeURIComponent(match[3]) : null);
+ },
+
+ remove: function remove(name) {
+ this.write(name, '', Date.now() - 86400000);
+ }
+ };
+ })() :
+
+ // Non standard browser env (web workers, react-native) lack needed support.
+ (function nonStandardBrowserEnv() {
+ return {
+ write: function write() {},
+ read: function read() { return null; },
+ remove: function remove() {}
+ };
+ })()
+);
+
+
+/***/ }),
+
+/***/ 1301:
+/***/ ((module) => {
+
+"use strict";
+
+
+/**
+ * Determines whether the specified URL is absolute
+ *
+ * @param {string} url The URL to test
+ * @returns {boolean} True if the specified URL is absolute, otherwise false
+ */
+module.exports = function isAbsoluteURL(url) {
+ // A URL is considered absolute if it begins with "://" or "//" (protocol-relative URL).
+ // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed
+ // by any combination of letters, digits, plus, period, or hyphen.
+ return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
+};
+
+
+/***/ }),
+
+/***/ 3608:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+var utils = __webpack_require__(328);
+
+module.exports = (
+ utils.isStandardBrowserEnv() ?
+
+ // Standard browser envs have full support of the APIs needed to test
+ // whether the request URL is of the same origin as current location.
+ (function standardBrowserEnv() {
+ var msie = /(msie|trident)/i.test(navigator.userAgent);
+ var urlParsingNode = document.createElement('a');
+ var originURL;
+
+ /**
+ * Parse a URL to discover it's components
+ *
+ * @param {String} url The URL to be parsed
+ * @returns {Object}
+ */
+ function resolveURL(url) {
+ var href = url;
+
+ if (msie) {
+ // IE needs attribute set twice to normalize properties
+ urlParsingNode.setAttribute('href', href);
+ href = urlParsingNode.href;
+ }
+
+ urlParsingNode.setAttribute('href', href);
+
+ // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils
+ return {
+ href: urlParsingNode.href,
+ protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',
+ host: urlParsingNode.host,
+ search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '',
+ hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',
+ hostname: urlParsingNode.hostname,
+ port: urlParsingNode.port,
+ pathname: (urlParsingNode.pathname.charAt(0) === '/') ?
+ urlParsingNode.pathname :
+ '/' + urlParsingNode.pathname
+ };
+ }
+
+ originURL = resolveURL(window.location.href);
+
+ /**
+ * Determine if a URL shares the same origin as the current location
+ *
+ * @param {String} requestURL The URL to test
+ * @returns {boolean} True if URL shares the same origin, otherwise false
+ */
+ return function isURLSameOrigin(requestURL) {
+ var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;
+ return (parsed.protocol === originURL.protocol &&
+ parsed.host === originURL.host);
+ };
+ })() :
+
+ // Non standard browser envs (web workers, react-native) lack needed support.
+ (function nonStandardBrowserEnv() {
+ return function isURLSameOrigin() {
+ return true;
+ };
+ })()
+);
+
+
+/***/ }),
+
+/***/ 6240:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+var utils = __webpack_require__(328);
+
+module.exports = function normalizeHeaderName(headers, normalizedName) {
+ utils.forEach(headers, function processHeader(value, name) {
+ if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {
+ headers[normalizedName] = value;
+ delete headers[name];
+ }
+ });
+};
+
+
+/***/ }),
+
+/***/ 6455:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+var utils = __webpack_require__(328);
+
+// Headers whose duplicates are ignored by node
+// c.f. https://nodejs.org/api/http.html#http_message_headers
+var ignoreDuplicateOf = [
+ 'age', 'authorization', 'content-length', 'content-type', 'etag',
+ 'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since',
+ 'last-modified', 'location', 'max-forwards', 'proxy-authorization',
+ 'referer', 'retry-after', 'user-agent'
+];
+
+/**
+ * Parse headers into an object
+ *
+ * ```
+ * Date: Wed, 27 Aug 2014 08:58:49 GMT
+ * Content-Type: application/json
+ * Connection: keep-alive
+ * Transfer-Encoding: chunked
+ * ```
+ *
+ * @param {String} headers Headers needing to be parsed
+ * @returns {Object} Headers parsed into an object
+ */
+module.exports = function parseHeaders(headers) {
+ var parsed = {};
+ var key;
+ var val;
+ var i;
+
+ if (!headers) { return parsed; }
+
+ utils.forEach(headers.split('\n'), function parser(line) {
+ i = line.indexOf(':');
+ key = utils.trim(line.substr(0, i)).toLowerCase();
+ val = utils.trim(line.substr(i + 1));
+
+ if (key) {
+ if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) {
+ return;
+ }
+ if (key === 'set-cookie') {
+ parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]);
+ } else {
+ parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
+ }
+ }
+ });
+
+ return parsed;
+};
+
+
+/***/ }),
+
+/***/ 4850:
+/***/ ((module) => {
+
+"use strict";
+
+
+/**
+ * Syntactic sugar for invoking a function and expanding an array for arguments.
+ *
+ * Common use case would be to use `Function.prototype.apply`.
+ *
+ * ```js
+ * function f(x, y, z) {}
+ * var args = [1, 2, 3];
+ * f.apply(null, args);
+ * ```
+ *
+ * With `spread` this example can be re-written.
+ *
+ * ```js
+ * spread(function(x, y, z) {})([1, 2, 3]);
+ * ```
+ *
+ * @param {Function} callback
+ * @returns {Function}
+ */
+module.exports = function spread(callback) {
+ return function wrap(arr) {
+ return callback.apply(null, arr);
+ };
+};
+
+
+/***/ }),
+
+/***/ 328:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+var bind = __webpack_require__(7065);
+
+/*global toString:true*/
+
+// utils is a library of generic helper functions non-specific to axios
+
+var toString = Object.prototype.toString;
+
+/**
+ * Determine if a value is an Array
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is an Array, otherwise false
+ */
+function isArray(val) {
+ return toString.call(val) === '[object Array]';
+}
+
+/**
+ * Determine if a value is undefined
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if the value is undefined, otherwise false
+ */
+function isUndefined(val) {
+ return typeof val === 'undefined';
+}
+
+/**
+ * Determine if a value is a Buffer
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is a Buffer, otherwise false
+ */
+function isBuffer(val) {
+ return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)
+ && typeof val.constructor.isBuffer === 'function' && val.constructor.isBuffer(val);
+}
+
+/**
+ * Determine if a value is an ArrayBuffer
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is an ArrayBuffer, otherwise false
+ */
+function isArrayBuffer(val) {
+ return toString.call(val) === '[object ArrayBuffer]';
+}
+
+/**
+ * Determine if a value is a FormData
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is an FormData, otherwise false
+ */
+function isFormData(val) {
+ return (typeof FormData !== 'undefined') && (val instanceof FormData);
+}
+
+/**
+ * Determine if a value is a view on an ArrayBuffer
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false
+ */
+function isArrayBufferView(val) {
+ var result;
+ if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {
+ result = ArrayBuffer.isView(val);
+ } else {
+ result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer);
+ }
+ return result;
+}
+
+/**
+ * Determine if a value is a String
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is a String, otherwise false
+ */
+function isString(val) {
+ return typeof val === 'string';
+}
+
+/**
+ * Determine if a value is a Number
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is a Number, otherwise false
+ */
+function isNumber(val) {
+ return typeof val === 'number';
+}
+
+/**
+ * Determine if a value is an Object
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is an Object, otherwise false
+ */
+function isObject(val) {
+ return val !== null && typeof val === 'object';
+}
+
+/**
+ * Determine if a value is a plain Object
+ *
+ * @param {Object} val The value to test
+ * @return {boolean} True if value is a plain Object, otherwise false
+ */
+function isPlainObject(val) {
+ if (toString.call(val) !== '[object Object]') {
+ return false;
+ }
+
+ var prototype = Object.getPrototypeOf(val);
+ return prototype === null || prototype === Object.prototype;
+}
+
+/**
+ * Determine if a value is a Date
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is a Date, otherwise false
+ */
+function isDate(val) {
+ return toString.call(val) === '[object Date]';
+}
+
+/**
+ * Determine if a value is a File
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is a File, otherwise false
+ */
+function isFile(val) {
+ return toString.call(val) === '[object File]';
+}
+
+/**
+ * Determine if a value is a Blob
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is a Blob, otherwise false
+ */
+function isBlob(val) {
+ return toString.call(val) === '[object Blob]';
+}
+
+/**
+ * Determine if a value is a Function
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is a Function, otherwise false
+ */
+function isFunction(val) {
+ return toString.call(val) === '[object Function]';
+}
+
+/**
+ * Determine if a value is a Stream
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is a Stream, otherwise false
+ */
+function isStream(val) {
+ return isObject(val) && isFunction(val.pipe);
+}
+
+/**
+ * Determine if a value is a URLSearchParams object
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is a URLSearchParams object, otherwise false
+ */
+function isURLSearchParams(val) {
+ return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams;
+}
+
+/**
+ * Trim excess whitespace off the beginning and end of a string
+ *
+ * @param {String} str The String to trim
+ * @returns {String} The String freed of excess whitespace
+ */
+function trim(str) {
+ return str.replace(/^\s*/, '').replace(/\s*$/, '');
+}
+
+/**
+ * Determine if we're running in a standard browser environment
+ *
+ * This allows axios to run in a web worker, and react-native.
+ * Both environments support XMLHttpRequest, but not fully standard globals.
+ *
+ * web workers:
+ * typeof window -> undefined
+ * typeof document -> undefined
+ *
+ * react-native:
+ * navigator.product -> 'ReactNative'
+ * nativescript
+ * navigator.product -> 'NativeScript' or 'NS'
+ */
+function isStandardBrowserEnv() {
+ if (typeof navigator !== 'undefined' && (navigator.product === 'ReactNative' ||
+ navigator.product === 'NativeScript' ||
+ navigator.product === 'NS')) {
+ return false;
+ }
+ return (
+ typeof window !== 'undefined' &&
+ typeof document !== 'undefined'
+ );
+}
+
+/**
+ * Iterate over an Array or an Object invoking a function for each item.
+ *
+ * If `obj` is an Array callback will be called passing
+ * the value, index, and complete array for each item.
+ *
+ * If 'obj' is an Object callback will be called passing
+ * the value, key, and complete object for each property.
+ *
+ * @param {Object|Array} obj The object to iterate
+ * @param {Function} fn The callback to invoke for each item
+ */
+function forEach(obj, fn) {
+ // Don't bother if no value provided
+ if (obj === null || typeof obj === 'undefined') {
+ return;
+ }
+
+ // Force an array if not already something iterable
+ if (typeof obj !== 'object') {
+ /*eslint no-param-reassign:0*/
+ obj = [obj];
+ }
+
+ if (isArray(obj)) {
+ // Iterate over array values
+ for (var i = 0, l = obj.length; i < l; i++) {
+ fn.call(null, obj[i], i, obj);
+ }
+ } else {
+ // Iterate over object keys
+ for (var key in obj) {
+ if (Object.prototype.hasOwnProperty.call(obj, key)) {
+ fn.call(null, obj[key], key, obj);
+ }
+ }
+ }
+}
+
+/**
+ * Accepts varargs expecting each argument to be an object, then
+ * immutably merges the properties of each object and returns result.
+ *
+ * When multiple objects contain the same key the later object in
+ * the arguments list will take precedence.
+ *
+ * Example:
+ *
+ * ```js
+ * var result = merge({foo: 123}, {foo: 456});
+ * console.log(result.foo); // outputs 456
+ * ```
+ *
+ * @param {Object} obj1 Object to merge
+ * @returns {Object} Result of all merge properties
+ */
+function merge(/* obj1, obj2, obj3, ... */) {
+ var result = {};
+ function assignValue(val, key) {
+ if (isPlainObject(result[key]) && isPlainObject(val)) {
+ result[key] = merge(result[key], val);
+ } else if (isPlainObject(val)) {
+ result[key] = merge({}, val);
+ } else if (isArray(val)) {
+ result[key] = val.slice();
+ } else {
+ result[key] = val;
+ }
+ }
+
+ for (var i = 0, l = arguments.length; i < l; i++) {
+ forEach(arguments[i], assignValue);
+ }
+ return result;
+}
+
+/**
+ * Extends object a by mutably adding to it the properties of object b.
+ *
+ * @param {Object} a The object to be extended
+ * @param {Object} b The object to copy properties from
+ * @param {Object} thisArg The object to bind function to
+ * @return {Object} The resulting value of object a
+ */
+function extend(a, b, thisArg) {
+ forEach(b, function assignValue(val, key) {
+ if (thisArg && typeof val === 'function') {
+ a[key] = bind(val, thisArg);
+ } else {
+ a[key] = val;
+ }
+ });
+ return a;
+}
+
+/**
+ * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
+ *
+ * @param {string} content with BOM
+ * @return {string} content value without BOM
+ */
+function stripBOM(content) {
+ if (content.charCodeAt(0) === 0xFEFF) {
+ content = content.slice(1);
+ }
+ return content;
+}
+
+module.exports = {
+ isArray: isArray,
+ isArrayBuffer: isArrayBuffer,
+ isBuffer: isBuffer,
+ isFormData: isFormData,
+ isArrayBufferView: isArrayBufferView,
+ isString: isString,
+ isNumber: isNumber,
+ isObject: isObject,
+ isPlainObject: isPlainObject,
+ isUndefined: isUndefined,
+ isDate: isDate,
+ isFile: isFile,
+ isBlob: isBlob,
+ isFunction: isFunction,
+ isStream: isStream,
+ isURLSearchParams: isURLSearchParams,
+ isStandardBrowserEnv: isStandardBrowserEnv,
+ forEach: forEach,
+ merge: merge,
+ extend: extend,
+ trim: trim,
+ stripBOM: stripBOM
+};
+
+
+/***/ }),
+
+/***/ 8222:
+/***/ ((module, exports, __webpack_require__) => {
+
+/* eslint-env browser */
+
+/**
+ * This is the web browser implementation of `debug()`.
+ */
+
+exports.formatArgs = formatArgs;
+exports.save = save;
+exports.load = load;
+exports.useColors = useColors;
+exports.storage = localstorage();
+exports.destroy = (() => {
+ let warned = false;
+
+ return () => {
+ if (!warned) {
+ warned = true;
+ console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+ }
+ };
+})();
+
+/**
+ * Colors.
+ */
+
+exports.colors = [
+ '#0000CC',
+ '#0000FF',
+ '#0033CC',
+ '#0033FF',
+ '#0066CC',
+ '#0066FF',
+ '#0099CC',
+ '#0099FF',
+ '#00CC00',
+ '#00CC33',
+ '#00CC66',
+ '#00CC99',
+ '#00CCCC',
+ '#00CCFF',
+ '#3300CC',
+ '#3300FF',
+ '#3333CC',
+ '#3333FF',
+ '#3366CC',
+ '#3366FF',
+ '#3399CC',
+ '#3399FF',
+ '#33CC00',
+ '#33CC33',
+ '#33CC66',
+ '#33CC99',
+ '#33CCCC',
+ '#33CCFF',
+ '#6600CC',
+ '#6600FF',
+ '#6633CC',
+ '#6633FF',
+ '#66CC00',
+ '#66CC33',
+ '#9900CC',
+ '#9900FF',
+ '#9933CC',
+ '#9933FF',
+ '#99CC00',
+ '#99CC33',
+ '#CC0000',
+ '#CC0033',
+ '#CC0066',
+ '#CC0099',
+ '#CC00CC',
+ '#CC00FF',
+ '#CC3300',
+ '#CC3333',
+ '#CC3366',
+ '#CC3399',
+ '#CC33CC',
+ '#CC33FF',
+ '#CC6600',
+ '#CC6633',
+ '#CC9900',
+ '#CC9933',
+ '#CCCC00',
+ '#CCCC33',
+ '#FF0000',
+ '#FF0033',
+ '#FF0066',
+ '#FF0099',
+ '#FF00CC',
+ '#FF00FF',
+ '#FF3300',
+ '#FF3333',
+ '#FF3366',
+ '#FF3399',
+ '#FF33CC',
+ '#FF33FF',
+ '#FF6600',
+ '#FF6633',
+ '#FF9900',
+ '#FF9933',
+ '#FFCC00',
+ '#FFCC33'
+];
+
+/**
+ * Currently only WebKit-based Web Inspectors, Firefox >= v31,
+ * and the Firebug extension (any Firefox version) are known
+ * to support "%c" CSS customizations.
+ *
+ * TODO: add a `localStorage` variable to explicitly enable/disable colors
+ */
+
+// eslint-disable-next-line complexity
+function useColors() {
+ // NB: In an Electron preload script, document will be defined but not fully
+ // initialized. Since we know we're in Chrome, we'll just detect this case
+ // explicitly
+ if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
+ return true;
+ }
+
+ // Internet Explorer and Edge do not support colors.
+ if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+ return false;
+ }
+
+ // Is webkit? http://stackoverflow.com/a/16459606/376773
+ // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
+ return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
+ // Is firebug? http://stackoverflow.com/a/398120/376773
+ (typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
+ // Is firefox >= v31?
+ // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+ (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
+ // Double check webkit in userAgent just in case we are in a worker
+ (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
+}
+
+/**
+ * Colorize log arguments if enabled.
+ *
+ * @api public
+ */
+
+function formatArgs(args) {
+ args[0] = (this.useColors ? '%c' : '') +
+ this.namespace +
+ (this.useColors ? ' %c' : ' ') +
+ args[0] +
+ (this.useColors ? '%c ' : ' ') +
+ '+' + module.exports.humanize(this.diff);
+
+ if (!this.useColors) {
+ return;
+ }
+
+ const c = 'color: ' + this.color;
+ args.splice(1, 0, c, 'color: inherit');
+
+ // The final "%c" is somewhat tricky, because there could be other
+ // arguments passed either before or after the %c, so we need to
+ // figure out the correct index to insert the CSS into
+ let index = 0;
+ let lastC = 0;
+ args[0].replace(/%[a-zA-Z%]/g, match => {
+ if (match === '%%') {
+ return;
+ }
+ index++;
+ if (match === '%c') {
+ // We only are interested in the *last* %c
+ // (the user may have provided their own)
+ lastC = index;
+ }
+ });
+
+ args.splice(lastC, 0, c);
+}
+
+/**
+ * Invokes `console.debug()` when available.
+ * No-op when `console.debug` is not a "function".
+ * If `console.debug` is not available, falls back
+ * to `console.log`.
+ *
+ * @api public
+ */
+exports.log = console.debug || console.log || (() => {});
+
+/**
+ * Save `namespaces`.
+ *
+ * @param {String} namespaces
+ * @api private
+ */
+function save(namespaces) {
+ try {
+ if (namespaces) {
+ exports.storage.setItem('debug', namespaces);
+ } else {
+ exports.storage.removeItem('debug');
+ }
+ } catch (error) {
+ // Swallow
+ // XXX (@Qix-) should we be logging these?
+ }
+}
+
+/**
+ * Load `namespaces`.
+ *
+ * @return {String} returns the previously persisted debug modes
+ * @api private
+ */
+function load() {
+ let r;
+ try {
+ r = exports.storage.getItem('debug');
+ } catch (error) {
+ // Swallow
+ // XXX (@Qix-) should we be logging these?
+ }
+
+ // If debug isn't set in LS, and we're in Electron, try to load $DEBUG
+ if (!r && typeof process !== 'undefined' && 'env' in process) {
+ r = process.env.DEBUG;
+ }
+
+ return r;
+}
+
+/**
+ * Localstorage attempts to return the localstorage.
+ *
+ * This is necessary because safari throws
+ * when a user disables cookies/localstorage
+ * and you attempt to access it.
+ *
+ * @return {LocalStorage}
+ * @api private
+ */
+
+function localstorage() {
+ try {
+ // TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
+ // The Browser also has localStorage in the global context.
+ return localStorage;
+ } catch (error) {
+ // Swallow
+ // XXX (@Qix-) should we be logging these?
+ }
+}
+
+module.exports = __webpack_require__(6243)(exports);
+
+const {formatters} = module.exports;
+
+/**
+ * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+ */
+
+formatters.j = function (v) {
+ try {
+ return JSON.stringify(v);
+ } catch (error) {
+ return '[UnexpectedJSONParseError]: ' + error.message;
+ }
+};
+
+
+/***/ }),
+
+/***/ 6243:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+
+/**
+ * This is the common logic for both the Node.js and web browser
+ * implementations of `debug()`.
+ */
+
+function setup(env) {
+ createDebug.debug = createDebug;
+ createDebug.default = createDebug;
+ createDebug.coerce = coerce;
+ createDebug.disable = disable;
+ createDebug.enable = enable;
+ createDebug.enabled = enabled;
+ createDebug.humanize = __webpack_require__(900);
+ createDebug.destroy = destroy;
+
+ Object.keys(env).forEach(key => {
+ createDebug[key] = env[key];
+ });
+
+ /**
+ * The currently active debug mode names, and names to skip.
+ */
+
+ createDebug.names = [];
+ createDebug.skips = [];
+
+ /**
+ * Map of special "%n" handling functions, for the debug "format" argument.
+ *
+ * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
+ */
+ createDebug.formatters = {};
+
+ /**
+ * Selects a color for a debug namespace
+ * @param {String} namespace The namespace string for the for the debug instance to be colored
+ * @return {Number|String} An ANSI color code for the given namespace
+ * @api private
+ */
+ function selectColor(namespace) {
+ let hash = 0;
+
+ for (let i = 0; i < namespace.length; i++) {
+ hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
+ hash |= 0; // Convert to 32bit integer
+ }
+
+ return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+ }
+ createDebug.selectColor = selectColor;
+
+ /**
+ * Create a debugger with the given `namespace`.
+ *
+ * @param {String} namespace
+ * @return {Function}
+ * @api public
+ */
+ function createDebug(namespace) {
+ let prevTime;
+ let enableOverride = null;
+
+ function debug(...args) {
+ // Disabled?
+ if (!debug.enabled) {
+ return;
+ }
+
+ const self = debug;
+
+ // Set `diff` timestamp
+ const curr = Number(new Date());
+ const ms = curr - (prevTime || curr);
+ self.diff = ms;
+ self.prev = prevTime;
+ self.curr = curr;
+ prevTime = curr;
+
+ args[0] = createDebug.coerce(args[0]);
+
+ if (typeof args[0] !== 'string') {
+ // Anything else let's inspect with %O
+ args.unshift('%O');
+ }
+
+ // Apply any `formatters` transformations
+ let index = 0;
+ args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+ // If we encounter an escaped % then don't increase the array index
+ if (match === '%%') {
+ return '%';
+ }
+ index++;
+ const formatter = createDebug.formatters[format];
+ if (typeof formatter === 'function') {
+ const val = args[index];
+ match = formatter.call(self, val);
+
+ // Now we need to remove `args[index]` since it's inlined in the `format`
+ args.splice(index, 1);
+ index--;
+ }
+ return match;
+ });
+
+ // Apply env-specific formatting (colors, etc.)
+ createDebug.formatArgs.call(self, args);
+
+ const logFn = self.log || createDebug.log;
+ logFn.apply(self, args);
+ }
+
+ debug.namespace = namespace;
+ debug.useColors = createDebug.useColors();
+ debug.color = createDebug.selectColor(namespace);
+ debug.extend = extend;
+ debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.
+
+ Object.defineProperty(debug, 'enabled', {
+ enumerable: true,
+ configurable: false,
+ get: () => enableOverride === null ? createDebug.enabled(namespace) : enableOverride,
+ set: v => {
+ enableOverride = v;
+ }
+ });
+
+ // Env-specific initialization logic for debug instances
+ if (typeof createDebug.init === 'function') {
+ createDebug.init(debug);
+ }
+
+ return debug;
+ }
+
+ function extend(namespace, delimiter) {
+ const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
+ newDebug.log = this.log;
+ return newDebug;
+ }
+
+ /**
+ * Enables a debug mode by namespaces. This can include modes
+ * separated by a colon and wildcards.
+ *
+ * @param {String} namespaces
+ * @api public
+ */
+ function enable(namespaces) {
+ createDebug.save(namespaces);
+
+ createDebug.names = [];
+ createDebug.skips = [];
+
+ let i;
+ const split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
+ const len = split.length;
+
+ for (i = 0; i < len; i++) {
+ if (!split[i]) {
+ // ignore empty strings
+ continue;
+ }
+
+ namespaces = split[i].replace(/\*/g, '.*?');
+
+ if (namespaces[0] === '-') {
+ createDebug.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
+ } else {
+ createDebug.names.push(new RegExp('^' + namespaces + '$'));
+ }
+ }
+ }
+
+ /**
+ * Disable debug output.
+ *
+ * @return {String} namespaces
+ * @api public
+ */
+ function disable() {
+ const namespaces = [
+ ...createDebug.names.map(toNamespace),
+ ...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)
+ ].join(',');
+ createDebug.enable('');
+ return namespaces;
+ }
+
+ /**
+ * Returns true if the given mode name is enabled, false otherwise.
+ *
+ * @param {String} name
+ * @return {Boolean}
+ * @api public
+ */
+ function enabled(name) {
+ if (name[name.length - 1] === '*') {
+ return true;
+ }
+
+ let i;
+ let len;
+
+ for (i = 0, len = createDebug.skips.length; i < len; i++) {
+ if (createDebug.skips[i].test(name)) {
+ return false;
+ }
+ }
+
+ for (i = 0, len = createDebug.names.length; i < len; i++) {
+ if (createDebug.names[i].test(name)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * Convert regexp to namespace
+ *
+ * @param {RegExp} regxep
+ * @return {String} namespace
+ * @api private
+ */
+ function toNamespace(regexp) {
+ return regexp.toString()
+ .substring(2, regexp.toString().length - 2)
+ .replace(/\.\*\?$/, '*');
+ }
+
+ /**
+ * Coerce `val`.
+ *
+ * @param {Mixed} val
+ * @return {Mixed}
+ * @api private
+ */
+ function coerce(val) {
+ if (val instanceof Error) {
+ return val.stack || val.message;
+ }
+ return val;
+ }
+
+ /**
+ * XXX DO NOT USE. This is a temporary stub function.
+ * XXX It WILL be removed in the next major release.
+ */
+ function destroy() {
+ console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+ }
+
+ createDebug.enable(createDebug.load());
+
+ return createDebug;
+}
+
+module.exports = setup;
+
+
+/***/ }),
+
+/***/ 8237:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+/**
+ * Detect Electron renderer / nwjs process, which is node, but we should
+ * treat as a browser.
+ */
+
+if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {
+ module.exports = __webpack_require__(8222);
+} else {
+ module.exports = __webpack_require__(5332);
+}
+
+
+/***/ }),
+
+/***/ 5332:
+/***/ ((module, exports, __webpack_require__) => {
+
+/**
+ * Module dependencies.
+ */
+
+const tty = __webpack_require__(3867);
+const util = __webpack_require__(1669);
+
+/**
+ * This is the Node.js implementation of `debug()`.
+ */
+
+exports.init = init;
+exports.log = log;
+exports.formatArgs = formatArgs;
+exports.save = save;
+exports.load = load;
+exports.useColors = useColors;
+exports.destroy = util.deprecate(
+ () => {},
+ 'Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.'
+);
+
+/**
+ * Colors.
+ */
+
+exports.colors = [6, 2, 3, 4, 5, 1];
+
+try {
+ // Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)
+ // eslint-disable-next-line import/no-extraneous-dependencies
+ const supportsColor = __webpack_require__(9318);
+
+ if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
+ exports.colors = [
+ 20,
+ 21,
+ 26,
+ 27,
+ 32,
+ 33,
+ 38,
+ 39,
+ 40,
+ 41,
+ 42,
+ 43,
+ 44,
+ 45,
+ 56,
+ 57,
+ 62,
+ 63,
+ 68,
+ 69,
+ 74,
+ 75,
+ 76,
+ 77,
+ 78,
+ 79,
+ 80,
+ 81,
+ 92,
+ 93,
+ 98,
+ 99,
+ 112,
+ 113,
+ 128,
+ 129,
+ 134,
+ 135,
+ 148,
+ 149,
+ 160,
+ 161,
+ 162,
+ 163,
+ 164,
+ 165,
+ 166,
+ 167,
+ 168,
+ 169,
+ 170,
+ 171,
+ 172,
+ 173,
+ 178,
+ 179,
+ 184,
+ 185,
+ 196,
+ 197,
+ 198,
+ 199,
+ 200,
+ 201,
+ 202,
+ 203,
+ 204,
+ 205,
+ 206,
+ 207,
+ 208,
+ 209,
+ 214,
+ 215,
+ 220,
+ 221
+ ];
+ }
+} catch (error) {
+ // Swallow - we only care if `supports-color` is available; it doesn't have to be.
+}
+
+/**
+ * Build up the default `inspectOpts` object from the environment variables.
+ *
+ * $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
+ */
+
+exports.inspectOpts = Object.keys(process.env).filter(key => {
+ return /^debug_/i.test(key);
+}).reduce((obj, key) => {
+ // Camel-case
+ const prop = key
+ .substring(6)
+ .toLowerCase()
+ .replace(/_([a-z])/g, (_, k) => {
+ return k.toUpperCase();
+ });
+
+ // Coerce string value into JS value
+ let val = process.env[key];
+ if (/^(yes|on|true|enabled)$/i.test(val)) {
+ val = true;
+ } else if (/^(no|off|false|disabled)$/i.test(val)) {
+ val = false;
+ } else if (val === 'null') {
+ val = null;
+ } else {
+ val = Number(val);
+ }
+
+ obj[prop] = val;
+ return obj;
+}, {});
+
+/**
+ * Is stdout a TTY? Colored output is enabled when `true`.
+ */
+
+function useColors() {
+ return 'colors' in exports.inspectOpts ?
+ Boolean(exports.inspectOpts.colors) :
+ tty.isatty(process.stderr.fd);
+}
+
+/**
+ * Adds ANSI color escape codes if enabled.
+ *
+ * @api public
+ */
+
+function formatArgs(args) {
+ const {namespace: name, useColors} = this;
+
+ if (useColors) {
+ const c = this.color;
+ const colorCode = '\u001B[3' + (c < 8 ? c : '8;5;' + c);
+ const prefix = ` ${colorCode};1m${name} \u001B[0m`;
+
+ args[0] = prefix + args[0].split('\n').join('\n' + prefix);
+ args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + '\u001B[0m');
+ } else {
+ args[0] = getDate() + name + ' ' + args[0];
+ }
+}
+
+function getDate() {
+ if (exports.inspectOpts.hideDate) {
+ return '';
+ }
+ return new Date().toISOString() + ' ';
+}
+
+/**
+ * Invokes `util.format()` with the specified arguments and writes to stderr.
+ */
+
+function log(...args) {
+ return process.stderr.write(util.format(...args) + '\n');
+}
+
+/**
+ * Save `namespaces`.
+ *
+ * @param {String} namespaces
+ * @api private
+ */
+function save(namespaces) {
+ if (namespaces) {
+ process.env.DEBUG = namespaces;
+ } else {
+ // If you set a process.env field to null or undefined, it gets cast to the
+ // string 'null' or 'undefined'. Just delete instead.
+ delete process.env.DEBUG;
+ }
+}
+
+/**
+ * Load `namespaces`.
+ *
+ * @return {String} returns the previously persisted debug modes
+ * @api private
+ */
+
+function load() {
+ return process.env.DEBUG;
+}
+
+/**
+ * Init logic for `debug` instances.
+ *
+ * Create a new `inspectOpts` object in case `useColors` is set
+ * differently for a particular `debug` instance.
+ */
+
+function init(debug) {
+ debug.inspectOpts = {};
+
+ const keys = Object.keys(exports.inspectOpts);
+ for (let i = 0; i < keys.length; i++) {
+ debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+ }
+}
+
+module.exports = __webpack_require__(6243)(exports);
+
+const {formatters} = module.exports;
+
+/**
+ * Map %o to `util.inspect()`, all on a single line.
+ */
+
+formatters.o = function (v) {
+ this.inspectOpts.colors = this.useColors;
+ return util.inspect(v, this.inspectOpts)
+ .split('\n')
+ .map(str => str.trim())
+ .join(' ');
+};
+
+/**
+ * Map %O to `util.inspect()`, allowing multiple lines if needed.
+ */
+
+formatters.O = function (v) {
+ this.inspectOpts.colors = this.useColors;
+ return util.inspect(v, this.inspectOpts);
+};
+
+
+/***/ }),
+
+/***/ 1133:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var debug;
+try {
+ /* eslint global-require: off */
+ debug = __webpack_require__(8237)("follow-redirects");
+}
+catch (error) {
+ debug = function () { /* */ };
+}
+module.exports = debug;
+
+
+/***/ }),
+
+/***/ 7707:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var url = __webpack_require__(8835);
+var URL = url.URL;
+var http = __webpack_require__(8605);
+var https = __webpack_require__(7211);
+var Writable = __webpack_require__(2413).Writable;
+var assert = __webpack_require__(2357);
+var debug = __webpack_require__(1133);
+
+// Create handlers that pass events from native requests
+var eventHandlers = Object.create(null);
+["abort", "aborted", "connect", "error", "socket", "timeout"].forEach(function (event) {
+ eventHandlers[event] = function (arg1, arg2, arg3) {
+ this._redirectable.emit(event, arg1, arg2, arg3);
+ };
+});
+
+// Error types with codes
+var RedirectionError = createErrorType(
+ "ERR_FR_REDIRECTION_FAILURE",
+ ""
+);
+var TooManyRedirectsError = createErrorType(
+ "ERR_FR_TOO_MANY_REDIRECTS",
+ "Maximum number of redirects exceeded"
+);
+var MaxBodyLengthExceededError = createErrorType(
+ "ERR_FR_MAX_BODY_LENGTH_EXCEEDED",
+ "Request body larger than maxBodyLength limit"
+);
+var WriteAfterEndError = createErrorType(
+ "ERR_STREAM_WRITE_AFTER_END",
+ "write after end"
+);
+
+// An HTTP(S) request that can be redirected
+function RedirectableRequest(options, responseCallback) {
+ // Initialize the request
+ Writable.call(this);
+ this._sanitizeOptions(options);
+ this._options = options;
+ this._ended = false;
+ this._ending = false;
+ this._redirectCount = 0;
+ this._redirects = [];
+ this._requestBodyLength = 0;
+ this._requestBodyBuffers = [];
+
+ // Attach a callback if passed
+ if (responseCallback) {
+ this.on("response", responseCallback);
+ }
+
+ // React to responses of native requests
+ var self = this;
+ this._onNativeResponse = function (response) {
+ self._processResponse(response);
+ };
+
+ // Perform the first request
+ this._performRequest();
+}
+RedirectableRequest.prototype = Object.create(Writable.prototype);
+
+// Writes buffered data to the current native request
+RedirectableRequest.prototype.write = function (data, encoding, callback) {
+ // Writing is not allowed if end has been called
+ if (this._ending) {
+ throw new WriteAfterEndError();
+ }
+
+ // Validate input and shift parameters if necessary
+ if (!(typeof data === "string" || typeof data === "object" && ("length" in data))) {
+ throw new TypeError("data should be a string, Buffer or Uint8Array");
+ }
+ if (typeof encoding === "function") {
+ callback = encoding;
+ encoding = null;
+ }
+
+ // Ignore empty buffers, since writing them doesn't invoke the callback
+ // https://github.com/nodejs/node/issues/22066
+ if (data.length === 0) {
+ if (callback) {
+ callback();
+ }
+ return;
+ }
+ // Only write when we don't exceed the maximum body length
+ if (this._requestBodyLength + data.length <= this._options.maxBodyLength) {
+ this._requestBodyLength += data.length;
+ this._requestBodyBuffers.push({ data: data, encoding: encoding });
+ this._currentRequest.write(data, encoding, callback);
+ }
+ // Error when we exceed the maximum body length
+ else {
+ this.emit("error", new MaxBodyLengthExceededError());
+ this.abort();
+ }
+};
+
+// Ends the current native request
+RedirectableRequest.prototype.end = function (data, encoding, callback) {
+ // Shift parameters if necessary
+ if (typeof data === "function") {
+ callback = data;
+ data = encoding = null;
+ }
+ else if (typeof encoding === "function") {
+ callback = encoding;
+ encoding = null;
+ }
+
+ // Write data if needed and end
+ if (!data) {
+ this._ended = this._ending = true;
+ this._currentRequest.end(null, null, callback);
+ }
+ else {
+ var self = this;
+ var currentRequest = this._currentRequest;
+ this.write(data, encoding, function () {
+ self._ended = true;
+ currentRequest.end(null, null, callback);
+ });
+ this._ending = true;
+ }
+};
+
+// Sets a header value on the current native request
+RedirectableRequest.prototype.setHeader = function (name, value) {
+ this._options.headers[name] = value;
+ this._currentRequest.setHeader(name, value);
+};
+
+// Clears a header value on the current native request
+RedirectableRequest.prototype.removeHeader = function (name) {
+ delete this._options.headers[name];
+ this._currentRequest.removeHeader(name);
+};
+
+// Global timeout for all underlying requests
+RedirectableRequest.prototype.setTimeout = function (msecs, callback) {
+ if (callback) {
+ this.once("timeout", callback);
+ }
+
+ if (this.socket) {
+ startTimer(this, msecs);
+ }
+ else {
+ var self = this;
+ this._currentRequest.once("socket", function () {
+ startTimer(self, msecs);
+ });
+ }
+
+ this.once("response", clearTimer);
+ this.once("error", clearTimer);
+
+ return this;
+};
+
+function startTimer(request, msecs) {
+ clearTimeout(request._timeout);
+ request._timeout = setTimeout(function () {
+ request.emit("timeout");
+ }, msecs);
+}
+
+function clearTimer() {
+ clearTimeout(this._timeout);
+}
+
+// Proxy all other public ClientRequest methods
+[
+ "abort", "flushHeaders", "getHeader",
+ "setNoDelay", "setSocketKeepAlive",
+].forEach(function (method) {
+ RedirectableRequest.prototype[method] = function (a, b) {
+ return this._currentRequest[method](a, b);
+ };
+});
+
+// Proxy all public ClientRequest properties
+["aborted", "connection", "socket"].forEach(function (property) {
+ Object.defineProperty(RedirectableRequest.prototype, property, {
+ get: function () { return this._currentRequest[property]; },
+ });
+});
+
+RedirectableRequest.prototype._sanitizeOptions = function (options) {
+ // Ensure headers are always present
+ if (!options.headers) {
+ options.headers = {};
+ }
+
+ // Since http.request treats host as an alias of hostname,
+ // but the url module interprets host as hostname plus port,
+ // eliminate the host property to avoid confusion.
+ if (options.host) {
+ // Use hostname if set, because it has precedence
+ if (!options.hostname) {
+ options.hostname = options.host;
+ }
+ delete options.host;
+ }
+
+ // Complete the URL object when necessary
+ if (!options.pathname && options.path) {
+ var searchPos = options.path.indexOf("?");
+ if (searchPos < 0) {
+ options.pathname = options.path;
+ }
+ else {
+ options.pathname = options.path.substring(0, searchPos);
+ options.search = options.path.substring(searchPos);
+ }
+ }
+};
+
+
+// Executes the next native request (initial or redirect)
+RedirectableRequest.prototype._performRequest = function () {
+ // Load the native protocol
+ var protocol = this._options.protocol;
+ var nativeProtocol = this._options.nativeProtocols[protocol];
+ if (!nativeProtocol) {
+ this.emit("error", new TypeError("Unsupported protocol " + protocol));
+ return;
+ }
+
+ // If specified, use the agent corresponding to the protocol
+ // (HTTP and HTTPS use different types of agents)
+ if (this._options.agents) {
+ var scheme = protocol.substr(0, protocol.length - 1);
+ this._options.agent = this._options.agents[scheme];
+ }
+
+ // Create the native request
+ var request = this._currentRequest =
+ nativeProtocol.request(this._options, this._onNativeResponse);
+ this._currentUrl = url.format(this._options);
+
+ // Set up event handlers
+ request._redirectable = this;
+ for (var event in eventHandlers) {
+ /* istanbul ignore else */
+ if (event) {
+ request.on(event, eventHandlers[event]);
+ }
+ }
+
+ // End a redirected request
+ // (The first request must be ended explicitly with RedirectableRequest#end)
+ if (this._isRedirect) {
+ // Write the request entity and end.
+ var i = 0;
+ var self = this;
+ var buffers = this._requestBodyBuffers;
+ (function writeNext(error) {
+ // Only write if this request has not been redirected yet
+ /* istanbul ignore else */
+ if (request === self._currentRequest) {
+ // Report any write errors
+ /* istanbul ignore if */
+ if (error) {
+ self.emit("error", error);
+ }
+ // Write the next buffer if there are still left
+ else if (i < buffers.length) {
+ var buffer = buffers[i++];
+ /* istanbul ignore else */
+ if (!request.finished) {
+ request.write(buffer.data, buffer.encoding, writeNext);
+ }
+ }
+ // End the request if `end` has been called on us
+ else if (self._ended) {
+ request.end();
+ }
+ }
+ }());
+ }
+};
+
+// Processes a response from the current native request
+RedirectableRequest.prototype._processResponse = function (response) {
+ // Store the redirected response
+ var statusCode = response.statusCode;
+ if (this._options.trackRedirects) {
+ this._redirects.push({
+ url: this._currentUrl,
+ headers: response.headers,
+ statusCode: statusCode,
+ });
+ }
+
+ // RFC7231§6.4: The 3xx (Redirection) class of status code indicates
+ // that further action needs to be taken by the user agent in order to
+ // fulfill the request. If a Location header field is provided,
+ // the user agent MAY automatically redirect its request to the URI
+ // referenced by the Location field value,
+ // even if the specific status code is not understood.
+ var location = response.headers.location;
+ if (location && this._options.followRedirects !== false &&
+ statusCode >= 300 && statusCode < 400) {
+ // Abort the current request
+ this._currentRequest.removeAllListeners();
+ this._currentRequest.on("error", noop);
+ this._currentRequest.abort();
+ // Discard the remainder of the response to avoid waiting for data
+ response.destroy();
+
+ // RFC7231§6.4: A client SHOULD detect and intervene
+ // in cyclical redirections (i.e., "infinite" redirection loops).
+ if (++this._redirectCount > this._options.maxRedirects) {
+ this.emit("error", new TooManyRedirectsError());
+ return;
+ }
+
+ // RFC7231§6.4: Automatic redirection needs to done with
+ // care for methods not known to be safe, […]
+ // RFC7231§6.4.2–3: For historical reasons, a user agent MAY change
+ // the request method from POST to GET for the subsequent request.
+ if ((statusCode === 301 || statusCode === 302) && this._options.method === "POST" ||
+ // RFC7231§6.4.4: The 303 (See Other) status code indicates that
+ // the server is redirecting the user agent to a different resource […]
+ // A user agent can perform a retrieval request targeting that URI
+ // (a GET or HEAD request if using HTTP) […]
+ (statusCode === 303) && !/^(?:GET|HEAD)$/.test(this._options.method)) {
+ this._options.method = "GET";
+ // Drop a possible entity and headers related to it
+ this._requestBodyBuffers = [];
+ removeMatchingHeaders(/^content-/i, this._options.headers);
+ }
+
+ // Drop the Host header, as the redirect might lead to a different host
+ var previousHostName = removeMatchingHeaders(/^host$/i, this._options.headers) ||
+ url.parse(this._currentUrl).hostname;
+
+ // Create the redirected request
+ var redirectUrl = url.resolve(this._currentUrl, location);
+ debug("redirecting to", redirectUrl);
+ this._isRedirect = true;
+ var redirectUrlParts = url.parse(redirectUrl);
+ Object.assign(this._options, redirectUrlParts);
+
+ // Drop the Authorization header if redirecting to another host
+ if (redirectUrlParts.hostname !== previousHostName) {
+ removeMatchingHeaders(/^authorization$/i, this._options.headers);
+ }
+
+ // Evaluate the beforeRedirect callback
+ if (typeof this._options.beforeRedirect === "function") {
+ var responseDetails = { headers: response.headers };
+ try {
+ this._options.beforeRedirect.call(null, this._options, responseDetails);
+ }
+ catch (err) {
+ this.emit("error", err);
+ return;
+ }
+ this._sanitizeOptions(this._options);
+ }
+
+ // Perform the redirected request
+ try {
+ this._performRequest();
+ }
+ catch (cause) {
+ var error = new RedirectionError("Redirected request failed: " + cause.message);
+ error.cause = cause;
+ this.emit("error", error);
+ }
+ }
+ else {
+ // The response is not a redirect; return it as-is
+ response.responseUrl = this._currentUrl;
+ response.redirects = this._redirects;
+ this.emit("response", response);
+
+ // Clean up
+ this._requestBodyBuffers = [];
+ }
+};
+
+// Wraps the key/value object of protocols with redirect functionality
+function wrap(protocols) {
+ // Default settings
+ var exports = {
+ maxRedirects: 21,
+ maxBodyLength: 10 * 1024 * 1024,
+ };
+
+ // Wrap each protocol
+ var nativeProtocols = {};
+ Object.keys(protocols).forEach(function (scheme) {
+ var protocol = scheme + ":";
+ var nativeProtocol = nativeProtocols[protocol] = protocols[scheme];
+ var wrappedProtocol = exports[scheme] = Object.create(nativeProtocol);
+
+ // Executes a request, following redirects
+ wrappedProtocol.request = function (input, options, callback) {
+ // Parse parameters
+ if (typeof input === "string") {
+ var urlStr = input;
+ try {
+ input = urlToOptions(new URL(urlStr));
+ }
+ catch (err) {
+ /* istanbul ignore next */
+ input = url.parse(urlStr);
+ }
+ }
+ else if (URL && (input instanceof URL)) {
+ input = urlToOptions(input);
+ }
+ else {
+ callback = options;
+ options = input;
+ input = { protocol: protocol };
+ }
+ if (typeof options === "function") {
+ callback = options;
+ options = null;
+ }
+
+ // Set defaults
+ options = Object.assign({
+ maxRedirects: exports.maxRedirects,
+ maxBodyLength: exports.maxBodyLength,
+ }, input, options);
+ options.nativeProtocols = nativeProtocols;
+
+ assert.equal(options.protocol, protocol, "protocol mismatch");
+ debug("options", options);
+ return new RedirectableRequest(options, callback);
+ };
+
+ // Executes a GET request, following redirects
+ wrappedProtocol.get = function (input, options, callback) {
+ var request = wrappedProtocol.request(input, options, callback);
+ request.end();
+ return request;
+ };
+ });
+ return exports;
+}
+
+/* istanbul ignore next */
+function noop() { /* empty */ }
+
+// from https://github.com/nodejs/node/blob/master/lib/internal/url.js
+function urlToOptions(urlObject) {
+ var options = {
+ protocol: urlObject.protocol,
+ hostname: urlObject.hostname.startsWith("[") ?
+ /* istanbul ignore next */
+ urlObject.hostname.slice(1, -1) :
+ urlObject.hostname,
+ hash: urlObject.hash,
+ search: urlObject.search,
+ pathname: urlObject.pathname,
+ path: urlObject.pathname + urlObject.search,
+ href: urlObject.href,
+ };
+ if (urlObject.port !== "") {
+ options.port = Number(urlObject.port);
+ }
+ return options;
+}
+
+function removeMatchingHeaders(regex, headers) {
+ var lastValue;
+ for (var header in headers) {
+ if (regex.test(header)) {
+ lastValue = headers[header];
+ delete headers[header];
+ }
+ }
+ return lastValue;
+}
+
+function createErrorType(code, defaultMessage) {
+ function CustomError(message) {
+ Error.captureStackTrace(this, this.constructor);
+ this.message = message || defaultMessage;
+ }
+ CustomError.prototype = new Error();
+ CustomError.prototype.constructor = CustomError;
+ CustomError.prototype.name = "Error [" + code + "]";
+ CustomError.prototype.code = code;
+ return CustomError;
+}
+
+// Exports
+module.exports = wrap({ http: http, https: https });
+module.exports.wrap = wrap;
+
+
+/***/ }),
+
+/***/ 1621:
+/***/ ((module) => {
+
+"use strict";
+
+module.exports = (flag, argv) => {
+ argv = argv || process.argv;
+ const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
+ const pos = argv.indexOf(prefix + flag);
+ const terminatorPos = argv.indexOf('--');
+ return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
+};
+
+
+/***/ }),
+
+/***/ 4124:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+try {
+ var util = __webpack_require__(1669);
+ /* istanbul ignore next */
+ if (typeof util.inherits !== 'function') throw '';
+ module.exports = util.inherits;
+} catch (e) {
+ /* istanbul ignore next */
+ module.exports = __webpack_require__(8544);
+}
+
+
+/***/ }),
+
+/***/ 8544:
+/***/ ((module) => {
+
+if (typeof Object.create === 'function') {
+ // implementation from standard node.js 'util' module
+ module.exports = function inherits(ctor, superCtor) {
+ if (superCtor) {
+ ctor.super_ = superCtor
+ ctor.prototype = Object.create(superCtor.prototype, {
+ constructor: {
+ value: ctor,
+ enumerable: false,
+ writable: true,
+ configurable: true
+ }
+ })
+ }
+ };
+} else {
+ // old school shim for old browsers
+ module.exports = function inherits(ctor, superCtor) {
+ if (superCtor) {
+ ctor.super_ = superCtor
+ var TempCtor = function () {}
+ TempCtor.prototype = superCtor.prototype
+ ctor.prototype = new TempCtor()
+ ctor.prototype.constructor = ctor
+ }
+ }
+}
+
+
+/***/ }),
+
+/***/ 900:
+/***/ ((module) => {
+
+/**
+ * Helpers.
+ */
+
+var s = 1000;
+var m = s * 60;
+var h = m * 60;
+var d = h * 24;
+var w = d * 7;
+var y = d * 365.25;
+
+/**
+ * Parse or format the given `val`.
+ *
+ * Options:
+ *
+ * - `long` verbose formatting [false]
+ *
+ * @param {String|Number} val
+ * @param {Object} [options]
+ * @throws {Error} throw an error if val is not a non-empty string or a number
+ * @return {String|Number}
+ * @api public
+ */
+
+module.exports = function(val, options) {
+ options = options || {};
+ var type = typeof val;
+ if (type === 'string' && val.length > 0) {
+ return parse(val);
+ } else if (type === 'number' && isFinite(val)) {
+ return options.long ? fmtLong(val) : fmtShort(val);
+ }
+ throw new Error(
+ 'val is not a non-empty string or a valid number. val=' +
+ JSON.stringify(val)
+ );
+};
+
+/**
+ * Parse the given `str` and return milliseconds.
+ *
+ * @param {String} str
+ * @return {Number}
+ * @api private
+ */
+
+function parse(str) {
+ str = String(str);
+ if (str.length > 100) {
+ return;
+ }
+ var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+ str
+ );
+ if (!match) {
+ return;
+ }
+ var n = parseFloat(match[1]);
+ var type = (match[2] || 'ms').toLowerCase();
+ switch (type) {
+ case 'years':
+ case 'year':
+ case 'yrs':
+ case 'yr':
+ case 'y':
+ return n * y;
+ case 'weeks':
+ case 'week':
+ case 'w':
+ return n * w;
+ case 'days':
+ case 'day':
+ case 'd':
+ return n * d;
+ case 'hours':
+ case 'hour':
+ case 'hrs':
+ case 'hr':
+ case 'h':
+ return n * h;
+ case 'minutes':
+ case 'minute':
+ case 'mins':
+ case 'min':
+ case 'm':
+ return n * m;
+ case 'seconds':
+ case 'second':
+ case 'secs':
+ case 'sec':
+ case 's':
+ return n * s;
+ case 'milliseconds':
+ case 'millisecond':
+ case 'msecs':
+ case 'msec':
+ case 'ms':
+ return n;
+ default:
+ return undefined;
+ }
+}
+
+/**
+ * Short format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function fmtShort(ms) {
+ var msAbs = Math.abs(ms);
+ if (msAbs >= d) {
+ return Math.round(ms / d) + 'd';
+ }
+ if (msAbs >= h) {
+ return Math.round(ms / h) + 'h';
+ }
+ if (msAbs >= m) {
+ return Math.round(ms / m) + 'm';
+ }
+ if (msAbs >= s) {
+ return Math.round(ms / s) + 's';
+ }
+ return ms + 'ms';
+}
+
+/**
+ * Long format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function fmtLong(ms) {
+ var msAbs = Math.abs(ms);
+ if (msAbs >= d) {
+ return plural(ms, msAbs, d, 'day');
+ }
+ if (msAbs >= h) {
+ return plural(ms, msAbs, h, 'hour');
+ }
+ if (msAbs >= m) {
+ return plural(ms, msAbs, m, 'minute');
+ }
+ if (msAbs >= s) {
+ return plural(ms, msAbs, s, 'second');
+ }
+ return ms + ' ms';
+}
+
+/**
+ * Pluralization helper.
+ */
+
+function plural(ms, msAbs, n, name) {
+ var isPlural = msAbs >= n * 1.5;
+ return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+}
+
+
+/***/ }),
+
+/***/ 7999:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+/*! multistream. MIT License. Feross Aboukhadijeh */
+var stream = __webpack_require__(1642)
+
+function toStreams2Obj (s) {
+ return toStreams2(s, { objectMode: true, highWaterMark: 16 })
+}
+
+function toStreams2Buf (s) {
+ return toStreams2(s)
+}
+
+function toStreams2 (s, opts) {
+ if (!s || typeof s === 'function' || s._readableState) return s
+
+ var wrap = new stream.Readable(opts).wrap(s)
+ if (s.destroy) {
+ wrap.destroy = s.destroy.bind(s)
+ }
+ return wrap
+}
+
+class MultiStream extends stream.Readable {
+ constructor (streams, opts) {
+ super(opts)
+
+ this.destroyed = false
+
+ this._drained = false
+ this._forwarding = false
+ this._current = null
+ this._toStreams2 = (opts && opts.objectMode) ? toStreams2Obj : toStreams2Buf
+
+ if (typeof streams === 'function') {
+ this._queue = streams
+ } else {
+ this._queue = streams.map(this._toStreams2)
+ this._queue.forEach(stream => {
+ if (typeof stream !== 'function') this._attachErrorListener(stream)
+ })
+ }
+
+ this._next()
+ }
+
+ _read () {
+ this._drained = true
+ this._forward()
+ }
+
+ _forward () {
+ if (this._forwarding || !this._drained || !this._current) return
+ this._forwarding = true
+
+ var chunk
+ while (this._drained && (chunk = this._current.read()) !== null) {
+ this._drained = this.push(chunk)
+ }
+
+ this._forwarding = false
+ }
+
+ destroy (err) {
+ if (this.destroyed) return
+ this.destroyed = true
+
+ if (this._current && this._current.destroy) this._current.destroy()
+ if (typeof this._queue !== 'function') {
+ this._queue.forEach(stream => {
+ if (stream.destroy) stream.destroy()
+ })
+ }
+
+ if (err) this.emit('error', err)
+ this.emit('close')
+ }
+
+ _next () {
+ this._current = null
+
+ if (typeof this._queue === 'function') {
+ this._queue((err, stream) => {
+ if (err) return this.destroy(err)
+ stream = this._toStreams2(stream)
+ this._attachErrorListener(stream)
+ this._gotNextStream(stream)
+ })
+ } else {
+ var stream = this._queue.shift()
+ if (typeof stream === 'function') {
+ stream = this._toStreams2(stream())
+ this._attachErrorListener(stream)
+ }
+ this._gotNextStream(stream)
+ }
+ }
+
+ _gotNextStream (stream) {
+ if (!stream) {
+ this.push(null)
+ this.destroy()
+ return
+ }
+
+ this._current = stream
+ this._forward()
+
+ const onReadable = () => {
+ this._forward()
+ }
+
+ const onClose = () => {
+ if (!stream._readableState.ended) {
+ this.destroy()
+ }
+ }
+
+ const onEnd = () => {
+ this._current = null
+ stream.removeListener('readable', onReadable)
+ stream.removeListener('end', onEnd)
+ stream.removeListener('close', onClose)
+ this._next()
+ }
+
+ stream.on('readable', onReadable)
+ stream.once('end', onEnd)
+ stream.once('close', onClose)
+ }
+
+ _attachErrorListener (stream) {
+ if (!stream) return
+
+ const onError = (err) => {
+ stream.removeListener('error', onError)
+ this.destroy(err)
+ }
+
+ stream.once('error', onError)
+ }
+}
+
+MultiStream.obj = streams => (
+ new MultiStream(streams, { objectMode: true, highWaterMark: 16 })
+)
+
+module.exports = MultiStream
+
+
+/***/ }),
+
+/***/ 7214:
+/***/ ((module) => {
+
+"use strict";
+
+
+const codes = {};
+
+function createErrorType(code, message, Base) {
+ if (!Base) {
+ Base = Error
+ }
+
+ function getMessage (arg1, arg2, arg3) {
+ if (typeof message === 'string') {
+ return message
+ } else {
+ return message(arg1, arg2, arg3)
+ }
+ }
+
+ class NodeError extends Base {
+ constructor (arg1, arg2, arg3) {
+ super(getMessage(arg1, arg2, arg3));
+ }
+ }
+
+ NodeError.prototype.name = Base.name;
+ NodeError.prototype.code = code;
+
+ codes[code] = NodeError;
+}
+
+// https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js
+function oneOf(expected, thing) {
+ if (Array.isArray(expected)) {
+ const len = expected.length;
+ expected = expected.map((i) => String(i));
+ if (len > 2) {
+ return `one of ${thing} ${expected.slice(0, len - 1).join(', ')}, or ` +
+ expected[len - 1];
+ } else if (len === 2) {
+ return `one of ${thing} ${expected[0]} or ${expected[1]}`;
+ } else {
+ return `of ${thing} ${expected[0]}`;
+ }
+ } else {
+ return `of ${thing} ${String(expected)}`;
+ }
+}
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith
+function startsWith(str, search, pos) {
+ return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
+}
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith
+function endsWith(str, search, this_len) {
+ if (this_len === undefined || this_len > str.length) {
+ this_len = str.length;
+ }
+ return str.substring(this_len - search.length, this_len) === search;
+}
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes
+function includes(str, search, start) {
+ if (typeof start !== 'number') {
+ start = 0;
+ }
+
+ if (start + search.length > str.length) {
+ return false;
+ } else {
+ return str.indexOf(search, start) !== -1;
+ }
+}
+
+createErrorType('ERR_INVALID_OPT_VALUE', function (name, value) {
+ return 'The value "' + value + '" is invalid for option "' + name + '"'
+}, TypeError);
+createErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {
+ // determiner: 'must be' or 'must not be'
+ let determiner;
+ if (typeof expected === 'string' && startsWith(expected, 'not ')) {
+ determiner = 'must not be';
+ expected = expected.replace(/^not /, '');
+ } else {
+ determiner = 'must be';
+ }
+
+ let msg;
+ if (endsWith(name, ' argument')) {
+ // For cases like 'first argument'
+ msg = `The ${name} ${determiner} ${oneOf(expected, 'type')}`;
+ } else {
+ const type = includes(name, '.') ? 'property' : 'argument';
+ msg = `The "${name}" ${type} ${determiner} ${oneOf(expected, 'type')}`;
+ }
+
+ msg += `. Received type ${typeof actual}`;
+ return msg;
+}, TypeError);
+createErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');
+createErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {
+ return 'The ' + name + ' method is not implemented'
+});
+createErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');
+createErrorType('ERR_STREAM_DESTROYED', function (name) {
+ return 'Cannot call ' + name + ' after a stream was destroyed';
+});
+createErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');
+createErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');
+createErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');
+createErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);
+createErrorType('ERR_UNKNOWN_ENCODING', function (arg) {
+ return 'Unknown encoding: ' + arg
+}, TypeError);
+createErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');
+
+module.exports.q = codes;
+
+
+/***/ }),
+
+/***/ 1359:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+// a duplex stream is just a stream that is both readable and writable.
+// Since JS doesn't have multiple prototypal inheritance, this class
+// prototypally inherits from Readable, and then parasitically from
+// Writable.
+
+/**/
+
+var objectKeys = Object.keys || function (obj) {
+ var keys = [];
+
+ for (var key in obj) {
+ keys.push(key);
+ }
+
+ return keys;
+};
+/**/
+
+
+module.exports = Duplex;
+
+var Readable = __webpack_require__(1433);
+
+var Writable = __webpack_require__(6993);
+
+__webpack_require__(4124)(Duplex, Readable);
+
+{
+ // Allow the keys array to be GC'ed.
+ var keys = objectKeys(Writable.prototype);
+
+ for (var v = 0; v < keys.length; v++) {
+ var method = keys[v];
+ if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
+ }
+}
+
+function Duplex(options) {
+ if (!(this instanceof Duplex)) return new Duplex(options);
+ Readable.call(this, options);
+ Writable.call(this, options);
+ this.allowHalfOpen = true;
+
+ if (options) {
+ if (options.readable === false) this.readable = false;
+ if (options.writable === false) this.writable = false;
+
+ if (options.allowHalfOpen === false) {
+ this.allowHalfOpen = false;
+ this.once('end', onend);
+ }
+ }
+}
+
+Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', {
+ // making it explicit this property is not enumerable
+ // because otherwise some prototype manipulation in
+ // userland will fail
+ enumerable: false,
+ get: function get() {
+ return this._writableState.highWaterMark;
+ }
+});
+Object.defineProperty(Duplex.prototype, 'writableBuffer', {
+ // making it explicit this property is not enumerable
+ // because otherwise some prototype manipulation in
+ // userland will fail
+ enumerable: false,
+ get: function get() {
+ return this._writableState && this._writableState.getBuffer();
+ }
+});
+Object.defineProperty(Duplex.prototype, 'writableLength', {
+ // making it explicit this property is not enumerable
+ // because otherwise some prototype manipulation in
+ // userland will fail
+ enumerable: false,
+ get: function get() {
+ return this._writableState.length;
+ }
+}); // the no-half-open enforcer
+
+function onend() {
+ // If the writable side ended, then we're ok.
+ if (this._writableState.ended) return; // no more data can be written.
+ // But allow more writes to happen in this tick.
+
+ process.nextTick(onEndNT, this);
+}
+
+function onEndNT(self) {
+ self.end();
+}
+
+Object.defineProperty(Duplex.prototype, 'destroyed', {
+ // making it explicit this property is not enumerable
+ // because otherwise some prototype manipulation in
+ // userland will fail
+ enumerable: false,
+ get: function get() {
+ if (this._readableState === undefined || this._writableState === undefined) {
+ return false;
+ }
+
+ return this._readableState.destroyed && this._writableState.destroyed;
+ },
+ set: function set(value) {
+ // we ignore the value if the stream
+ // has not been initialized yet
+ if (this._readableState === undefined || this._writableState === undefined) {
+ return;
+ } // backward compatibility, the user is explicitly
+ // managing destroyed
+
+
+ this._readableState.destroyed = value;
+ this._writableState.destroyed = value;
+ }
+});
+
+/***/ }),
+
+/***/ 1542:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+// a passthrough stream.
+// basically just the most minimal sort of Transform stream.
+// Every written chunk gets output as-is.
+
+
+module.exports = PassThrough;
+
+var Transform = __webpack_require__(4415);
+
+__webpack_require__(4124)(PassThrough, Transform);
+
+function PassThrough(options) {
+ if (!(this instanceof PassThrough)) return new PassThrough(options);
+ Transform.call(this, options);
+}
+
+PassThrough.prototype._transform = function (chunk, encoding, cb) {
+ cb(null, chunk);
+};
+
+/***/ }),
+
+/***/ 1433:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+module.exports = Readable;
+/**/
+
+var Duplex;
+/**/
+
+Readable.ReadableState = ReadableState;
+/**/
+
+var EE = __webpack_require__(8614).EventEmitter;
+
+var EElistenerCount = function EElistenerCount(emitter, type) {
+ return emitter.listeners(type).length;
+};
+/**/
+
+/**/
+
+
+var Stream = __webpack_require__(2387);
+/**/
+
+
+var Buffer = __webpack_require__(4293).Buffer;
+
+var OurUint8Array = global.Uint8Array || function () {};
+
+function _uint8ArrayToBuffer(chunk) {
+ return Buffer.from(chunk);
+}
+
+function _isUint8Array(obj) {
+ return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
+}
+/**/
+
+
+var debugUtil = __webpack_require__(1669);
+
+var debug;
+
+if (debugUtil && debugUtil.debuglog) {
+ debug = debugUtil.debuglog('stream');
+} else {
+ debug = function debug() {};
+}
+/**/
+
+
+var BufferList = __webpack_require__(2746);
+
+var destroyImpl = __webpack_require__(7049);
+
+var _require = __webpack_require__(9948),
+ getHighWaterMark = _require.getHighWaterMark;
+
+var _require$codes = __webpack_require__(7214)/* .codes */ .q,
+ ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
+ ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF,
+ ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
+ ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT; // Lazy loaded to improve the startup performance.
+
+
+var StringDecoder;
+var createReadableStreamAsyncIterator;
+var from;
+
+__webpack_require__(4124)(Readable, Stream);
+
+var errorOrDestroy = destroyImpl.errorOrDestroy;
+var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];
+
+function prependListener(emitter, event, fn) {
+ // Sadly this is not cacheable as some libraries bundle their own
+ // event emitter implementation with them.
+ if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn); // This is a hack to make sure that our error handler is attached before any
+ // userland ones. NEVER DO THIS. This is here only because this code needs
+ // to continue to work with older versions of Node.js that do not include
+ // the prependListener() method. The goal is to eventually remove this hack.
+
+ if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];
+}
+
+function ReadableState(options, stream, isDuplex) {
+ Duplex = Duplex || __webpack_require__(1359);
+ options = options || {}; // Duplex streams are both readable and writable, but share
+ // the same options object.
+ // However, some cases require setting options to different
+ // values for the readable and the writable sides of the duplex stream.
+ // These options can be provided separately as readableXXX and writableXXX.
+
+ if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag. Used to make read(n) ignore n and to
+ // make all the buffer merging and length checks go away
+
+ this.objectMode = !!options.objectMode;
+ if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; // the point at which it stops calling _read() to fill the buffer
+ // Note: 0 is a valid value, means "don't call _read preemptively ever"
+
+ this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex); // A linked list is used to store data chunks instead of an array because the
+ // linked list can remove elements from the beginning faster than
+ // array.shift()
+
+ this.buffer = new BufferList();
+ this.length = 0;
+ this.pipes = null;
+ this.pipesCount = 0;
+ this.flowing = null;
+ this.ended = false;
+ this.endEmitted = false;
+ this.reading = false; // a flag to be able to tell if the event 'readable'/'data' is emitted
+ // immediately, or on a later tick. We set this to true at first, because
+ // any actions that shouldn't happen until "later" should generally also
+ // not happen before the first read call.
+
+ this.sync = true; // whenever we return null, then we set a flag to say
+ // that we're awaiting a 'readable' event emission.
+
+ this.needReadable = false;
+ this.emittedReadable = false;
+ this.readableListening = false;
+ this.resumeScheduled = false;
+ this.paused = true; // Should close be emitted on destroy. Defaults to true.
+
+ this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'end' (and potentially 'finish')
+
+ this.autoDestroy = !!options.autoDestroy; // has it been destroyed
+
+ this.destroyed = false; // Crypto is kind of old and crusty. Historically, its default string
+ // encoding is 'binary' so we have to make this configurable.
+ // Everything else in the universe uses 'utf8', though.
+
+ this.defaultEncoding = options.defaultEncoding || 'utf8'; // the number of writers that are awaiting a drain event in .pipe()s
+
+ this.awaitDrain = 0; // if true, a maybeReadMore has been scheduled
+
+ this.readingMore = false;
+ this.decoder = null;
+ this.encoding = null;
+
+ if (options.encoding) {
+ if (!StringDecoder) StringDecoder = __webpack_require__(4841)/* .StringDecoder */ .s;
+ this.decoder = new StringDecoder(options.encoding);
+ this.encoding = options.encoding;
+ }
+}
+
+function Readable(options) {
+ Duplex = Duplex || __webpack_require__(1359);
+ if (!(this instanceof Readable)) return new Readable(options); // Checking for a Stream.Duplex instance is faster here instead of inside
+ // the ReadableState constructor, at least with V8 6.5
+
+ var isDuplex = this instanceof Duplex;
+ this._readableState = new ReadableState(options, this, isDuplex); // legacy
+
+ this.readable = true;
+
+ if (options) {
+ if (typeof options.read === 'function') this._read = options.read;
+ if (typeof options.destroy === 'function') this._destroy = options.destroy;
+ }
+
+ Stream.call(this);
+}
+
+Object.defineProperty(Readable.prototype, 'destroyed', {
+ // making it explicit this property is not enumerable
+ // because otherwise some prototype manipulation in
+ // userland will fail
+ enumerable: false,
+ get: function get() {
+ if (this._readableState === undefined) {
+ return false;
+ }
+
+ return this._readableState.destroyed;
+ },
+ set: function set(value) {
+ // we ignore the value if the stream
+ // has not been initialized yet
+ if (!this._readableState) {
+ return;
+ } // backward compatibility, the user is explicitly
+ // managing destroyed
+
+
+ this._readableState.destroyed = value;
+ }
+});
+Readable.prototype.destroy = destroyImpl.destroy;
+Readable.prototype._undestroy = destroyImpl.undestroy;
+
+Readable.prototype._destroy = function (err, cb) {
+ cb(err);
+}; // Manually shove something into the read() buffer.
+// This returns true if the highWaterMark has not been hit yet,
+// similar to how Writable.write() returns true if you should
+// write() some more.
+
+
+Readable.prototype.push = function (chunk, encoding) {
+ var state = this._readableState;
+ var skipChunkCheck;
+
+ if (!state.objectMode) {
+ if (typeof chunk === 'string') {
+ encoding = encoding || state.defaultEncoding;
+
+ if (encoding !== state.encoding) {
+ chunk = Buffer.from(chunk, encoding);
+ encoding = '';
+ }
+
+ skipChunkCheck = true;
+ }
+ } else {
+ skipChunkCheck = true;
+ }
+
+ return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
+}; // Unshift should *always* be something directly out of read()
+
+
+Readable.prototype.unshift = function (chunk) {
+ return readableAddChunk(this, chunk, null, true, false);
+};
+
+function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
+ debug('readableAddChunk', chunk);
+ var state = stream._readableState;
+
+ if (chunk === null) {
+ state.reading = false;
+ onEofChunk(stream, state);
+ } else {
+ var er;
+ if (!skipChunkCheck) er = chunkInvalid(state, chunk);
+
+ if (er) {
+ errorOrDestroy(stream, er);
+ } else if (state.objectMode || chunk && chunk.length > 0) {
+ if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {
+ chunk = _uint8ArrayToBuffer(chunk);
+ }
+
+ if (addToFront) {
+ if (state.endEmitted) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());else addChunk(stream, state, chunk, true);
+ } else if (state.ended) {
+ errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF());
+ } else if (state.destroyed) {
+ return false;
+ } else {
+ state.reading = false;
+
+ if (state.decoder && !encoding) {
+ chunk = state.decoder.write(chunk);
+ if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);
+ } else {
+ addChunk(stream, state, chunk, false);
+ }
+ }
+ } else if (!addToFront) {
+ state.reading = false;
+ maybeReadMore(stream, state);
+ }
+ } // We can push more data if we are below the highWaterMark.
+ // Also, if we have no data yet, we can stand some more bytes.
+ // This is to work around cases where hwm=0, such as the repl.
+
+
+ return !state.ended && (state.length < state.highWaterMark || state.length === 0);
+}
+
+function addChunk(stream, state, chunk, addToFront) {
+ if (state.flowing && state.length === 0 && !state.sync) {
+ state.awaitDrain = 0;
+ stream.emit('data', chunk);
+ } else {
+ // update the buffer info.
+ state.length += state.objectMode ? 1 : chunk.length;
+ if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);
+ if (state.needReadable) emitReadable(stream);
+ }
+
+ maybeReadMore(stream, state);
+}
+
+function chunkInvalid(state, chunk) {
+ var er;
+
+ if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
+ er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk);
+ }
+
+ return er;
+}
+
+Readable.prototype.isPaused = function () {
+ return this._readableState.flowing === false;
+}; // backwards compatibility.
+
+
+Readable.prototype.setEncoding = function (enc) {
+ if (!StringDecoder) StringDecoder = __webpack_require__(4841)/* .StringDecoder */ .s;
+ var decoder = new StringDecoder(enc);
+ this._readableState.decoder = decoder; // If setEncoding(null), decoder.encoding equals utf8
+
+ this._readableState.encoding = this._readableState.decoder.encoding; // Iterate over current buffer to convert already stored Buffers:
+
+ var p = this._readableState.buffer.head;
+ var content = '';
+
+ while (p !== null) {
+ content += decoder.write(p.data);
+ p = p.next;
+ }
+
+ this._readableState.buffer.clear();
+
+ if (content !== '') this._readableState.buffer.push(content);
+ this._readableState.length = content.length;
+ return this;
+}; // Don't raise the hwm > 1GB
+
+
+var MAX_HWM = 0x40000000;
+
+function computeNewHighWaterMark(n) {
+ if (n >= MAX_HWM) {
+ // TODO(ronag): Throw ERR_VALUE_OUT_OF_RANGE.
+ n = MAX_HWM;
+ } else {
+ // Get the next highest power of 2 to prevent increasing hwm excessively in
+ // tiny amounts
+ n--;
+ n |= n >>> 1;
+ n |= n >>> 2;
+ n |= n >>> 4;
+ n |= n >>> 8;
+ n |= n >>> 16;
+ n++;
+ }
+
+ return n;
+} // This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+
+
+function howMuchToRead(n, state) {
+ if (n <= 0 || state.length === 0 && state.ended) return 0;
+ if (state.objectMode) return 1;
+
+ if (n !== n) {
+ // Only flow one buffer at a time
+ if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;
+ } // If we're asking for more than the current hwm, then raise the hwm.
+
+
+ if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
+ if (n <= state.length) return n; // Don't have enough
+
+ if (!state.ended) {
+ state.needReadable = true;
+ return 0;
+ }
+
+ return state.length;
+} // you can override either this method, or the async _read(n) below.
+
+
+Readable.prototype.read = function (n) {
+ debug('read', n);
+ n = parseInt(n, 10);
+ var state = this._readableState;
+ var nOrig = n;
+ if (n !== 0) state.emittedReadable = false; // if we're doing read(0) to trigger a readable event, but we
+ // already have a bunch of data in the buffer, then just trigger
+ // the 'readable' event and move on.
+
+ if (n === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) {
+ debug('read: emitReadable', state.length, state.ended);
+ if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);
+ return null;
+ }
+
+ n = howMuchToRead(n, state); // if we've ended, and we're now clear, then finish it up.
+
+ if (n === 0 && state.ended) {
+ if (state.length === 0) endReadable(this);
+ return null;
+ } // All the actual chunk generation logic needs to be
+ // *below* the call to _read. The reason is that in certain
+ // synthetic stream cases, such as passthrough streams, _read
+ // may be a completely synchronous operation which may change
+ // the state of the read buffer, providing enough data when
+ // before there was *not* enough.
+ //
+ // So, the steps are:
+ // 1. Figure out what the state of things will be after we do
+ // a read from the buffer.
+ //
+ // 2. If that resulting state will trigger a _read, then call _read.
+ // Note that this may be asynchronous, or synchronous. Yes, it is
+ // deeply ugly to write APIs this way, but that still doesn't mean
+ // that the Readable class should behave improperly, as streams are
+ // designed to be sync/async agnostic.
+ // Take note if the _read call is sync or async (ie, if the read call
+ // has returned yet), so that we know whether or not it's safe to emit
+ // 'readable' etc.
+ //
+ // 3. Actually pull the requested chunks out of the buffer and return.
+ // if we need a readable event, then we need to do some reading.
+
+
+ var doRead = state.needReadable;
+ debug('need readable', doRead); // if we currently have less than the highWaterMark, then also read some
+
+ if (state.length === 0 || state.length - n < state.highWaterMark) {
+ doRead = true;
+ debug('length less than watermark', doRead);
+ } // however, if we've ended, then there's no point, and if we're already
+ // reading, then it's unnecessary.
+
+
+ if (state.ended || state.reading) {
+ doRead = false;
+ debug('reading or ended', doRead);
+ } else if (doRead) {
+ debug('do read');
+ state.reading = true;
+ state.sync = true; // if the length is currently zero, then we *need* a readable event.
+
+ if (state.length === 0) state.needReadable = true; // call internal read method
+
+ this._read(state.highWaterMark);
+
+ state.sync = false; // If _read pushed data synchronously, then `reading` will be false,
+ // and we need to re-evaluate how much data we can return to the user.
+
+ if (!state.reading) n = howMuchToRead(nOrig, state);
+ }
+
+ var ret;
+ if (n > 0) ret = fromList(n, state);else ret = null;
+
+ if (ret === null) {
+ state.needReadable = state.length <= state.highWaterMark;
+ n = 0;
+ } else {
+ state.length -= n;
+ state.awaitDrain = 0;
+ }
+
+ if (state.length === 0) {
+ // If we have nothing in the buffer, then we want to know
+ // as soon as we *do* get something into the buffer.
+ if (!state.ended) state.needReadable = true; // If we tried to read() past the EOF, then emit end on the next tick.
+
+ if (nOrig !== n && state.ended) endReadable(this);
+ }
+
+ if (ret !== null) this.emit('data', ret);
+ return ret;
+};
+
+function onEofChunk(stream, state) {
+ debug('onEofChunk');
+ if (state.ended) return;
+
+ if (state.decoder) {
+ var chunk = state.decoder.end();
+
+ if (chunk && chunk.length) {
+ state.buffer.push(chunk);
+ state.length += state.objectMode ? 1 : chunk.length;
+ }
+ }
+
+ state.ended = true;
+
+ if (state.sync) {
+ // if we are sync, wait until next tick to emit the data.
+ // Otherwise we risk emitting data in the flow()
+ // the readable code triggers during a read() call
+ emitReadable(stream);
+ } else {
+ // emit 'readable' now to make sure it gets picked up.
+ state.needReadable = false;
+
+ if (!state.emittedReadable) {
+ state.emittedReadable = true;
+ emitReadable_(stream);
+ }
+ }
+} // Don't emit readable right away in sync mode, because this can trigger
+// another read() call => stack overflow. This way, it might trigger
+// a nextTick recursion warning, but that's not so bad.
+
+
+function emitReadable(stream) {
+ var state = stream._readableState;
+ debug('emitReadable', state.needReadable, state.emittedReadable);
+ state.needReadable = false;
+
+ if (!state.emittedReadable) {
+ debug('emitReadable', state.flowing);
+ state.emittedReadable = true;
+ process.nextTick(emitReadable_, stream);
+ }
+}
+
+function emitReadable_(stream) {
+ var state = stream._readableState;
+ debug('emitReadable_', state.destroyed, state.length, state.ended);
+
+ if (!state.destroyed && (state.length || state.ended)) {
+ stream.emit('readable');
+ state.emittedReadable = false;
+ } // The stream needs another readable event if
+ // 1. It is not flowing, as the flow mechanism will take
+ // care of it.
+ // 2. It is not ended.
+ // 3. It is below the highWaterMark, so we can schedule
+ // another readable later.
+
+
+ state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;
+ flow(stream);
+} // at this point, the user has presumably seen the 'readable' event,
+// and called read() to consume some data. that may have triggered
+// in turn another _read(n) call, in which case reading = true if
+// it's in progress.
+// However, if we're not ended, or reading, and the length < hwm,
+// then go ahead and try to read some more preemptively.
+
+
+function maybeReadMore(stream, state) {
+ if (!state.readingMore) {
+ state.readingMore = true;
+ process.nextTick(maybeReadMore_, stream, state);
+ }
+}
+
+function maybeReadMore_(stream, state) {
+ // Attempt to read more data if we should.
+ //
+ // The conditions for reading more data are (one of):
+ // - Not enough data buffered (state.length < state.highWaterMark). The loop
+ // is responsible for filling the buffer with enough data if such data
+ // is available. If highWaterMark is 0 and we are not in the flowing mode
+ // we should _not_ attempt to buffer any extra data. We'll get more data
+ // when the stream consumer calls read() instead.
+ // - No data in the buffer, and the stream is in flowing mode. In this mode
+ // the loop below is responsible for ensuring read() is called. Failing to
+ // call read here would abort the flow and there's no other mechanism for
+ // continuing the flow if the stream consumer has just subscribed to the
+ // 'data' event.
+ //
+ // In addition to the above conditions to keep reading data, the following
+ // conditions prevent the data from being read:
+ // - The stream has ended (state.ended).
+ // - There is already a pending 'read' operation (state.reading). This is a
+ // case where the the stream has called the implementation defined _read()
+ // method, but they are processing the call asynchronously and have _not_
+ // called push() with new data. In this case we skip performing more
+ // read()s. The execution ends in this method again after the _read() ends
+ // up calling push() with more data.
+ while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) {
+ var len = state.length;
+ debug('maybeReadMore read 0');
+ stream.read(0);
+ if (len === state.length) // didn't get any data, stop spinning.
+ break;
+ }
+
+ state.readingMore = false;
+} // abstract method. to be overridden in specific implementation classes.
+// call cb(er, data) where data is <= n in length.
+// for virtual (non-string, non-buffer) streams, "length" is somewhat
+// arbitrary, and perhaps not very meaningful.
+
+
+Readable.prototype._read = function (n) {
+ errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED('_read()'));
+};
+
+Readable.prototype.pipe = function (dest, pipeOpts) {
+ var src = this;
+ var state = this._readableState;
+
+ switch (state.pipesCount) {
+ case 0:
+ state.pipes = dest;
+ break;
+
+ case 1:
+ state.pipes = [state.pipes, dest];
+ break;
+
+ default:
+ state.pipes.push(dest);
+ break;
+ }
+
+ state.pipesCount += 1;
+ debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
+ var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
+ var endFn = doEnd ? onend : unpipe;
+ if (state.endEmitted) process.nextTick(endFn);else src.once('end', endFn);
+ dest.on('unpipe', onunpipe);
+
+ function onunpipe(readable, unpipeInfo) {
+ debug('onunpipe');
+
+ if (readable === src) {
+ if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
+ unpipeInfo.hasUnpiped = true;
+ cleanup();
+ }
+ }
+ }
+
+ function onend() {
+ debug('onend');
+ dest.end();
+ } // when the dest drains, it reduces the awaitDrain counter
+ // on the source. This would be more elegant with a .once()
+ // handler in flow(), but adding and removing repeatedly is
+ // too slow.
+
+
+ var ondrain = pipeOnDrain(src);
+ dest.on('drain', ondrain);
+ var cleanedUp = false;
+
+ function cleanup() {
+ debug('cleanup'); // cleanup event handlers once the pipe is broken
+
+ dest.removeListener('close', onclose);
+ dest.removeListener('finish', onfinish);
+ dest.removeListener('drain', ondrain);
+ dest.removeListener('error', onerror);
+ dest.removeListener('unpipe', onunpipe);
+ src.removeListener('end', onend);
+ src.removeListener('end', unpipe);
+ src.removeListener('data', ondata);
+ cleanedUp = true; // if the reader is waiting for a drain event from this
+ // specific writer, then it would cause it to never start
+ // flowing again.
+ // So, if this is awaiting a drain, then we just call it now.
+ // If we don't know, then assume that we are waiting for one.
+
+ if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
+ }
+
+ src.on('data', ondata);
+
+ function ondata(chunk) {
+ debug('ondata');
+ var ret = dest.write(chunk);
+ debug('dest.write', ret);
+
+ if (ret === false) {
+ // If the user unpiped during `dest.write()`, it is possible
+ // to get stuck in a permanently paused state if that write
+ // also returned false.
+ // => Check whether `dest` is still a piping destination.
+ if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
+ debug('false write response, pause', state.awaitDrain);
+ state.awaitDrain++;
+ }
+
+ src.pause();
+ }
+ } // if the dest has an error, then stop piping into it.
+ // however, don't suppress the throwing behavior for this.
+
+
+ function onerror(er) {
+ debug('onerror', er);
+ unpipe();
+ dest.removeListener('error', onerror);
+ if (EElistenerCount(dest, 'error') === 0) errorOrDestroy(dest, er);
+ } // Make sure our error handler is attached before userland ones.
+
+
+ prependListener(dest, 'error', onerror); // Both close and finish should trigger unpipe, but only once.
+
+ function onclose() {
+ dest.removeListener('finish', onfinish);
+ unpipe();
+ }
+
+ dest.once('close', onclose);
+
+ function onfinish() {
+ debug('onfinish');
+ dest.removeListener('close', onclose);
+ unpipe();
+ }
+
+ dest.once('finish', onfinish);
+
+ function unpipe() {
+ debug('unpipe');
+ src.unpipe(dest);
+ } // tell the dest that it's being piped to
+
+
+ dest.emit('pipe', src); // start the flow if it hasn't been started already.
+
+ if (!state.flowing) {
+ debug('pipe resume');
+ src.resume();
+ }
+
+ return dest;
+};
+
+function pipeOnDrain(src) {
+ return function pipeOnDrainFunctionResult() {
+ var state = src._readableState;
+ debug('pipeOnDrain', state.awaitDrain);
+ if (state.awaitDrain) state.awaitDrain--;
+
+ if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {
+ state.flowing = true;
+ flow(src);
+ }
+ };
+}
+
+Readable.prototype.unpipe = function (dest) {
+ var state = this._readableState;
+ var unpipeInfo = {
+ hasUnpiped: false
+ }; // if we're not piping anywhere, then do nothing.
+
+ if (state.pipesCount === 0) return this; // just one destination. most common case.
+
+ if (state.pipesCount === 1) {
+ // passed in one, but it's not the right one.
+ if (dest && dest !== state.pipes) return this;
+ if (!dest) dest = state.pipes; // got a match.
+
+ state.pipes = null;
+ state.pipesCount = 0;
+ state.flowing = false;
+ if (dest) dest.emit('unpipe', this, unpipeInfo);
+ return this;
+ } // slow case. multiple pipe destinations.
+
+
+ if (!dest) {
+ // remove all.
+ var dests = state.pipes;
+ var len = state.pipesCount;
+ state.pipes = null;
+ state.pipesCount = 0;
+ state.flowing = false;
+
+ for (var i = 0; i < len; i++) {
+ dests[i].emit('unpipe', this, {
+ hasUnpiped: false
+ });
+ }
+
+ return this;
+ } // try to find the right one.
+
+
+ var index = indexOf(state.pipes, dest);
+ if (index === -1) return this;
+ state.pipes.splice(index, 1);
+ state.pipesCount -= 1;
+ if (state.pipesCount === 1) state.pipes = state.pipes[0];
+ dest.emit('unpipe', this, unpipeInfo);
+ return this;
+}; // set up data events if they are asked for
+// Ensure readable listeners eventually get something
+
+
+Readable.prototype.on = function (ev, fn) {
+ var res = Stream.prototype.on.call(this, ev, fn);
+ var state = this._readableState;
+
+ if (ev === 'data') {
+ // update readableListening so that resume() may be a no-op
+ // a few lines down. This is needed to support once('readable').
+ state.readableListening = this.listenerCount('readable') > 0; // Try start flowing on next tick if stream isn't explicitly paused
+
+ if (state.flowing !== false) this.resume();
+ } else if (ev === 'readable') {
+ if (!state.endEmitted && !state.readableListening) {
+ state.readableListening = state.needReadable = true;
+ state.flowing = false;
+ state.emittedReadable = false;
+ debug('on readable', state.length, state.reading);
+
+ if (state.length) {
+ emitReadable(this);
+ } else if (!state.reading) {
+ process.nextTick(nReadingNextTick, this);
+ }
+ }
+ }
+
+ return res;
+};
+
+Readable.prototype.addListener = Readable.prototype.on;
+
+Readable.prototype.removeListener = function (ev, fn) {
+ var res = Stream.prototype.removeListener.call(this, ev, fn);
+
+ if (ev === 'readable') {
+ // We need to check if there is someone still listening to
+ // readable and reset the state. However this needs to happen
+ // after readable has been emitted but before I/O (nextTick) to
+ // support once('readable', fn) cycles. This means that calling
+ // resume within the same tick will have no
+ // effect.
+ process.nextTick(updateReadableListening, this);
+ }
+
+ return res;
+};
+
+Readable.prototype.removeAllListeners = function (ev) {
+ var res = Stream.prototype.removeAllListeners.apply(this, arguments);
+
+ if (ev === 'readable' || ev === undefined) {
+ // We need to check if there is someone still listening to
+ // readable and reset the state. However this needs to happen
+ // after readable has been emitted but before I/O (nextTick) to
+ // support once('readable', fn) cycles. This means that calling
+ // resume within the same tick will have no
+ // effect.
+ process.nextTick(updateReadableListening, this);
+ }
+
+ return res;
+};
+
+function updateReadableListening(self) {
+ var state = self._readableState;
+ state.readableListening = self.listenerCount('readable') > 0;
+
+ if (state.resumeScheduled && !state.paused) {
+ // flowing needs to be set to true now, otherwise
+ // the upcoming resume will not flow.
+ state.flowing = true; // crude way to check if we should resume
+ } else if (self.listenerCount('data') > 0) {
+ self.resume();
+ }
+}
+
+function nReadingNextTick(self) {
+ debug('readable nexttick read 0');
+ self.read(0);
+} // pause() and resume() are remnants of the legacy readable stream API
+// If the user uses them, then switch into old mode.
+
+
+Readable.prototype.resume = function () {
+ var state = this._readableState;
+
+ if (!state.flowing) {
+ debug('resume'); // we flow only if there is no one listening
+ // for readable, but we still have to call
+ // resume()
+
+ state.flowing = !state.readableListening;
+ resume(this, state);
+ }
+
+ state.paused = false;
+ return this;
+};
+
+function resume(stream, state) {
+ if (!state.resumeScheduled) {
+ state.resumeScheduled = true;
+ process.nextTick(resume_, stream, state);
+ }
+}
+
+function resume_(stream, state) {
+ debug('resume', state.reading);
+
+ if (!state.reading) {
+ stream.read(0);
+ }
+
+ state.resumeScheduled = false;
+ stream.emit('resume');
+ flow(stream);
+ if (state.flowing && !state.reading) stream.read(0);
+}
+
+Readable.prototype.pause = function () {
+ debug('call pause flowing=%j', this._readableState.flowing);
+
+ if (this._readableState.flowing !== false) {
+ debug('pause');
+ this._readableState.flowing = false;
+ this.emit('pause');
+ }
+
+ this._readableState.paused = true;
+ return this;
+};
+
+function flow(stream) {
+ var state = stream._readableState;
+ debug('flow', state.flowing);
+
+ while (state.flowing && stream.read() !== null) {
+ ;
+ }
+} // wrap an old-style stream as the async data source.
+// This is *not* part of the readable stream interface.
+// It is an ugly unfortunate mess of history.
+
+
+Readable.prototype.wrap = function (stream) {
+ var _this = this;
+
+ var state = this._readableState;
+ var paused = false;
+ stream.on('end', function () {
+ debug('wrapped end');
+
+ if (state.decoder && !state.ended) {
+ var chunk = state.decoder.end();
+ if (chunk && chunk.length) _this.push(chunk);
+ }
+
+ _this.push(null);
+ });
+ stream.on('data', function (chunk) {
+ debug('wrapped data');
+ if (state.decoder) chunk = state.decoder.write(chunk); // don't skip over falsy values in objectMode
+
+ if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;
+
+ var ret = _this.push(chunk);
+
+ if (!ret) {
+ paused = true;
+ stream.pause();
+ }
+ }); // proxy all the other methods.
+ // important when wrapping filters and duplexes.
+
+ for (var i in stream) {
+ if (this[i] === undefined && typeof stream[i] === 'function') {
+ this[i] = function methodWrap(method) {
+ return function methodWrapReturnFunction() {
+ return stream[method].apply(stream, arguments);
+ };
+ }(i);
+ }
+ } // proxy certain important events.
+
+
+ for (var n = 0; n < kProxyEvents.length; n++) {
+ stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
+ } // when we try to consume some more bytes, simply unpause the
+ // underlying stream.
+
+
+ this._read = function (n) {
+ debug('wrapped _read', n);
+
+ if (paused) {
+ paused = false;
+ stream.resume();
+ }
+ };
+
+ return this;
+};
+
+if (typeof Symbol === 'function') {
+ Readable.prototype[Symbol.asyncIterator] = function () {
+ if (createReadableStreamAsyncIterator === undefined) {
+ createReadableStreamAsyncIterator = __webpack_require__(3306);
+ }
+
+ return createReadableStreamAsyncIterator(this);
+ };
+}
+
+Object.defineProperty(Readable.prototype, 'readableHighWaterMark', {
+ // making it explicit this property is not enumerable
+ // because otherwise some prototype manipulation in
+ // userland will fail
+ enumerable: false,
+ get: function get() {
+ return this._readableState.highWaterMark;
+ }
+});
+Object.defineProperty(Readable.prototype, 'readableBuffer', {
+ // making it explicit this property is not enumerable
+ // because otherwise some prototype manipulation in
+ // userland will fail
+ enumerable: false,
+ get: function get() {
+ return this._readableState && this._readableState.buffer;
+ }
+});
+Object.defineProperty(Readable.prototype, 'readableFlowing', {
+ // making it explicit this property is not enumerable
+ // because otherwise some prototype manipulation in
+ // userland will fail
+ enumerable: false,
+ get: function get() {
+ return this._readableState.flowing;
+ },
+ set: function set(state) {
+ if (this._readableState) {
+ this._readableState.flowing = state;
+ }
+ }
+}); // exposed for testing purposes only.
+
+Readable._fromList = fromList;
+Object.defineProperty(Readable.prototype, 'readableLength', {
+ // making it explicit this property is not enumerable
+ // because otherwise some prototype manipulation in
+ // userland will fail
+ enumerable: false,
+ get: function get() {
+ return this._readableState.length;
+ }
+}); // Pluck off n bytes from an array of buffers.
+// Length is the combined lengths of all the buffers in the list.
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+
+function fromList(n, state) {
+ // nothing buffered
+ if (state.length === 0) return null;
+ var ret;
+ if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {
+ // read it all, truncate the list
+ if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.first();else ret = state.buffer.concat(state.length);
+ state.buffer.clear();
+ } else {
+ // read part of list
+ ret = state.buffer.consume(n, state.decoder);
+ }
+ return ret;
+}
+
+function endReadable(stream) {
+ var state = stream._readableState;
+ debug('endReadable', state.endEmitted);
+
+ if (!state.endEmitted) {
+ state.ended = true;
+ process.nextTick(endReadableNT, state, stream);
+ }
+}
+
+function endReadableNT(state, stream) {
+ debug('endReadableNT', state.endEmitted, state.length); // Check that we didn't get one last unshift.
+
+ if (!state.endEmitted && state.length === 0) {
+ state.endEmitted = true;
+ stream.readable = false;
+ stream.emit('end');
+
+ if (state.autoDestroy) {
+ // In case of duplex streams we need a way to detect
+ // if the writable side is ready for autoDestroy as well
+ var wState = stream._writableState;
+
+ if (!wState || wState.autoDestroy && wState.finished) {
+ stream.destroy();
+ }
+ }
+ }
+}
+
+if (typeof Symbol === 'function') {
+ Readable.from = function (iterable, opts) {
+ if (from === undefined) {
+ from = __webpack_require__(9082);
+ }
+
+ return from(Readable, iterable, opts);
+ };
+}
+
+function indexOf(xs, x) {
+ for (var i = 0, l = xs.length; i < l; i++) {
+ if (xs[i] === x) return i;
+ }
+
+ return -1;
+}
+
+/***/ }),
+
+/***/ 4415:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+// a transform stream is a readable/writable stream where you do
+// something with the data. Sometimes it's called a "filter",
+// but that's not a great name for it, since that implies a thing where
+// some bits pass through, and others are simply ignored. (That would
+// be a valid example of a transform, of course.)
+//
+// While the output is causally related to the input, it's not a
+// necessarily symmetric or synchronous transformation. For example,
+// a zlib stream might take multiple plain-text writes(), and then
+// emit a single compressed chunk some time in the future.
+//
+// Here's how this works:
+//
+// The Transform stream has all the aspects of the readable and writable
+// stream classes. When you write(chunk), that calls _write(chunk,cb)
+// internally, and returns false if there's a lot of pending writes
+// buffered up. When you call read(), that calls _read(n) until
+// there's enough pending readable data buffered up.
+//
+// In a transform stream, the written data is placed in a buffer. When
+// _read(n) is called, it transforms the queued up data, calling the
+// buffered _write cb's as it consumes chunks. If consuming a single
+// written chunk would result in multiple output chunks, then the first
+// outputted bit calls the readcb, and subsequent chunks just go into
+// the read buffer, and will cause it to emit 'readable' if necessary.
+//
+// This way, back-pressure is actually determined by the reading side,
+// since _read has to be called to start processing a new chunk. However,
+// a pathological inflate type of transform can cause excessive buffering
+// here. For example, imagine a stream where every byte of input is
+// interpreted as an integer from 0-255, and then results in that many
+// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in
+// 1kb of data being output. In this case, you could write a very small
+// amount of input, and end up with a very large amount of output. In
+// such a pathological inflating mechanism, there'd be no way to tell
+// the system to stop doing the transform. A single 4MB write could
+// cause the system to run out of memory.
+//
+// However, even in such a pathological case, only a single written chunk
+// would be consumed, and then the rest would wait (un-transformed) until
+// the results of the previous transformed chunk were consumed.
+
+
+module.exports = Transform;
+
+var _require$codes = __webpack_require__(7214)/* .codes */ .q,
+ ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
+ ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,
+ ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING,
+ ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;
+
+var Duplex = __webpack_require__(1359);
+
+__webpack_require__(4124)(Transform, Duplex);
+
+function afterTransform(er, data) {
+ var ts = this._transformState;
+ ts.transforming = false;
+ var cb = ts.writecb;
+
+ if (cb === null) {
+ return this.emit('error', new ERR_MULTIPLE_CALLBACK());
+ }
+
+ ts.writechunk = null;
+ ts.writecb = null;
+ if (data != null) // single equals check for both `null` and `undefined`
+ this.push(data);
+ cb(er);
+ var rs = this._readableState;
+ rs.reading = false;
+
+ if (rs.needReadable || rs.length < rs.highWaterMark) {
+ this._read(rs.highWaterMark);
+ }
+}
+
+function Transform(options) {
+ if (!(this instanceof Transform)) return new Transform(options);
+ Duplex.call(this, options);
+ this._transformState = {
+ afterTransform: afterTransform.bind(this),
+ needTransform: false,
+ transforming: false,
+ writecb: null,
+ writechunk: null,
+ writeencoding: null
+ }; // start out asking for a readable event once data is transformed.
+
+ this._readableState.needReadable = true; // we have implemented the _read method, and done the other things
+ // that Readable wants before the first _read call, so unset the
+ // sync guard flag.
+
+ this._readableState.sync = false;
+
+ if (options) {
+ if (typeof options.transform === 'function') this._transform = options.transform;
+ if (typeof options.flush === 'function') this._flush = options.flush;
+ } // When the writable side finishes, then flush out anything remaining.
+
+
+ this.on('prefinish', prefinish);
+}
+
+function prefinish() {
+ var _this = this;
+
+ if (typeof this._flush === 'function' && !this._readableState.destroyed) {
+ this._flush(function (er, data) {
+ done(_this, er, data);
+ });
+ } else {
+ done(this, null, null);
+ }
+}
+
+Transform.prototype.push = function (chunk, encoding) {
+ this._transformState.needTransform = false;
+ return Duplex.prototype.push.call(this, chunk, encoding);
+}; // This is the part where you do stuff!
+// override this function in implementation classes.
+// 'chunk' is an input chunk.
+//
+// Call `push(newChunk)` to pass along transformed output
+// to the readable side. You may call 'push' zero or more times.
+//
+// Call `cb(err)` when you are done with this chunk. If you pass
+// an error, then that'll put the hurt on the whole operation. If you
+// never call cb(), then you'll never get another chunk.
+
+
+Transform.prototype._transform = function (chunk, encoding, cb) {
+ cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()'));
+};
+
+Transform.prototype._write = function (chunk, encoding, cb) {
+ var ts = this._transformState;
+ ts.writecb = cb;
+ ts.writechunk = chunk;
+ ts.writeencoding = encoding;
+
+ if (!ts.transforming) {
+ var rs = this._readableState;
+ if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
+ }
+}; // Doesn't matter what the args are here.
+// _transform does all the work.
+// That we got here means that the readable side wants more data.
+
+
+Transform.prototype._read = function (n) {
+ var ts = this._transformState;
+
+ if (ts.writechunk !== null && !ts.transforming) {
+ ts.transforming = true;
+
+ this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
+ } else {
+ // mark that we need a transform, so that any data that comes in
+ // will get processed, now that we've asked for it.
+ ts.needTransform = true;
+ }
+};
+
+Transform.prototype._destroy = function (err, cb) {
+ Duplex.prototype._destroy.call(this, err, function (err2) {
+ cb(err2);
+ });
+};
+
+function done(stream, er, data) {
+ if (er) return stream.emit('error', er);
+ if (data != null) // single equals check for both `null` and `undefined`
+ stream.push(data); // TODO(BridgeAR): Write a test for these two error cases
+ // if there's nothing in the write buffer, then that means
+ // that nothing more will ever be provided
+
+ if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0();
+ if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();
+ return stream.push(null);
+}
+
+/***/ }),
+
+/***/ 6993:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+// A bit simpler than readable streams.
+// Implement an async ._write(chunk, encoding, cb), and it'll handle all
+// the drain event emission and buffering.
+
+
+module.exports = Writable;
+/* */
+
+function WriteReq(chunk, encoding, cb) {
+ this.chunk = chunk;
+ this.encoding = encoding;
+ this.callback = cb;
+ this.next = null;
+} // It seems a linked list but it is not
+// there will be only 2 of these for each stream
+
+
+function CorkedRequest(state) {
+ var _this = this;
+
+ this.next = null;
+ this.entry = null;
+
+ this.finish = function () {
+ onCorkedFinish(_this, state);
+ };
+}
+/* */
+
+/**/
+
+
+var Duplex;
+/**/
+
+Writable.WritableState = WritableState;
+/**/
+
+var internalUtil = {
+ deprecate: __webpack_require__(7127)
+};
+/**/
+
+/**/
+
+var Stream = __webpack_require__(2387);
+/**/
+
+
+var Buffer = __webpack_require__(4293).Buffer;
+
+var OurUint8Array = global.Uint8Array || function () {};
+
+function _uint8ArrayToBuffer(chunk) {
+ return Buffer.from(chunk);
+}
+
+function _isUint8Array(obj) {
+ return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
+}
+
+var destroyImpl = __webpack_require__(7049);
+
+var _require = __webpack_require__(9948),
+ getHighWaterMark = _require.getHighWaterMark;
+
+var _require$codes = __webpack_require__(7214)/* .codes */ .q,
+ ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
+ ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
+ ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,
+ ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE,
+ ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED,
+ ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES,
+ ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END,
+ ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;
+
+var errorOrDestroy = destroyImpl.errorOrDestroy;
+
+__webpack_require__(4124)(Writable, Stream);
+
+function nop() {}
+
+function WritableState(options, stream, isDuplex) {
+ Duplex = Duplex || __webpack_require__(1359);
+ options = options || {}; // Duplex streams are both readable and writable, but share
+ // the same options object.
+ // However, some cases require setting options to different
+ // values for the readable and the writable sides of the duplex stream,
+ // e.g. options.readableObjectMode vs. options.writableObjectMode, etc.
+
+ if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag to indicate whether or not this stream
+ // contains buffers or objects.
+
+ this.objectMode = !!options.objectMode;
+ if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; // the point at which write() starts returning false
+ // Note: 0 is a valid value, means that we always return false if
+ // the entire buffer is not flushed immediately on write()
+
+ this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex); // if _final has been called
+
+ this.finalCalled = false; // drain event flag.
+
+ this.needDrain = false; // at the start of calling end()
+
+ this.ending = false; // when end() has been called, and returned
+
+ this.ended = false; // when 'finish' is emitted
+
+ this.finished = false; // has it been destroyed
+
+ this.destroyed = false; // should we decode strings into buffers before passing to _write?
+ // this is here so that some node-core streams can optimize string
+ // handling at a lower level.
+
+ var noDecode = options.decodeStrings === false;
+ this.decodeStrings = !noDecode; // Crypto is kind of old and crusty. Historically, its default string
+ // encoding is 'binary' so we have to make this configurable.
+ // Everything else in the universe uses 'utf8', though.
+
+ this.defaultEncoding = options.defaultEncoding || 'utf8'; // not an actual buffer we keep track of, but a measurement
+ // of how much we're waiting to get pushed to some underlying
+ // socket or file.
+
+ this.length = 0; // a flag to see when we're in the middle of a write.
+
+ this.writing = false; // when true all writes will be buffered until .uncork() call
+
+ this.corked = 0; // a flag to be able to tell if the onwrite cb is called immediately,
+ // or on a later tick. We set this to true at first, because any
+ // actions that shouldn't happen until "later" should generally also
+ // not happen before the first write call.
+
+ this.sync = true; // a flag to know if we're processing previously buffered items, which
+ // may call the _write() callback in the same tick, so that we don't
+ // end up in an overlapped onwrite situation.
+
+ this.bufferProcessing = false; // the callback that's passed to _write(chunk,cb)
+
+ this.onwrite = function (er) {
+ onwrite(stream, er);
+ }; // the callback that the user supplies to write(chunk,encoding,cb)
+
+
+ this.writecb = null; // the amount that is being written when _write is called.
+
+ this.writelen = 0;
+ this.bufferedRequest = null;
+ this.lastBufferedRequest = null; // number of pending user-supplied write callbacks
+ // this must be 0 before 'finish' can be emitted
+
+ this.pendingcb = 0; // emit prefinish if the only thing we're waiting for is _write cbs
+ // This is relevant for synchronous Transform streams
+
+ this.prefinished = false; // True if the error was already emitted and should not be thrown again
+
+ this.errorEmitted = false; // Should close be emitted on destroy. Defaults to true.
+
+ this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'finish' (and potentially 'end')
+
+ this.autoDestroy = !!options.autoDestroy; // count buffered requests
+
+ this.bufferedRequestCount = 0; // allocate the first CorkedRequest, there is always
+ // one allocated and free to use, and we maintain at most two
+
+ this.corkedRequestsFree = new CorkedRequest(this);
+}
+
+WritableState.prototype.getBuffer = function getBuffer() {
+ var current = this.bufferedRequest;
+ var out = [];
+
+ while (current) {
+ out.push(current);
+ current = current.next;
+ }
+
+ return out;
+};
+
+(function () {
+ try {
+ Object.defineProperty(WritableState.prototype, 'buffer', {
+ get: internalUtil.deprecate(function writableStateBufferGetter() {
+ return this.getBuffer();
+ }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')
+ });
+ } catch (_) {}
+})(); // Test _writableState for inheritance to account for Duplex streams,
+// whose prototype chain only points to Readable.
+
+
+var realHasInstance;
+
+if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {
+ realHasInstance = Function.prototype[Symbol.hasInstance];
+ Object.defineProperty(Writable, Symbol.hasInstance, {
+ value: function value(object) {
+ if (realHasInstance.call(this, object)) return true;
+ if (this !== Writable) return false;
+ return object && object._writableState instanceof WritableState;
+ }
+ });
+} else {
+ realHasInstance = function realHasInstance(object) {
+ return object instanceof this;
+ };
+}
+
+function Writable(options) {
+ Duplex = Duplex || __webpack_require__(1359); // Writable ctor is applied to Duplexes, too.
+ // `realHasInstance` is necessary because using plain `instanceof`
+ // would return false, as no `_writableState` property is attached.
+ // Trying to use the custom `instanceof` for Writable here will also break the
+ // Node.js LazyTransform implementation, which has a non-trivial getter for
+ // `_writableState` that would lead to infinite recursion.
+ // Checking for a Stream.Duplex instance is faster here instead of inside
+ // the WritableState constructor, at least with V8 6.5
+
+ var isDuplex = this instanceof Duplex;
+ if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);
+ this._writableState = new WritableState(options, this, isDuplex); // legacy.
+
+ this.writable = true;
+
+ if (options) {
+ if (typeof options.write === 'function') this._write = options.write;
+ if (typeof options.writev === 'function') this._writev = options.writev;
+ if (typeof options.destroy === 'function') this._destroy = options.destroy;
+ if (typeof options.final === 'function') this._final = options.final;
+ }
+
+ Stream.call(this);
+} // Otherwise people can pipe Writable streams, which is just wrong.
+
+
+Writable.prototype.pipe = function () {
+ errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());
+};
+
+function writeAfterEnd(stream, cb) {
+ var er = new ERR_STREAM_WRITE_AFTER_END(); // TODO: defer error events consistently everywhere, not just the cb
+
+ errorOrDestroy(stream, er);
+ process.nextTick(cb, er);
+} // Checks that a user-supplied chunk is valid, especially for the particular
+// mode the stream is in. Currently this means that `null` is never accepted
+// and undefined/non-string values are only allowed in object mode.
+
+
+function validChunk(stream, state, chunk, cb) {
+ var er;
+
+ if (chunk === null) {
+ er = new ERR_STREAM_NULL_VALUES();
+ } else if (typeof chunk !== 'string' && !state.objectMode) {
+ er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk);
+ }
+
+ if (er) {
+ errorOrDestroy(stream, er);
+ process.nextTick(cb, er);
+ return false;
+ }
+
+ return true;
+}
+
+Writable.prototype.write = function (chunk, encoding, cb) {
+ var state = this._writableState;
+ var ret = false;
+
+ var isBuf = !state.objectMode && _isUint8Array(chunk);
+
+ if (isBuf && !Buffer.isBuffer(chunk)) {
+ chunk = _uint8ArrayToBuffer(chunk);
+ }
+
+ if (typeof encoding === 'function') {
+ cb = encoding;
+ encoding = null;
+ }
+
+ if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;
+ if (typeof cb !== 'function') cb = nop;
+ if (state.ending) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {
+ state.pendingcb++;
+ ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
+ }
+ return ret;
+};
+
+Writable.prototype.cork = function () {
+ this._writableState.corked++;
+};
+
+Writable.prototype.uncork = function () {
+ var state = this._writableState;
+
+ if (state.corked) {
+ state.corked--;
+ if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
+ }
+};
+
+Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
+ // node::ParseEncoding() requires lower case.
+ if (typeof encoding === 'string') encoding = encoding.toLowerCase();
+ if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding);
+ this._writableState.defaultEncoding = encoding;
+ return this;
+};
+
+Object.defineProperty(Writable.prototype, 'writableBuffer', {
+ // making it explicit this property is not enumerable
+ // because otherwise some prototype manipulation in
+ // userland will fail
+ enumerable: false,
+ get: function get() {
+ return this._writableState && this._writableState.getBuffer();
+ }
+});
+
+function decodeChunk(state, chunk, encoding) {
+ if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
+ chunk = Buffer.from(chunk, encoding);
+ }
+
+ return chunk;
+}
+
+Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
+ // making it explicit this property is not enumerable
+ // because otherwise some prototype manipulation in
+ // userland will fail
+ enumerable: false,
+ get: function get() {
+ return this._writableState.highWaterMark;
+ }
+}); // if we're already writing something, then just put this
+// in the queue, and wait our turn. Otherwise, call _write
+// If we return false, then we need a drain event, so set that flag.
+
+function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
+ if (!isBuf) {
+ var newChunk = decodeChunk(state, chunk, encoding);
+
+ if (chunk !== newChunk) {
+ isBuf = true;
+ encoding = 'buffer';
+ chunk = newChunk;
+ }
+ }
+
+ var len = state.objectMode ? 1 : chunk.length;
+ state.length += len;
+ var ret = state.length < state.highWaterMark; // we must ensure that previous needDrain will not be reset to false.
+
+ if (!ret) state.needDrain = true;
+
+ if (state.writing || state.corked) {
+ var last = state.lastBufferedRequest;
+ state.lastBufferedRequest = {
+ chunk: chunk,
+ encoding: encoding,
+ isBuf: isBuf,
+ callback: cb,
+ next: null
+ };
+
+ if (last) {
+ last.next = state.lastBufferedRequest;
+ } else {
+ state.bufferedRequest = state.lastBufferedRequest;
+ }
+
+ state.bufferedRequestCount += 1;
+ } else {
+ doWrite(stream, state, false, len, chunk, encoding, cb);
+ }
+
+ return ret;
+}
+
+function doWrite(stream, state, writev, len, chunk, encoding, cb) {
+ state.writelen = len;
+ state.writecb = cb;
+ state.writing = true;
+ state.sync = true;
+ if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'));else if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);
+ state.sync = false;
+}
+
+function onwriteError(stream, state, sync, er, cb) {
+ --state.pendingcb;
+
+ if (sync) {
+ // defer the callback if we are being called synchronously
+ // to avoid piling up things on the stack
+ process.nextTick(cb, er); // this can emit finish, and it will always happen
+ // after error
+
+ process.nextTick(finishMaybe, stream, state);
+ stream._writableState.errorEmitted = true;
+ errorOrDestroy(stream, er);
+ } else {
+ // the caller expect this to happen before if
+ // it is async
+ cb(er);
+ stream._writableState.errorEmitted = true;
+ errorOrDestroy(stream, er); // this can emit finish, but finish must
+ // always follow error
+
+ finishMaybe(stream, state);
+ }
+}
+
+function onwriteStateUpdate(state) {
+ state.writing = false;
+ state.writecb = null;
+ state.length -= state.writelen;
+ state.writelen = 0;
+}
+
+function onwrite(stream, er) {
+ var state = stream._writableState;
+ var sync = state.sync;
+ var cb = state.writecb;
+ if (typeof cb !== 'function') throw new ERR_MULTIPLE_CALLBACK();
+ onwriteStateUpdate(state);
+ if (er) onwriteError(stream, state, sync, er, cb);else {
+ // Check if we're actually ready to finish, but don't emit yet
+ var finished = needFinish(state) || stream.destroyed;
+
+ if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
+ clearBuffer(stream, state);
+ }
+
+ if (sync) {
+ process.nextTick(afterWrite, stream, state, finished, cb);
+ } else {
+ afterWrite(stream, state, finished, cb);
+ }
+ }
+}
+
+function afterWrite(stream, state, finished, cb) {
+ if (!finished) onwriteDrain(stream, state);
+ state.pendingcb--;
+ cb();
+ finishMaybe(stream, state);
+} // Must force callback to be called on nextTick, so that we don't
+// emit 'drain' before the write() consumer gets the 'false' return
+// value, and has a chance to attach a 'drain' listener.
+
+
+function onwriteDrain(stream, state) {
+ if (state.length === 0 && state.needDrain) {
+ state.needDrain = false;
+ stream.emit('drain');
+ }
+} // if there's something in the buffer waiting, then process it
+
+
+function clearBuffer(stream, state) {
+ state.bufferProcessing = true;
+ var entry = state.bufferedRequest;
+
+ if (stream._writev && entry && entry.next) {
+ // Fast case, write everything using _writev()
+ var l = state.bufferedRequestCount;
+ var buffer = new Array(l);
+ var holder = state.corkedRequestsFree;
+ holder.entry = entry;
+ var count = 0;
+ var allBuffers = true;
+
+ while (entry) {
+ buffer[count] = entry;
+ if (!entry.isBuf) allBuffers = false;
+ entry = entry.next;
+ count += 1;
+ }
+
+ buffer.allBuffers = allBuffers;
+ doWrite(stream, state, true, state.length, buffer, '', holder.finish); // doWrite is almost always async, defer these to save a bit of time
+ // as the hot path ends with doWrite
+
+ state.pendingcb++;
+ state.lastBufferedRequest = null;
+
+ if (holder.next) {
+ state.corkedRequestsFree = holder.next;
+ holder.next = null;
+ } else {
+ state.corkedRequestsFree = new CorkedRequest(state);
+ }
+
+ state.bufferedRequestCount = 0;
+ } else {
+ // Slow case, write chunks one-by-one
+ while (entry) {
+ var chunk = entry.chunk;
+ var encoding = entry.encoding;
+ var cb = entry.callback;
+ var len = state.objectMode ? 1 : chunk.length;
+ doWrite(stream, state, false, len, chunk, encoding, cb);
+ entry = entry.next;
+ state.bufferedRequestCount--; // if we didn't call the onwrite immediately, then
+ // it means that we need to wait until it does.
+ // also, that means that the chunk and cb are currently
+ // being processed, so move the buffer counter past them.
+
+ if (state.writing) {
+ break;
+ }
+ }
+
+ if (entry === null) state.lastBufferedRequest = null;
+ }
+
+ state.bufferedRequest = entry;
+ state.bufferProcessing = false;
+}
+
+Writable.prototype._write = function (chunk, encoding, cb) {
+ cb(new ERR_METHOD_NOT_IMPLEMENTED('_write()'));
+};
+
+Writable.prototype._writev = null;
+
+Writable.prototype.end = function (chunk, encoding, cb) {
+ var state = this._writableState;
+
+ if (typeof chunk === 'function') {
+ cb = chunk;
+ chunk = null;
+ encoding = null;
+ } else if (typeof encoding === 'function') {
+ cb = encoding;
+ encoding = null;
+ }
+
+ if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); // .end() fully uncorks
+
+ if (state.corked) {
+ state.corked = 1;
+ this.uncork();
+ } // ignore unnecessary end() calls.
+
+
+ if (!state.ending) endWritable(this, state, cb);
+ return this;
+};
+
+Object.defineProperty(Writable.prototype, 'writableLength', {
+ // making it explicit this property is not enumerable
+ // because otherwise some prototype manipulation in
+ // userland will fail
+ enumerable: false,
+ get: function get() {
+ return this._writableState.length;
+ }
+});
+
+function needFinish(state) {
+ return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
+}
+
+function callFinal(stream, state) {
+ stream._final(function (err) {
+ state.pendingcb--;
+
+ if (err) {
+ errorOrDestroy(stream, err);
+ }
+
+ state.prefinished = true;
+ stream.emit('prefinish');
+ finishMaybe(stream, state);
+ });
+}
+
+function prefinish(stream, state) {
+ if (!state.prefinished && !state.finalCalled) {
+ if (typeof stream._final === 'function' && !state.destroyed) {
+ state.pendingcb++;
+ state.finalCalled = true;
+ process.nextTick(callFinal, stream, state);
+ } else {
+ state.prefinished = true;
+ stream.emit('prefinish');
+ }
+ }
+}
+
+function finishMaybe(stream, state) {
+ var need = needFinish(state);
+
+ if (need) {
+ prefinish(stream, state);
+
+ if (state.pendingcb === 0) {
+ state.finished = true;
+ stream.emit('finish');
+
+ if (state.autoDestroy) {
+ // In case of duplex streams we need a way to detect
+ // if the readable side is ready for autoDestroy as well
+ var rState = stream._readableState;
+
+ if (!rState || rState.autoDestroy && rState.endEmitted) {
+ stream.destroy();
+ }
+ }
+ }
+ }
+
+ return need;
+}
+
+function endWritable(stream, state, cb) {
+ state.ending = true;
+ finishMaybe(stream, state);
+
+ if (cb) {
+ if (state.finished) process.nextTick(cb);else stream.once('finish', cb);
+ }
+
+ state.ended = true;
+ stream.writable = false;
+}
+
+function onCorkedFinish(corkReq, state, err) {
+ var entry = corkReq.entry;
+ corkReq.entry = null;
+
+ while (entry) {
+ var cb = entry.callback;
+ state.pendingcb--;
+ cb(err);
+ entry = entry.next;
+ } // reuse the free corkReq.
+
+
+ state.corkedRequestsFree.next = corkReq;
+}
+
+Object.defineProperty(Writable.prototype, 'destroyed', {
+ // making it explicit this property is not enumerable
+ // because otherwise some prototype manipulation in
+ // userland will fail
+ enumerable: false,
+ get: function get() {
+ if (this._writableState === undefined) {
+ return false;
+ }
+
+ return this._writableState.destroyed;
+ },
+ set: function set(value) {
+ // we ignore the value if the stream
+ // has not been initialized yet
+ if (!this._writableState) {
+ return;
+ } // backward compatibility, the user is explicitly
+ // managing destroyed
+
+
+ this._writableState.destroyed = value;
+ }
+});
+Writable.prototype.destroy = destroyImpl.destroy;
+Writable.prototype._undestroy = destroyImpl.undestroy;
+
+Writable.prototype._destroy = function (err, cb) {
+ cb(err);
+};
+
+/***/ }),
+
+/***/ 3306:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+var _Object$setPrototypeO;
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var finished = __webpack_require__(6080);
+
+var kLastResolve = Symbol('lastResolve');
+var kLastReject = Symbol('lastReject');
+var kError = Symbol('error');
+var kEnded = Symbol('ended');
+var kLastPromise = Symbol('lastPromise');
+var kHandlePromise = Symbol('handlePromise');
+var kStream = Symbol('stream');
+
+function createIterResult(value, done) {
+ return {
+ value: value,
+ done: done
+ };
+}
+
+function readAndResolve(iter) {
+ var resolve = iter[kLastResolve];
+
+ if (resolve !== null) {
+ var data = iter[kStream].read(); // we defer if data is null
+ // we can be expecting either 'end' or
+ // 'error'
+
+ if (data !== null) {
+ iter[kLastPromise] = null;
+ iter[kLastResolve] = null;
+ iter[kLastReject] = null;
+ resolve(createIterResult(data, false));
+ }
+ }
+}
+
+function onReadable(iter) {
+ // we wait for the next tick, because it might
+ // emit an error with process.nextTick
+ process.nextTick(readAndResolve, iter);
+}
+
+function wrapForNext(lastPromise, iter) {
+ return function (resolve, reject) {
+ lastPromise.then(function () {
+ if (iter[kEnded]) {
+ resolve(createIterResult(undefined, true));
+ return;
+ }
+
+ iter[kHandlePromise](resolve, reject);
+ }, reject);
+ };
+}
+
+var AsyncIteratorPrototype = Object.getPrototypeOf(function () {});
+var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {
+ get stream() {
+ return this[kStream];
+ },
+
+ next: function next() {
+ var _this = this;
+
+ // if we have detected an error in the meanwhile
+ // reject straight away
+ var error = this[kError];
+
+ if (error !== null) {
+ return Promise.reject(error);
+ }
+
+ if (this[kEnded]) {
+ return Promise.resolve(createIterResult(undefined, true));
+ }
+
+ if (this[kStream].destroyed) {
+ // We need to defer via nextTick because if .destroy(err) is
+ // called, the error will be emitted via nextTick, and
+ // we cannot guarantee that there is no error lingering around
+ // waiting to be emitted.
+ return new Promise(function (resolve, reject) {
+ process.nextTick(function () {
+ if (_this[kError]) {
+ reject(_this[kError]);
+ } else {
+ resolve(createIterResult(undefined, true));
+ }
+ });
+ });
+ } // if we have multiple next() calls
+ // we will wait for the previous Promise to finish
+ // this logic is optimized to support for await loops,
+ // where next() is only called once at a time
+
+
+ var lastPromise = this[kLastPromise];
+ var promise;
+
+ if (lastPromise) {
+ promise = new Promise(wrapForNext(lastPromise, this));
+ } else {
+ // fast path needed to support multiple this.push()
+ // without triggering the next() queue
+ var data = this[kStream].read();
+
+ if (data !== null) {
+ return Promise.resolve(createIterResult(data, false));
+ }
+
+ promise = new Promise(this[kHandlePromise]);
+ }
+
+ this[kLastPromise] = promise;
+ return promise;
+ }
+}, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function () {
+ return this;
+}), _defineProperty(_Object$setPrototypeO, "return", function _return() {
+ var _this2 = this;
+
+ // destroy(err, cb) is a private API
+ // we can guarantee we have that here, because we control the
+ // Readable class this is attached to
+ return new Promise(function (resolve, reject) {
+ _this2[kStream].destroy(null, function (err) {
+ if (err) {
+ reject(err);
+ return;
+ }
+
+ resolve(createIterResult(undefined, true));
+ });
+ });
+}), _Object$setPrototypeO), AsyncIteratorPrototype);
+
+var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) {
+ var _Object$create;
+
+ var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {
+ value: stream,
+ writable: true
+ }), _defineProperty(_Object$create, kLastResolve, {
+ value: null,
+ writable: true
+ }), _defineProperty(_Object$create, kLastReject, {
+ value: null,
+ writable: true
+ }), _defineProperty(_Object$create, kError, {
+ value: null,
+ writable: true
+ }), _defineProperty(_Object$create, kEnded, {
+ value: stream._readableState.endEmitted,
+ writable: true
+ }), _defineProperty(_Object$create, kHandlePromise, {
+ value: function value(resolve, reject) {
+ var data = iterator[kStream].read();
+
+ if (data) {
+ iterator[kLastPromise] = null;
+ iterator[kLastResolve] = null;
+ iterator[kLastReject] = null;
+ resolve(createIterResult(data, false));
+ } else {
+ iterator[kLastResolve] = resolve;
+ iterator[kLastReject] = reject;
+ }
+ },
+ writable: true
+ }), _Object$create));
+ iterator[kLastPromise] = null;
+ finished(stream, function (err) {
+ if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {
+ var reject = iterator[kLastReject]; // reject if we are waiting for data in the Promise
+ // returned by next() and store the error
+
+ if (reject !== null) {
+ iterator[kLastPromise] = null;
+ iterator[kLastResolve] = null;
+ iterator[kLastReject] = null;
+ reject(err);
+ }
+
+ iterator[kError] = err;
+ return;
+ }
+
+ var resolve = iterator[kLastResolve];
+
+ if (resolve !== null) {
+ iterator[kLastPromise] = null;
+ iterator[kLastResolve] = null;
+ iterator[kLastReject] = null;
+ resolve(createIterResult(undefined, true));
+ }
+
+ iterator[kEnded] = true;
+ });
+ stream.on('readable', onReadable.bind(null, iterator));
+ return iterator;
+};
+
+module.exports = createReadableStreamAsyncIterator;
+
+/***/ }),
+
+/***/ 2746:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var _require = __webpack_require__(4293),
+ Buffer = _require.Buffer;
+
+var _require2 = __webpack_require__(1669),
+ inspect = _require2.inspect;
+
+var custom = inspect && inspect.custom || 'inspect';
+
+function copyBuffer(src, target, offset) {
+ Buffer.prototype.copy.call(src, target, offset);
+}
+
+module.exports =
+/*#__PURE__*/
+function () {
+ function BufferList() {
+ _classCallCheck(this, BufferList);
+
+ this.head = null;
+ this.tail = null;
+ this.length = 0;
+ }
+
+ _createClass(BufferList, [{
+ key: "push",
+ value: function push(v) {
+ var entry = {
+ data: v,
+ next: null
+ };
+ if (this.length > 0) this.tail.next = entry;else this.head = entry;
+ this.tail = entry;
+ ++this.length;
+ }
+ }, {
+ key: "unshift",
+ value: function unshift(v) {
+ var entry = {
+ data: v,
+ next: this.head
+ };
+ if (this.length === 0) this.tail = entry;
+ this.head = entry;
+ ++this.length;
+ }
+ }, {
+ key: "shift",
+ value: function shift() {
+ if (this.length === 0) return;
+ var ret = this.head.data;
+ if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;
+ --this.length;
+ return ret;
+ }
+ }, {
+ key: "clear",
+ value: function clear() {
+ this.head = this.tail = null;
+ this.length = 0;
+ }
+ }, {
+ key: "join",
+ value: function join(s) {
+ if (this.length === 0) return '';
+ var p = this.head;
+ var ret = '' + p.data;
+
+ while (p = p.next) {
+ ret += s + p.data;
+ }
+
+ return ret;
+ }
+ }, {
+ key: "concat",
+ value: function concat(n) {
+ if (this.length === 0) return Buffer.alloc(0);
+ var ret = Buffer.allocUnsafe(n >>> 0);
+ var p = this.head;
+ var i = 0;
+
+ while (p) {
+ copyBuffer(p.data, ret, i);
+ i += p.data.length;
+ p = p.next;
+ }
+
+ return ret;
+ } // Consumes a specified amount of bytes or characters from the buffered data.
+
+ }, {
+ key: "consume",
+ value: function consume(n, hasStrings) {
+ var ret;
+
+ if (n < this.head.data.length) {
+ // `slice` is the same for buffers and strings.
+ ret = this.head.data.slice(0, n);
+ this.head.data = this.head.data.slice(n);
+ } else if (n === this.head.data.length) {
+ // First chunk is a perfect match.
+ ret = this.shift();
+ } else {
+ // Result spans more than one buffer.
+ ret = hasStrings ? this._getString(n) : this._getBuffer(n);
+ }
+
+ return ret;
+ }
+ }, {
+ key: "first",
+ value: function first() {
+ return this.head.data;
+ } // Consumes a specified amount of characters from the buffered data.
+
+ }, {
+ key: "_getString",
+ value: function _getString(n) {
+ var p = this.head;
+ var c = 1;
+ var ret = p.data;
+ n -= ret.length;
+
+ while (p = p.next) {
+ var str = p.data;
+ var nb = n > str.length ? str.length : n;
+ if (nb === str.length) ret += str;else ret += str.slice(0, n);
+ n -= nb;
+
+ if (n === 0) {
+ if (nb === str.length) {
+ ++c;
+ if (p.next) this.head = p.next;else this.head = this.tail = null;
+ } else {
+ this.head = p;
+ p.data = str.slice(nb);
+ }
+
+ break;
+ }
+
+ ++c;
+ }
+
+ this.length -= c;
+ return ret;
+ } // Consumes a specified amount of bytes from the buffered data.
+
+ }, {
+ key: "_getBuffer",
+ value: function _getBuffer(n) {
+ var ret = Buffer.allocUnsafe(n);
+ var p = this.head;
+ var c = 1;
+ p.data.copy(ret);
+ n -= p.data.length;
+
+ while (p = p.next) {
+ var buf = p.data;
+ var nb = n > buf.length ? buf.length : n;
+ buf.copy(ret, ret.length - n, 0, nb);
+ n -= nb;
+
+ if (n === 0) {
+ if (nb === buf.length) {
+ ++c;
+ if (p.next) this.head = p.next;else this.head = this.tail = null;
+ } else {
+ this.head = p;
+ p.data = buf.slice(nb);
+ }
+
+ break;
+ }
+
+ ++c;
+ }
+
+ this.length -= c;
+ return ret;
+ } // Make sure the linked list only shows the minimal necessary information.
+
+ }, {
+ key: custom,
+ value: function value(_, options) {
+ return inspect(this, _objectSpread({}, options, {
+ // Only inspect one level.
+ depth: 0,
+ // It should not recurse.
+ customInspect: false
+ }));
+ }
+ }]);
+
+ return BufferList;
+}();
+
+/***/ }),
+
+/***/ 7049:
+/***/ ((module) => {
+
+"use strict";
+ // undocumented cb() API, needed for core, not for public API
+
+function destroy(err, cb) {
+ var _this = this;
+
+ var readableDestroyed = this._readableState && this._readableState.destroyed;
+ var writableDestroyed = this._writableState && this._writableState.destroyed;
+
+ if (readableDestroyed || writableDestroyed) {
+ if (cb) {
+ cb(err);
+ } else if (err) {
+ if (!this._writableState) {
+ process.nextTick(emitErrorNT, this, err);
+ } else if (!this._writableState.errorEmitted) {
+ this._writableState.errorEmitted = true;
+ process.nextTick(emitErrorNT, this, err);
+ }
+ }
+
+ return this;
+ } // we set destroyed to true before firing error callbacks in order
+ // to make it re-entrance safe in case destroy() is called within callbacks
+
+
+ if (this._readableState) {
+ this._readableState.destroyed = true;
+ } // if this is a duplex stream mark the writable part as destroyed as well
+
+
+ if (this._writableState) {
+ this._writableState.destroyed = true;
+ }
+
+ this._destroy(err || null, function (err) {
+ if (!cb && err) {
+ if (!_this._writableState) {
+ process.nextTick(emitErrorAndCloseNT, _this, err);
+ } else if (!_this._writableState.errorEmitted) {
+ _this._writableState.errorEmitted = true;
+ process.nextTick(emitErrorAndCloseNT, _this, err);
+ } else {
+ process.nextTick(emitCloseNT, _this);
+ }
+ } else if (cb) {
+ process.nextTick(emitCloseNT, _this);
+ cb(err);
+ } else {
+ process.nextTick(emitCloseNT, _this);
+ }
+ });
+
+ return this;
+}
+
+function emitErrorAndCloseNT(self, err) {
+ emitErrorNT(self, err);
+ emitCloseNT(self);
+}
+
+function emitCloseNT(self) {
+ if (self._writableState && !self._writableState.emitClose) return;
+ if (self._readableState && !self._readableState.emitClose) return;
+ self.emit('close');
+}
+
+function undestroy() {
+ if (this._readableState) {
+ this._readableState.destroyed = false;
+ this._readableState.reading = false;
+ this._readableState.ended = false;
+ this._readableState.endEmitted = false;
+ }
+
+ if (this._writableState) {
+ this._writableState.destroyed = false;
+ this._writableState.ended = false;
+ this._writableState.ending = false;
+ this._writableState.finalCalled = false;
+ this._writableState.prefinished = false;
+ this._writableState.finished = false;
+ this._writableState.errorEmitted = false;
+ }
+}
+
+function emitErrorNT(self, err) {
+ self.emit('error', err);
+}
+
+function errorOrDestroy(stream, err) {
+ // We have tests that rely on errors being emitted
+ // in the same tick, so changing this is semver major.
+ // For now when you opt-in to autoDestroy we allow
+ // the error to be emitted nextTick. In a future
+ // semver major update we should change the default to this.
+ var rState = stream._readableState;
+ var wState = stream._writableState;
+ if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err);
+}
+
+module.exports = {
+ destroy: destroy,
+ undestroy: undestroy,
+ errorOrDestroy: errorOrDestroy
+};
+
+/***/ }),
+
+/***/ 6080:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+// Ported from https://github.com/mafintosh/end-of-stream with
+// permission from the author, Mathias Buus (@mafintosh).
+
+
+var ERR_STREAM_PREMATURE_CLOSE = __webpack_require__(7214)/* .codes.ERR_STREAM_PREMATURE_CLOSE */ .q.ERR_STREAM_PREMATURE_CLOSE;
+
+function once(callback) {
+ var called = false;
+ return function () {
+ if (called) return;
+ called = true;
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ callback.apply(this, args);
+ };
+}
+
+function noop() {}
+
+function isRequest(stream) {
+ return stream.setHeader && typeof stream.abort === 'function';
+}
+
+function eos(stream, opts, callback) {
+ if (typeof opts === 'function') return eos(stream, null, opts);
+ if (!opts) opts = {};
+ callback = once(callback || noop);
+ var readable = opts.readable || opts.readable !== false && stream.readable;
+ var writable = opts.writable || opts.writable !== false && stream.writable;
+
+ var onlegacyfinish = function onlegacyfinish() {
+ if (!stream.writable) onfinish();
+ };
+
+ var writableEnded = stream._writableState && stream._writableState.finished;
+
+ var onfinish = function onfinish() {
+ writable = false;
+ writableEnded = true;
+ if (!readable) callback.call(stream);
+ };
+
+ var readableEnded = stream._readableState && stream._readableState.endEmitted;
+
+ var onend = function onend() {
+ readable = false;
+ readableEnded = true;
+ if (!writable) callback.call(stream);
+ };
+
+ var onerror = function onerror(err) {
+ callback.call(stream, err);
+ };
+
+ var onclose = function onclose() {
+ var err;
+
+ if (readable && !readableEnded) {
+ if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
+ return callback.call(stream, err);
+ }
+
+ if (writable && !writableEnded) {
+ if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
+ return callback.call(stream, err);
+ }
+ };
+
+ var onrequest = function onrequest() {
+ stream.req.on('finish', onfinish);
+ };
+
+ if (isRequest(stream)) {
+ stream.on('complete', onfinish);
+ stream.on('abort', onclose);
+ if (stream.req) onrequest();else stream.on('request', onrequest);
+ } else if (writable && !stream._writableState) {
+ // legacy streams
+ stream.on('end', onlegacyfinish);
+ stream.on('close', onlegacyfinish);
+ }
+
+ stream.on('end', onend);
+ stream.on('finish', onfinish);
+ if (opts.error !== false) stream.on('error', onerror);
+ stream.on('close', onclose);
+ return function () {
+ stream.removeListener('complete', onfinish);
+ stream.removeListener('abort', onclose);
+ stream.removeListener('request', onrequest);
+ if (stream.req) stream.req.removeListener('finish', onfinish);
+ stream.removeListener('end', onlegacyfinish);
+ stream.removeListener('close', onlegacyfinish);
+ stream.removeListener('finish', onfinish);
+ stream.removeListener('end', onend);
+ stream.removeListener('error', onerror);
+ stream.removeListener('close', onclose);
+ };
+}
+
+module.exports = eos;
+
+/***/ }),
+
+/***/ 9082:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var ERR_INVALID_ARG_TYPE = __webpack_require__(7214)/* .codes.ERR_INVALID_ARG_TYPE */ .q.ERR_INVALID_ARG_TYPE;
+
+function from(Readable, iterable, opts) {
+ var iterator;
+
+ if (iterable && typeof iterable.next === 'function') {
+ iterator = iterable;
+ } else if (iterable && iterable[Symbol.asyncIterator]) iterator = iterable[Symbol.asyncIterator]();else if (iterable && iterable[Symbol.iterator]) iterator = iterable[Symbol.iterator]();else throw new ERR_INVALID_ARG_TYPE('iterable', ['Iterable'], iterable);
+
+ var readable = new Readable(_objectSpread({
+ objectMode: true
+ }, opts)); // Reading boolean to protect against _read
+ // being called before last iteration completion.
+
+ var reading = false;
+
+ readable._read = function () {
+ if (!reading) {
+ reading = true;
+ next();
+ }
+ };
+
+ function next() {
+ return _next2.apply(this, arguments);
+ }
+
+ function _next2() {
+ _next2 = _asyncToGenerator(function* () {
+ try {
+ var _ref = yield iterator.next(),
+ value = _ref.value,
+ done = _ref.done;
+
+ if (done) {
+ readable.push(null);
+ } else if (readable.push((yield value))) {
+ next();
+ } else {
+ reading = false;
+ }
+ } catch (err) {
+ readable.destroy(err);
+ }
+ });
+ return _next2.apply(this, arguments);
+ }
+
+ return readable;
+}
+
+module.exports = from;
+
+/***/ }),
+
+/***/ 6989:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+// Ported from https://github.com/mafintosh/pump with
+// permission from the author, Mathias Buus (@mafintosh).
+
+
+var eos;
+
+function once(callback) {
+ var called = false;
+ return function () {
+ if (called) return;
+ called = true;
+ callback.apply(void 0, arguments);
+ };
+}
+
+var _require$codes = __webpack_require__(7214)/* .codes */ .q,
+ ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,
+ ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
+
+function noop(err) {
+ // Rethrow the error if it exists to avoid swallowing it
+ if (err) throw err;
+}
+
+function isRequest(stream) {
+ return stream.setHeader && typeof stream.abort === 'function';
+}
+
+function destroyer(stream, reading, writing, callback) {
+ callback = once(callback);
+ var closed = false;
+ stream.on('close', function () {
+ closed = true;
+ });
+ if (eos === undefined) eos = __webpack_require__(6080);
+ eos(stream, {
+ readable: reading,
+ writable: writing
+ }, function (err) {
+ if (err) return callback(err);
+ closed = true;
+ callback();
+ });
+ var destroyed = false;
+ return function (err) {
+ if (closed) return;
+ if (destroyed) return;
+ destroyed = true; // request.destroy just do .end - .abort is what we want
+
+ if (isRequest(stream)) return stream.abort();
+ if (typeof stream.destroy === 'function') return stream.destroy();
+ callback(err || new ERR_STREAM_DESTROYED('pipe'));
+ };
+}
+
+function call(fn) {
+ fn();
+}
+
+function pipe(from, to) {
+ return from.pipe(to);
+}
+
+function popCallback(streams) {
+ if (!streams.length) return noop;
+ if (typeof streams[streams.length - 1] !== 'function') return noop;
+ return streams.pop();
+}
+
+function pipeline() {
+ for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {
+ streams[_key] = arguments[_key];
+ }
+
+ var callback = popCallback(streams);
+ if (Array.isArray(streams[0])) streams = streams[0];
+
+ if (streams.length < 2) {
+ throw new ERR_MISSING_ARGS('streams');
+ }
+
+ var error;
+ var destroys = streams.map(function (stream, i) {
+ var reading = i < streams.length - 1;
+ var writing = i > 0;
+ return destroyer(stream, reading, writing, function (err) {
+ if (!error) error = err;
+ if (err) destroys.forEach(call);
+ if (reading) return;
+ destroys.forEach(call);
+ callback(error);
+ });
+ });
+ return streams.reduce(pipe);
+}
+
+module.exports = pipeline;
+
+/***/ }),
+
+/***/ 9948:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+var ERR_INVALID_OPT_VALUE = __webpack_require__(7214)/* .codes.ERR_INVALID_OPT_VALUE */ .q.ERR_INVALID_OPT_VALUE;
+
+function highWaterMarkFrom(options, isDuplex, duplexKey) {
+ return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
+}
+
+function getHighWaterMark(state, options, duplexKey, isDuplex) {
+ var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
+
+ if (hwm != null) {
+ if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {
+ var name = isDuplex ? duplexKey : 'highWaterMark';
+ throw new ERR_INVALID_OPT_VALUE(name, hwm);
+ }
+
+ return Math.floor(hwm);
+ } // Default value
+
+
+ return state.objectMode ? 16 : 16 * 1024;
+}
+
+module.exports = {
+ getHighWaterMark: getHighWaterMark
+};
+
+/***/ }),
+
+/***/ 2387:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+module.exports = __webpack_require__(2413);
+
+
+/***/ }),
+
+/***/ 1642:
+/***/ ((module, exports, __webpack_require__) => {
+
+var Stream = __webpack_require__(2413);
+if (process.env.READABLE_STREAM === 'disable' && Stream) {
+ module.exports = Stream.Readable;
+ Object.assign(module.exports, Stream);
+ module.exports.Stream = Stream;
+} else {
+ exports = module.exports = __webpack_require__(1433);
+ exports.Stream = Stream || exports;
+ exports.Readable = exports;
+ exports.Writable = __webpack_require__(6993);
+ exports.Duplex = __webpack_require__(1359);
+ exports.Transform = __webpack_require__(4415);
+ exports.PassThrough = __webpack_require__(1542);
+ exports.finished = __webpack_require__(6080);
+ exports.pipeline = __webpack_require__(6989);
+}
+
+
+/***/ }),
+
+/***/ 1867:
+/***/ ((module, exports, __webpack_require__) => {
+
+/*! safe-buffer. MIT License. Feross Aboukhadijeh */
+/* eslint-disable node/no-deprecated-api */
+var buffer = __webpack_require__(4293)
+var Buffer = buffer.Buffer
+
+// alternative to using Object.keys for old browsers
+function copyProps (src, dst) {
+ for (var key in src) {
+ dst[key] = src[key]
+ }
+}
+if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
+ module.exports = buffer
+} else {
+ // Copy properties from require('buffer')
+ copyProps(buffer, exports)
+ exports.Buffer = SafeBuffer
+}
+
+function SafeBuffer (arg, encodingOrOffset, length) {
+ return Buffer(arg, encodingOrOffset, length)
+}
+
+SafeBuffer.prototype = Object.create(Buffer.prototype)
+
+// Copy static methods from Buffer
+copyProps(Buffer, SafeBuffer)
+
+SafeBuffer.from = function (arg, encodingOrOffset, length) {
+ if (typeof arg === 'number') {
+ throw new TypeError('Argument must not be a number')
+ }
+ return Buffer(arg, encodingOrOffset, length)
+}
+
+SafeBuffer.alloc = function (size, fill, encoding) {
+ if (typeof size !== 'number') {
+ throw new TypeError('Argument must be a number')
+ }
+ var buf = Buffer(size)
+ if (fill !== undefined) {
+ if (typeof encoding === 'string') {
+ buf.fill(fill, encoding)
+ } else {
+ buf.fill(fill)
+ }
+ } else {
+ buf.fill(0)
+ }
+ return buf
+}
+
+SafeBuffer.allocUnsafe = function (size) {
+ if (typeof size !== 'number') {
+ throw new TypeError('Argument must be a number')
+ }
+ return Buffer(size)
+}
+
+SafeBuffer.allocUnsafeSlow = function (size) {
+ if (typeof size !== 'number') {
+ throw new TypeError('Argument must be a number')
+ }
+ return buffer.SlowBuffer(size)
+}
+
+
+/***/ }),
+
+/***/ 4841:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+
+/**/
+
+var Buffer = __webpack_require__(1867).Buffer;
+/**/
+
+var isEncoding = Buffer.isEncoding || function (encoding) {
+ encoding = '' + encoding;
+ switch (encoding && encoding.toLowerCase()) {
+ case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':
+ return true;
+ default:
+ return false;
+ }
+};
+
+function _normalizeEncoding(enc) {
+ if (!enc) return 'utf8';
+ var retried;
+ while (true) {
+ switch (enc) {
+ case 'utf8':
+ case 'utf-8':
+ return 'utf8';
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return 'utf16le';
+ case 'latin1':
+ case 'binary':
+ return 'latin1';
+ case 'base64':
+ case 'ascii':
+ case 'hex':
+ return enc;
+ default:
+ if (retried) return; // undefined
+ enc = ('' + enc).toLowerCase();
+ retried = true;
+ }
+ }
+};
+
+// Do not cache `Buffer.isEncoding` when checking encoding names as some
+// modules monkey-patch it to support additional encodings
+function normalizeEncoding(enc) {
+ var nenc = _normalizeEncoding(enc);
+ if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);
+ return nenc || enc;
+}
+
+// StringDecoder provides an interface for efficiently splitting a series of
+// buffers into a series of JS strings without breaking apart multi-byte
+// characters.
+exports.s = StringDecoder;
+function StringDecoder(encoding) {
+ this.encoding = normalizeEncoding(encoding);
+ var nb;
+ switch (this.encoding) {
+ case 'utf16le':
+ this.text = utf16Text;
+ this.end = utf16End;
+ nb = 4;
+ break;
+ case 'utf8':
+ this.fillLast = utf8FillLast;
+ nb = 4;
+ break;
+ case 'base64':
+ this.text = base64Text;
+ this.end = base64End;
+ nb = 3;
+ break;
+ default:
+ this.write = simpleWrite;
+ this.end = simpleEnd;
+ return;
+ }
+ this.lastNeed = 0;
+ this.lastTotal = 0;
+ this.lastChar = Buffer.allocUnsafe(nb);
+}
+
+StringDecoder.prototype.write = function (buf) {
+ if (buf.length === 0) return '';
+ var r;
+ var i;
+ if (this.lastNeed) {
+ r = this.fillLast(buf);
+ if (r === undefined) return '';
+ i = this.lastNeed;
+ this.lastNeed = 0;
+ } else {
+ i = 0;
+ }
+ if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
+ return r || '';
+};
+
+StringDecoder.prototype.end = utf8End;
+
+// Returns only complete characters in a Buffer
+StringDecoder.prototype.text = utf8Text;
+
+// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer
+StringDecoder.prototype.fillLast = function (buf) {
+ if (this.lastNeed <= buf.length) {
+ buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
+ return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+ }
+ buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
+ this.lastNeed -= buf.length;
+};
+
+// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a
+// continuation byte. If an invalid byte is detected, -2 is returned.
+function utf8CheckByte(byte) {
+ if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;
+ return byte >> 6 === 0x02 ? -1 : -2;
+}
+
+// Checks at most 3 bytes at the end of a Buffer in order to detect an
+// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)
+// needed to complete the UTF-8 character (if applicable) are returned.
+function utf8CheckIncomplete(self, buf, i) {
+ var j = buf.length - 1;
+ if (j < i) return 0;
+ var nb = utf8CheckByte(buf[j]);
+ if (nb >= 0) {
+ if (nb > 0) self.lastNeed = nb - 1;
+ return nb;
+ }
+ if (--j < i || nb === -2) return 0;
+ nb = utf8CheckByte(buf[j]);
+ if (nb >= 0) {
+ if (nb > 0) self.lastNeed = nb - 2;
+ return nb;
+ }
+ if (--j < i || nb === -2) return 0;
+ nb = utf8CheckByte(buf[j]);
+ if (nb >= 0) {
+ if (nb > 0) {
+ if (nb === 2) nb = 0;else self.lastNeed = nb - 3;
+ }
+ return nb;
+ }
+ return 0;
+}
+
+// Validates as many continuation bytes for a multi-byte UTF-8 character as
+// needed or are available. If we see a non-continuation byte where we expect
+// one, we "replace" the validated continuation bytes we've seen so far with
+// a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding
+// behavior. The continuation byte check is included three times in the case
+// where all of the continuation bytes for a character exist in the same buffer.
+// It is also done this way as a slight performance increase instead of using a
+// loop.
+function utf8CheckExtraBytes(self, buf, p) {
+ if ((buf[0] & 0xC0) !== 0x80) {
+ self.lastNeed = 0;
+ return '\ufffd';
+ }
+ if (self.lastNeed > 1 && buf.length > 1) {
+ if ((buf[1] & 0xC0) !== 0x80) {
+ self.lastNeed = 1;
+ return '\ufffd';
+ }
+ if (self.lastNeed > 2 && buf.length > 2) {
+ if ((buf[2] & 0xC0) !== 0x80) {
+ self.lastNeed = 2;
+ return '\ufffd';
+ }
+ }
+ }
+}
+
+// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.
+function utf8FillLast(buf) {
+ var p = this.lastTotal - this.lastNeed;
+ var r = utf8CheckExtraBytes(this, buf, p);
+ if (r !== undefined) return r;
+ if (this.lastNeed <= buf.length) {
+ buf.copy(this.lastChar, p, 0, this.lastNeed);
+ return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+ }
+ buf.copy(this.lastChar, p, 0, buf.length);
+ this.lastNeed -= buf.length;
+}
+
+// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a
+// partial character, the character's bytes are buffered until the required
+// number of bytes are available.
+function utf8Text(buf, i) {
+ var total = utf8CheckIncomplete(this, buf, i);
+ if (!this.lastNeed) return buf.toString('utf8', i);
+ this.lastTotal = total;
+ var end = buf.length - (total - this.lastNeed);
+ buf.copy(this.lastChar, 0, end);
+ return buf.toString('utf8', i, end);
+}
+
+// For UTF-8, a replacement character is added when ending on a partial
+// character.
+function utf8End(buf) {
+ var r = buf && buf.length ? this.write(buf) : '';
+ if (this.lastNeed) return r + '\ufffd';
+ return r;
+}
+
+// UTF-16LE typically needs two bytes per character, but even if we have an even
+// number of bytes available, we need to check if we end on a leading/high
+// surrogate. In that case, we need to wait for the next two bytes in order to
+// decode the last character properly.
+function utf16Text(buf, i) {
+ if ((buf.length - i) % 2 === 0) {
+ var r = buf.toString('utf16le', i);
+ if (r) {
+ var c = r.charCodeAt(r.length - 1);
+ if (c >= 0xD800 && c <= 0xDBFF) {
+ this.lastNeed = 2;
+ this.lastTotal = 4;
+ this.lastChar[0] = buf[buf.length - 2];
+ this.lastChar[1] = buf[buf.length - 1];
+ return r.slice(0, -1);
+ }
+ }
+ return r;
+ }
+ this.lastNeed = 1;
+ this.lastTotal = 2;
+ this.lastChar[0] = buf[buf.length - 1];
+ return buf.toString('utf16le', i, buf.length - 1);
+}
+
+// For UTF-16LE we do not explicitly append special replacement characters if we
+// end on a partial character, we simply let v8 handle that.
+function utf16End(buf) {
+ var r = buf && buf.length ? this.write(buf) : '';
+ if (this.lastNeed) {
+ var end = this.lastTotal - this.lastNeed;
+ return r + this.lastChar.toString('utf16le', 0, end);
+ }
+ return r;
+}
+
+function base64Text(buf, i) {
+ var n = (buf.length - i) % 3;
+ if (n === 0) return buf.toString('base64', i);
+ this.lastNeed = 3 - n;
+ this.lastTotal = 3;
+ if (n === 1) {
+ this.lastChar[0] = buf[buf.length - 1];
+ } else {
+ this.lastChar[0] = buf[buf.length - 2];
+ this.lastChar[1] = buf[buf.length - 1];
+ }
+ return buf.toString('base64', i, buf.length - n);
+}
+
+function base64End(buf) {
+ var r = buf && buf.length ? this.write(buf) : '';
+ if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);
+ return r;
+}
+
+// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)
+function simpleWrite(buf) {
+ return buf.toString(this.encoding);
+}
+
+function simpleEnd(buf) {
+ return buf && buf.length ? this.write(buf) : '';
+}
+
+/***/ }),
+
+/***/ 9318:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+const os = __webpack_require__(2087);
+const hasFlag = __webpack_require__(1621);
+
+const env = process.env;
+
+let forceColor;
+if (hasFlag('no-color') ||
+ hasFlag('no-colors') ||
+ hasFlag('color=false')) {
+ forceColor = false;
+} else if (hasFlag('color') ||
+ hasFlag('colors') ||
+ hasFlag('color=true') ||
+ hasFlag('color=always')) {
+ forceColor = true;
+}
+if ('FORCE_COLOR' in env) {
+ forceColor = env.FORCE_COLOR.length === 0 || parseInt(env.FORCE_COLOR, 10) !== 0;
+}
+
+function translateLevel(level) {
+ if (level === 0) {
+ return false;
+ }
+
+ return {
+ level,
+ hasBasic: true,
+ has256: level >= 2,
+ has16m: level >= 3
+ };
+}
+
+function supportsColor(stream) {
+ if (forceColor === false) {
+ return 0;
+ }
+
+ if (hasFlag('color=16m') ||
+ hasFlag('color=full') ||
+ hasFlag('color=truecolor')) {
+ return 3;
+ }
+
+ if (hasFlag('color=256')) {
+ return 2;
+ }
+
+ if (stream && !stream.isTTY && forceColor !== true) {
+ return 0;
+ }
+
+ const min = forceColor ? 1 : 0;
+
+ if (process.platform === 'win32') {
+ // Node.js 7.5.0 is the first version of Node.js to include a patch to
+ // libuv that enables 256 color output on Windows. Anything earlier and it
+ // won't work. However, here we target Node.js 8 at minimum as it is an LTS
+ // release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows
+ // release that supports 256 colors. Windows 10 build 14931 is the first release
+ // that supports 16m/TrueColor.
+ const osRelease = os.release().split('.');
+ if (
+ Number(process.versions.node.split('.')[0]) >= 8 &&
+ Number(osRelease[0]) >= 10 &&
+ Number(osRelease[2]) >= 10586
+ ) {
+ return Number(osRelease[2]) >= 14931 ? 3 : 2;
+ }
+
+ return 1;
+ }
+
+ if ('CI' in env) {
+ if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
+ return 1;
+ }
+
+ return min;
+ }
+
+ if ('TEAMCITY_VERSION' in env) {
+ return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+ }
+
+ if (env.COLORTERM === 'truecolor') {
+ return 3;
+ }
+
+ if ('TERM_PROGRAM' in env) {
+ const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+
+ switch (env.TERM_PROGRAM) {
+ case 'iTerm.app':
+ return version >= 3 ? 3 : 2;
+ case 'Apple_Terminal':
+ return 2;
+ // No default
+ }
+ }
+
+ if (/-256(color)?$/i.test(env.TERM)) {
+ return 2;
+ }
+
+ if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+ return 1;
+ }
+
+ if ('COLORTERM' in env) {
+ return 1;
+ }
+
+ if (env.TERM === 'dumb') {
+ return min;
+ }
+
+ return min;
+}
+
+function getSupportLevel(stream) {
+ const level = supportsColor(stream);
+ return translateLevel(level);
+}
+
+module.exports = {
+ supportsColor: getSupportLevel,
+ stdout: getSupportLevel(process.stdout),
+ stderr: getSupportLevel(process.stderr)
+};
+
+
+/***/ }),
+
+/***/ 7127:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+
+/**
+ * For Node.js, simply re-export the core `util.deprecate` function.
+ */
+
+module.exports = __webpack_require__(1669).deprecate;
+
+
+/***/ }),
+
+/***/ 5627:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+ "default": () => /* binding */ run
+});
+
+// EXTERNAL MODULE: ./node_modules/@actions/core/lib/core.js
+var core = __webpack_require__(2186);
+// CONCATENATED MODULE: ./lib/input.ts
+
+function getInput(name, options = {}) {
+ const value = core.getInput(name, options);
+ if (!value && options.default) {
+ core.debug(`${name}: ${options.default}`);
+ return options.default;
+ }
+ core.debug(`${name}: ${value}`);
+ return value;
+}
+
+// EXTERNAL MODULE: ./node_modules/axios/index.js
+var axios = __webpack_require__(6545);
+var axios_default = /*#__PURE__*/__webpack_require__.n(axios);
+
+// CONCATENATED MODULE: ./lib/github-client.ts
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const pkg = __webpack_require__(306);
+const github = axios_default().create({
+ baseURL: `https://api.github.com/`,
+ headers: {
+ accept: `application/vnd.github.v3+json`,
+ authorization: `bearer ${process.env.GH_TOKEN}`,
+ "user-agent": `${pkg.name}/${pkg.version}`,
+ },
+});
+/* harmony default export */ const github_client = (github);
+
+// CONCATENATED MODULE: ./lib/resource.ts
+
+
+class Resource {
+ constructor() {
+ this.debug = core.debug;
+ this.github = github_client;
+ }
+ graphql(query, variables) {
+ const body = {
+ query,
+ variables,
+ };
+ return this.github.post(`/graphql`, body);
+ }
+}
+
+// CONCATENATED MODULE: ./lib/repo.ts
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+ 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) : adopt(result.value).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+
+class Repo extends Resource {
+ constructor(nameWithOwner) {
+ super();
+ this.nameWithOwner = nameWithOwner;
+ const [owner, name] = this.nameWithOwner.split("/");
+ this.owner = owner;
+ this.name = name;
+ }
+ save() {
+ return __awaiter(this, void 0, void 0, function* () {
+ throw new Error("Not implemented");
+ });
+ }
+ load() {
+ return __awaiter(this, void 0, void 0, function* () {
+ const response = yield this.github.get(`/repos/${this.nameWithOwner}`);
+ this.defaultBranchRef = response.data.default_branch;
+ });
+ }
+}
+
+// CONCATENATED MODULE: ./lib/ref.ts
+var ref_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+ 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) : adopt(result.value).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+
+class Ref extends Resource {
+ constructor(repo, ref) {
+ super();
+ this.repo = repo;
+ this.ref = ref;
+ }
+ save() {
+ return ref_awaiter(this, void 0, void 0, function* () {
+ throw new Error("Not implemented");
+ });
+ }
+ get fullyQualifiedName() {
+ return this.prefix + this.name;
+ }
+ load() {
+ return ref_awaiter(this, void 0, void 0, function* () {
+ const response = yield this.graphql(`query inspectRef($owner: String!, $name: String!, $ref: String!) {
+ repository(owner: $owner, name: $name) {
+ ref(qualifiedName: $ref) {
+ name
+ prefix
+ commit: target {
+ ... on Commit {
+ oid
+ tree {
+ oid
+ }
+ }
+ }
+ }
+ }
+ }`, { owner: this.repo.owner, name: this.repo.name, ref: this.ref });
+ this.name = response.data.data.repository.ref.name;
+ this.prefix = response.data.data.repository.ref.prefix;
+ this.commitOid = response.data.data.repository.ref.commit.oid;
+ this.treeOid = response.data.data.repository.ref.commit.tree.oid;
+ this.debug(`Ref: ${this.fullyQualifiedName}, prefix: ${this.prefix}, commitOid: ${this.commitOid}, treeOid: ${this.treeOid}`);
+ });
+ }
+ update(sha) {
+ return ref_awaiter(this, void 0, void 0, function* () {
+ // Update ref
+ // Via: PATCH https://api.github.com/repos/$GITHUB_REPOSITORY/git/$REF
+ yield this.github.patch(`/repos/${this.repo.nameWithOwner}/git/${this.fullyQualifiedName}`, { sha });
+ });
+ }
+}
+
+// EXTERNAL MODULE: external "fs"
+var external_fs_ = __webpack_require__(5747);
+// EXTERNAL MODULE: external "stream"
+var external_stream_ = __webpack_require__(2413);
+// EXTERNAL MODULE: external "path"
+var external_path_ = __webpack_require__(5622);
+// EXTERNAL MODULE: ./node_modules/multistream/index.js
+var multistream = __webpack_require__(7999);
+// CONCATENATED MODULE: ./lib/blob.ts
+var blob_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+ 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) : adopt(result.value).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+
+
+
+
+
+/**
+ * Encodes chunks in a stream to base64
+ */
+const base64Transformer = new external_stream_.Transform({
+ transform(chunk, encoding, callback) {
+ this.push(chunk.toString("base64"));
+ callback();
+ },
+});
+class Blob extends Resource {
+ constructor(repo, baseDir, file) {
+ super();
+ this.repo = repo;
+ this.baseDir = baseDir;
+ this.file = file;
+ this.type = "blob";
+ this.absoluteFilePath = (0,external_path_.join)(baseDir, file);
+ // Reject files that don't exist
+ if (!external_fs_.existsSync(this.absoluteFilePath)) {
+ throw new Error(`File does not exist: ${this.absoluteFilePath}.`);
+ }
+ // Set the file's mode, this should be represented as an octal string
+ this.mode = external_fs_.statSync(this.absoluteFilePath).mode.toString(8);
+ }
+ /**
+ * Produces a stream that conforms to the shape expected
+ * by the POST /repos/{owner}/{repo}/git/blobs GitHub API
+ *
+ * For example, streams produced by this class will resolve to a shape like:
+ * {
+ * "encoding": "base64",
+ * "content": "SGFsZiBtZWFzdXJlcyBhcmUgYXMgYmFkIGFzIG5vdGhpbmcgYXQgYWxsLg=="
+ * }
+ *
+ * See: https://docs.github.com/rest/reference/git#create-a-blob
+ */
+ get stream() {
+ // Produces the JSON body as a stream, so that we don't have to read (
+ // potentially very large) files into memory
+ return new multistream([
+ external_stream_.Readable.from('{"encoding":"base64","content":"'),
+ external_fs_.createReadStream(this.absoluteFilePath).pipe(base64Transformer),
+ external_stream_.Readable.from('"}'),
+ ]);
+ }
+ get path() {
+ return this.file;
+ }
+ save() {
+ return blob_awaiter(this, void 0, void 0, function* () {
+ const response = yield this.github.post(`/repos/${this.repo.nameWithOwner}/git/blobs`, this.stream);
+ this.sha = response.data.sha;
+ this.debug(`Sha for blob ${this.file}: ${this.sha}.`);
+ });
+ }
+}
+function getBlobsFromFiles(repo, files, options = {}) {
+ const { baseDir } = options;
+ return files
+ .trim()
+ .split("\n")
+ .map((file) => new Blob(repo, baseDir, file));
+}
+
+// CONCATENATED MODULE: ./lib/tree.ts
+var tree_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+ 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) : adopt(result.value).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+var __asyncValues = (undefined && undefined.__asyncValues) || function (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); }
+};
+
+class Tree extends Resource {
+ constructor(repo, blobs, parentOid) {
+ super();
+ this.repo = repo;
+ this.blobs = blobs;
+ this.parentOid = parentOid;
+ }
+ save() {
+ var e_1, _a;
+ return tree_awaiter(this, void 0, void 0, function* () {
+ try {
+ // Save all the blobs
+ for (var _b = __asyncValues(this.blobs), _c; _c = yield _b.next(), !_c.done;) {
+ const blob = _c.value;
+ yield blob.save();
+ }
+ }
+ catch (e_1_1) { e_1 = { error: e_1_1 }; }
+ finally {
+ try {
+ if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b);
+ }
+ finally { if (e_1) throw e_1.error; }
+ }
+ // Save the tree
+ // Via: POST https://api.github.com/repos/$GITHUB_REPOSITORY/git/trees
+ const response = yield this.github.post(`repos/${this.repo.nameWithOwner}/git/trees`, {
+ tree: this.blobs.map((blob) => {
+ return {
+ path: blob.path,
+ mode: blob.mode,
+ type: blob.type,
+ sha: blob.sha,
+ };
+ }),
+ base_tree: this.parentOid,
+ });
+ this.sha = response.data.sha;
+ this.debug(`Tree: ${this.sha}`);
+ });
+ }
+}
+
+// CONCATENATED MODULE: ./lib/commit.ts
+var commit_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+ 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) : adopt(result.value).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+
+class Commit extends Resource {
+ constructor(repo, tree, message, parents) {
+ super();
+ this.repo = repo;
+ this.tree = tree;
+ this.message = message;
+ this.parents = parents;
+ }
+ save() {
+ return commit_awaiter(this, void 0, void 0, function* () {
+ // Save the tree first
+ yield this.tree.save();
+ // Save the commit
+ // Via: POST https://api.github.com/repos/$GITHUB_REPOSITORY/git/commits
+ const response = yield this.github.post(`/repos/${this.repo.nameWithOwner}/git/commits`, {
+ message: this.message,
+ tree: this.tree.sha,
+ parents: this.parents,
+ });
+ this.sha = response.data.sha;
+ this.debug(`Commit: ${this.sha}`);
+ });
+ }
+}
+
+// CONCATENATED MODULE: ./index.ts
+var index_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+ 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) : adopt(result.value).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+
+
+
+
+
+
+
+function run() {
+ return index_awaiter(this, void 0, void 0, function* () {
+ try {
+ // Get repo
+ const repo = new Repo(process.env.GITHUB_REPOSITORY);
+ yield repo.load();
+ // Get inputs
+ const files = getInput("files");
+ const baseDir = getInput("workspace", {
+ default: process.env.GITHUB_WORKSPACE,
+ });
+ const commitMessage = getInput("commit-message");
+ // Load ref details
+ const ref = new Ref(repo, getInput("ref", { default: repo.defaultBranchRef }));
+ yield ref.load();
+ // Expand files to an array of "blobs", which will be created on GitHub via the create blob API
+ const blobs = getBlobsFromFiles(repo, files, { baseDir });
+ core.debug(`Received ${blobs.length} blob${blobs.length === 1 ? "" : "s"}: ${blobs.map((blob) => blob.absoluteFilePath).join(", ")}`);
+ // Create a tree
+ const tree = new Tree(repo, blobs, ref.treeOid);
+ // Create commit
+ const commit = new Commit(repo, tree, commitMessage, [
+ ref.commitOid,
+ ]);
+ yield commit.save();
+ // Set commit sha output
+ core.setOutput("commit-sha", commit.sha);
+ // Update ref to point at new commit sha
+ yield ref.update(commit.sha);
+ }
+ catch (e) {
+ core.setFailed(e);
+ }
+ });
+}
+run();
+
+
+/***/ }),
+
+/***/ 696:
+/***/ ((module) => {
+
+"use strict";
+module.exports = JSON.parse("{\"_from\":\"axios\",\"_id\":\"axios@0.21.0\",\"_inBundle\":false,\"_integrity\":\"sha512-fmkJBknJKoZwem3/IKSSLpkdNXZeBu5Q7GA/aRsr2btgrptmSCxi2oFjZHqGdK9DoTil9PIHlPIZw2EcRJXRvw==\",\"_location\":\"/axios\",\"_phantomChildren\":{},\"_requested\":{\"type\":\"tag\",\"registry\":true,\"raw\":\"axios\",\"name\":\"axios\",\"escapedName\":\"axios\",\"rawSpec\":\"\",\"saveSpec\":null,\"fetchSpec\":\"latest\"},\"_requiredBy\":[\"#USER\",\"/\"],\"_resolved\":\"https://registry.npmjs.org/axios/-/axios-0.21.0.tgz\",\"_shasum\":\"26df088803a2350dff2c27f96fef99fe49442aca\",\"_spec\":\"axios\",\"_where\":\"/Users/swinton/GitHub/swinton/verified-commit\",\"author\":{\"name\":\"Matt Zabriskie\"},\"browser\":{\"./lib/adapters/http.js\":\"./lib/adapters/xhr.js\"},\"bugs\":{\"url\":\"https://github.com/axios/axios/issues\"},\"bundleDependencies\":false,\"bundlesize\":[{\"path\":\"./dist/axios.min.js\",\"threshold\":\"5kB\"}],\"dependencies\":{\"follow-redirects\":\"^1.10.0\"},\"deprecated\":false,\"description\":\"Promise based HTTP client for the browser and node.js\",\"devDependencies\":{\"bundlesize\":\"^0.17.0\",\"coveralls\":\"^3.0.0\",\"es6-promise\":\"^4.2.4\",\"grunt\":\"^1.0.2\",\"grunt-banner\":\"^0.6.0\",\"grunt-cli\":\"^1.2.0\",\"grunt-contrib-clean\":\"^1.1.0\",\"grunt-contrib-watch\":\"^1.0.0\",\"grunt-eslint\":\"^20.1.0\",\"grunt-karma\":\"^2.0.0\",\"grunt-mocha-test\":\"^0.13.3\",\"grunt-ts\":\"^6.0.0-beta.19\",\"grunt-webpack\":\"^1.0.18\",\"istanbul-instrumenter-loader\":\"^1.0.0\",\"jasmine-core\":\"^2.4.1\",\"karma\":\"^1.3.0\",\"karma-chrome-launcher\":\"^2.2.0\",\"karma-coverage\":\"^1.1.1\",\"karma-firefox-launcher\":\"^1.1.0\",\"karma-jasmine\":\"^1.1.1\",\"karma-jasmine-ajax\":\"^0.1.13\",\"karma-opera-launcher\":\"^1.0.0\",\"karma-safari-launcher\":\"^1.0.0\",\"karma-sauce-launcher\":\"^1.2.0\",\"karma-sinon\":\"^1.0.5\",\"karma-sourcemap-loader\":\"^0.3.7\",\"karma-webpack\":\"^1.7.0\",\"load-grunt-tasks\":\"^3.5.2\",\"minimist\":\"^1.2.0\",\"mocha\":\"^5.2.0\",\"sinon\":\"^4.5.0\",\"typescript\":\"^2.8.1\",\"url-search-params\":\"^0.10.0\",\"webpack\":\"^1.13.1\",\"webpack-dev-server\":\"^1.14.1\"},\"homepage\":\"https://github.com/axios/axios\",\"jsdelivr\":\"dist/axios.min.js\",\"keywords\":[\"xhr\",\"http\",\"ajax\",\"promise\",\"node\"],\"license\":\"MIT\",\"main\":\"index.js\",\"name\":\"axios\",\"repository\":{\"type\":\"git\",\"url\":\"git+https://github.com/axios/axios.git\"},\"scripts\":{\"build\":\"NODE_ENV=production grunt build\",\"coveralls\":\"cat coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js\",\"examples\":\"node ./examples/server.js\",\"fix\":\"eslint --fix lib/**/*.js\",\"postversion\":\"git push && git push --tags\",\"preversion\":\"npm test\",\"start\":\"node ./sandbox/server.js\",\"test\":\"grunt test && bundlesize\",\"version\":\"npm run build && grunt version && git add -A dist && git add CHANGELOG.md bower.json package.json\"},\"typings\":\"./index.d.ts\",\"unpkg\":\"dist/axios.min.js\",\"version\":\"0.21.0\"}");
+
+/***/ }),
+
+/***/ 306:
+/***/ ((module) => {
+
+"use strict";
+module.exports = JSON.parse("{\"name\":\"@swinton/commit\",\"version\":\"2.0.0\",\"description\":\"Create a verified commit with GitHub Actions\",\"main\":\"dist/index.js\",\"scripts\":{\"start\":\"node dist/index.js\",\"lint\":\"tsc --noEmit && eslint '*/**/*.{js,ts,tsx}'\",\"test\":\"echo \\\"Error: no test specified\\\" && exit 1\",\"build\":\"ncc build index.ts -o dist\"},\"repository\":{\"type\":\"git\",\"url\":\"git+https://github.com/swinton/commit.git\"},\"keywords\":[],\"author\":\"Steve Winton (https://github.com/swinton)\",\"license\":\"ISC\",\"bugs\":{\"url\":\"https://github.com/swinton/commit/issues\"},\"homepage\":\"https://github.com/swinton/commit#readme\",\"devDependencies\":{\"@types/node\":\"^14.14.10\",\"@typescript-eslint/eslint-plugin\":\"^4.9.1\",\"@typescript-eslint/parser\":\"^4.9.1\",\"@vercel/ncc\":\"^0.25.1\",\"eslint\":\"^7.15.0\",\"eslint-config-prettier\":\"^7.0.0\",\"eslint-plugin-prettier\":\"^3.2.0\",\"prettier\":\"^2.2.1\",\"typescript\":\"^4.1.2\"},\"dependencies\":{\"@actions/core\":\"^1.2.6\",\"axios\":\"^0.21.0\",\"multistream\":\"^4.0.1\"}}");
+
+/***/ }),
+
+/***/ 2357:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("assert");;
+
+/***/ }),
+
+/***/ 4293:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("buffer");;
+
+/***/ }),
+
+/***/ 8614:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("events");;
+
+/***/ }),
+
+/***/ 5747:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("fs");;
+
+/***/ }),
+
+/***/ 8605:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("http");;
+
+/***/ }),
+
+/***/ 7211:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("https");;
+
+/***/ }),
+
+/***/ 2087:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("os");;
+
+/***/ }),
+
+/***/ 5622:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("path");;
+
+/***/ }),
+
+/***/ 2413:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("stream");;
+
+/***/ }),
+
+/***/ 3867:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("tty");;
+
+/***/ }),
+
+/***/ 8835:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("url");;
+
+/***/ }),
+
+/***/ 1669:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("util");;
+
+/***/ }),
+
+/***/ 8761:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("zlib");;
+
+/***/ })
+
+/******/ });
+/************************************************************************/
+/******/ // The module cache
+/******/ var __webpack_module_cache__ = {};
+/******/
+/******/ // The require function
+/******/ function __webpack_require__(moduleId) {
+/******/ // Check if module is in cache
+/******/ if(__webpack_module_cache__[moduleId]) {
+/******/ return __webpack_module_cache__[moduleId].exports;
+/******/ }
+/******/ // Create a new module (and put it into the cache)
+/******/ var module = __webpack_module_cache__[moduleId] = {
+/******/ // no module.id needed
+/******/ // no module.loaded needed
+/******/ exports: {}
+/******/ };
+/******/
+/******/ // Execute the module function
+/******/ var threw = true;
+/******/ try {
+/******/ __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ threw = false;
+/******/ } finally {
+/******/ if(threw) delete __webpack_module_cache__[moduleId];
+/******/ }
+/******/
+/******/ // Return the exports of the module
+/******/ return module.exports;
+/******/ }
+/******/
+/************************************************************************/
+/******/ /* webpack/runtime/compat get default export */
+/******/ (() => {
+/******/ // getDefaultExport function for compatibility with non-harmony modules
+/******/ __webpack_require__.n = (module) => {
+/******/ var getter = module && module.__esModule ?
+/******/ () => module['default'] :
+/******/ () => module;
+/******/ __webpack_require__.d(getter, { a: getter });
+/******/ return getter;
+/******/ };
+/******/ })();
+/******/
+/******/ /* webpack/runtime/define property getters */
+/******/ (() => {
+/******/ // define getter functions for harmony exports
+/******/ __webpack_require__.d = (exports, definition) => {
+/******/ for(var key in definition) {
+/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ }
+/******/ }
+/******/ };
+/******/ })();
+/******/
+/******/ /* webpack/runtime/hasOwnProperty shorthand */
+/******/ (() => {
+/******/ __webpack_require__.o = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop)
+/******/ })();
+/******/
+/******/ /* webpack/runtime/make namespace object */
+/******/ (() => {
+/******/ // define __esModule on exports
+/******/ __webpack_require__.r = (exports) => {
+/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ }
+/******/ Object.defineProperty(exports, '__esModule', { value: true });
+/******/ };
+/******/ })();
+/******/
+/******/ /* webpack/runtime/compat */
+/******/
+/******/ __webpack_require__.ab = __dirname + "/";/************************************************************************/
+/******/ // module exports must be returned from runtime so entry inlining is disabled
+/******/ // startup
+/******/ // Load entry module and return exports
+/******/ return __webpack_require__(5627);
+/******/ })()
+;
\ No newline at end of file
diff --git a/get-oids.sh b/get-oids.sh
deleted file mode 100755
index bfbdb9a..0000000
--- a/get-oids.sh
+++ /dev/null
@@ -1,28 +0,0 @@
-#!/bin/bash
-set -e
-
-# GraphQL query to get default branch ref's head commit SHA and tree SHA
-response=$( gh api graphql \
- --field owner=':owner' \
- --field repo=':repo' \
- --raw-field \
- query='query repoContents($owner: String!, $repo: String!) {
- repository(owner: $owner, name: $repo) {
- defaultBranchRef {
- name
- commit: target {
- ... on Commit {
- oid
- tree {
- oid
- }
- }
- }
- }
- }
- }'
-)
-
-# Export environment variables with object ids
-echo HEAD_SHA=$( jq -r '.data.repository.defaultBranchRef.commit.oid' <<< "${response}" ) >> $GITHUB_ENV
-echo BASE_TREE_SHA=$( jq -r '.data.repository.defaultBranchRef.commit.tree.oid' <<< "${response}" ) >> $GITHUB_ENV
diff --git a/index.ts b/index.ts
new file mode 100644
index 0000000..b4520a8
--- /dev/null
+++ b/index.ts
@@ -0,0 +1,57 @@
+import * as core from "@actions/core";
+
+import getInput from "./lib/input";
+import { Repo } from "./lib/repo";
+import { Ref } from "./lib/ref";
+import { getBlobsFromFiles } from "./lib/blob";
+import { Tree } from "./lib/tree";
+import { Commit } from "./lib/commit";
+
+export default async function run(): Promise {
+ try {
+ // Get repo
+ const repo = new Repo(process.env.GITHUB_REPOSITORY);
+ await repo.load();
+
+ // Get inputs
+ const files = getInput("files");
+ const baseDir = getInput("workspace", {
+ default: process.env.GITHUB_WORKSPACE,
+ });
+ const commitMessage = getInput("commit-message");
+
+ // Load ref details
+ const ref = new Ref(
+ repo,
+ getInput("ref", { default: repo.defaultBranchRef })
+ );
+ await ref.load();
+
+ // Expand files to an array of "blobs", which will be created on GitHub via the create blob API
+ const blobs = getBlobsFromFiles(repo, files, { baseDir });
+ core.debug(
+ `Received ${blobs.length} blob${
+ blobs.length === 1 ? "" : "s"
+ }: ${blobs.map((blob) => blob.absoluteFilePath).join(", ")}`
+ );
+
+ // Create a tree
+ const tree: Tree = new Tree(repo, blobs, ref.treeOid);
+
+ // Create commit
+ const commit: Commit = new Commit(repo, tree, commitMessage, [
+ ref.commitOid,
+ ]);
+ await commit.save();
+
+ // Set commit sha output
+ core.setOutput("commit-sha", commit.sha);
+
+ // Update ref to point at new commit sha
+ await ref.update(commit.sha);
+ } catch (e) {
+ core.setFailed(e);
+ }
+}
+
+run();
diff --git a/jest.config.js b/jest.config.js
new file mode 100644
index 0000000..1775ad0
--- /dev/null
+++ b/jest.config.js
@@ -0,0 +1,10 @@
+module.exports = {
+ moduleFileExtensions: ["js", "ts"],
+ setupFilesAfterEnv: ["./jest.setup.js"],
+ testEnvironment: "node",
+ testMatch: ["**/*.test.ts"],
+ transform: {
+ "^.+\\.ts$": "ts-jest",
+ },
+ verbose: true,
+};
diff --git a/jest.setup.js b/jest.setup.js
new file mode 100644
index 0000000..3b4b79b
--- /dev/null
+++ b/jest.setup.js
@@ -0,0 +1 @@
+jest.setTimeout(5000);
diff --git a/lib/blob.ts b/lib/blob.ts
new file mode 100644
index 0000000..5eb7f0a
--- /dev/null
+++ b/lib/blob.ts
@@ -0,0 +1,83 @@
+import * as fs from "fs";
+import { Readable } from "stream";
+import { join } from "path";
+import { Base64Encode } from "base64-stream";
+import MultiStream from "multistream";
+import Resource from "./resource";
+import { Repo } from "./repo";
+
+export class Blob extends Resource {
+ readonly type: string = "blob";
+ readonly absoluteFilePath: string;
+ readonly mode: string;
+ sha: string;
+
+ constructor(
+ readonly repo: Repo,
+ readonly baseDir: string,
+ readonly file: string
+ ) {
+ super();
+ this.absoluteFilePath = join(baseDir, file);
+ // Reject files that don't exist
+ if (!fs.existsSync(this.absoluteFilePath)) {
+ throw new Error(`File does not exist: ${this.absoluteFilePath}.`);
+ }
+ // Set the file's mode, this should be represented as an octal string
+ this.mode = fs.statSync(this.absoluteFilePath).mode.toString(8);
+ }
+
+ /**
+ * Produces a stream that conforms to the shape expected
+ * by the POST /repos/{owner}/{repo}/git/blobs GitHub API
+ *
+ * For example, streams produced by this class will resolve to a shape like:
+ * {
+ * "encoding": "base64",
+ * "content": "SGFsZiBtZWFzdXJlcyBhcmUgYXMgYmFkIGFzIG5vdGhpbmcgYXQgYWxsLg=="
+ * }
+ *
+ * See: https://docs.github.com/rest/reference/git#create-a-blob
+ */
+ get stream(): Readable {
+ const streams: Readable[] = [
+ Readable.from('{"encoding":"base64","content":"'),
+ fs.createReadStream(this.absoluteFilePath).pipe(new Base64Encode()),
+ Readable.from('"}'),
+ ];
+
+ // Produces the JSON body as a stream, so that we don't have to read (
+ // potentially very large) files into memory
+ return new MultiStream(streams);
+ }
+
+ get path(): string {
+ return this.file;
+ }
+
+ async save(): Promise {
+ const response = await this.github.post(
+ `/repos/${this.repo.nameWithOwner}/git/blobs`,
+ this.stream
+ );
+ this.sha = response.data.sha;
+ this.debug(`Sha for blob ${this.file}: ${this.sha}.`);
+ }
+}
+
+export interface Options {
+ /** Optional. Default base dir to use when expanding a set of files. */
+ baseDir?: string;
+}
+
+export function getBlobsFromFiles(
+ repo: Repo,
+ files: string,
+ options: Options = {}
+): Blob[] {
+ const { baseDir } = options;
+ return files
+ .trim()
+ .split("\n")
+ .map((file) => new Blob(repo, baseDir, file));
+}
diff --git a/lib/commit.ts b/lib/commit.ts
new file mode 100644
index 0000000..9dac567
--- /dev/null
+++ b/lib/commit.ts
@@ -0,0 +1,34 @@
+import Resource from "./resource";
+import { Repo } from "./repo";
+import { Tree } from "./tree";
+
+export class Commit extends Resource {
+ sha: string;
+ constructor(
+ readonly repo: Repo,
+ readonly tree: Tree,
+ readonly message: string,
+ readonly parents: string[]
+ ) {
+ super();
+ }
+
+ async save(): Promise {
+ // Save the tree first
+ await this.tree.save();
+
+ // Save the commit
+ // Via: POST https://api.github.com/repos/$GITHUB_REPOSITORY/git/commits
+ const response = await this.github.post(
+ `/repos/${this.repo.nameWithOwner}/git/commits`,
+ {
+ message: this.message,
+ tree: this.tree.sha,
+ parents: this.parents,
+ }
+ );
+
+ this.sha = response.data.sha;
+ this.debug(`Commit: ${this.sha}`);
+ }
+}
diff --git a/lib/github-client.ts b/lib/github-client.ts
new file mode 100644
index 0000000..89b4458
--- /dev/null
+++ b/lib/github-client.ts
@@ -0,0 +1,15 @@
+import axios from "axios";
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const pkg = require("../package.json");
+
+const github = axios.create({
+ baseURL: `https://api.github.com/`,
+ headers: {
+ accept: `application/vnd.github.v3+json`,
+ authorization: `bearer ${process.env.GH_TOKEN}`,
+ "user-agent": `${pkg.name}/${pkg.version}`,
+ },
+});
+
+export default github;
diff --git a/lib/input.ts b/lib/input.ts
new file mode 100644
index 0000000..48de2d3
--- /dev/null
+++ b/lib/input.ts
@@ -0,0 +1,21 @@
+import * as core from "@actions/core";
+
+export interface InputOptions extends core.InputOptions {
+ /** Optional. Default value to use for an input option if the option is not set. */
+ default?: string | null;
+}
+
+export default function getInput(
+ name: string,
+ options: InputOptions = {}
+): string | null {
+ const value = core.getInput(name, options);
+
+ if (!value && options.default) {
+ core.debug(`${name}: ${options.default}`);
+ return options.default;
+ }
+
+ core.debug(`${name}: ${value}`);
+ return value;
+}
diff --git a/lib/ref.ts b/lib/ref.ts
new file mode 100644
index 0000000..2018394
--- /dev/null
+++ b/lib/ref.ts
@@ -0,0 +1,76 @@
+import Resource from "./resource";
+import { Repo } from "./repo";
+
+export class Ref extends Resource {
+ prefix: string;
+ name: string;
+ commitOid: string;
+ treeOid: string;
+
+ constructor(readonly repo: Repo, readonly ref: string) {
+ super();
+ }
+
+ async save(): Promise {
+ throw new Error("Not implemented");
+ }
+
+ get fullyQualifiedName(): string {
+ return this.prefix + this.name;
+ }
+
+ async load(): Promise {
+ type ResponseShape = {
+ data: {
+ repository: {
+ ref: {
+ name: string;
+ prefix: string;
+ commit: {
+ oid: string;
+ tree: {
+ oid: string;
+ };
+ };
+ };
+ };
+ };
+ };
+
+ const response = await this.graphql(
+ `query inspectRef($owner: String!, $name: String!, $ref: String!) {
+ repository(owner: $owner, name: $name) {
+ ref(qualifiedName: $ref) {
+ name
+ prefix
+ commit: target {
+ ... on Commit {
+ oid
+ tree {
+ oid
+ }
+ }
+ }
+ }
+ }
+ }`,
+ { owner: this.repo.owner, name: this.repo.name, ref: this.ref }
+ );
+ this.name = (response.data as ResponseShape).data.repository.ref.name;
+ this.prefix = (response.data as ResponseShape).data.repository.ref.prefix;
+ this.commitOid = (response.data as ResponseShape).data.repository.ref.commit.oid;
+ this.treeOid = (response.data as ResponseShape).data.repository.ref.commit.tree.oid;
+ this.debug(
+ `Ref: ${this.fullyQualifiedName}, prefix: ${this.prefix}, commitOid: ${this.commitOid}, treeOid: ${this.treeOid}`
+ );
+ }
+
+ async update(sha: string): Promise {
+ // Update ref
+ // Via: PATCH https://api.github.com/repos/$GITHUB_REPOSITORY/git/$REF
+ await this.github.patch(
+ `/repos/${this.repo.nameWithOwner}/git/${this.fullyQualifiedName}`,
+ { sha }
+ );
+ }
+}
diff --git a/lib/repo.ts b/lib/repo.ts
new file mode 100644
index 0000000..fa198b9
--- /dev/null
+++ b/lib/repo.ts
@@ -0,0 +1,22 @@
+import Resource from "./resource";
+
+export class Repo extends Resource {
+ readonly owner: string;
+ readonly name: string;
+ defaultBranchRef: string;
+ constructor(readonly nameWithOwner: string) {
+ super();
+ const [owner, name] = this.nameWithOwner.split("/");
+ this.owner = owner;
+ this.name = name;
+ }
+
+ async save(): Promise {
+ throw new Error("Not implemented");
+ }
+
+ async load(): Promise {
+ const response = await this.github.get(`/repos/${this.nameWithOwner}`);
+ this.defaultBranchRef = response.data.default_branch;
+ }
+}
diff --git a/lib/resource.ts b/lib/resource.ts
new file mode 100644
index 0000000..558961f
--- /dev/null
+++ b/lib/resource.ts
@@ -0,0 +1,30 @@
+import { AxiosInstance, AxiosResponse } from "axios";
+import * as core from "@actions/core";
+
+import github from "./github-client";
+
+export interface Saveable {
+ save(): Promise;
+}
+
+export default abstract class Resource implements Saveable {
+ protected debug: (message: string) => void;
+ protected github: AxiosInstance;
+ constructor() {
+ this.debug = core.debug;
+ this.github = github;
+ }
+
+ protected graphql(
+ query: string,
+ variables: Record
+ ): Promise> {
+ const body: Record = {
+ query,
+ variables,
+ };
+ return this.github.post(`/graphql`, body);
+ }
+
+ abstract save(): Promise;
+}
diff --git a/lib/tree.ts b/lib/tree.ts
new file mode 100644
index 0000000..b3b1046
--- /dev/null
+++ b/lib/tree.ts
@@ -0,0 +1,43 @@
+import Resource from "./resource";
+
+import { Repo } from "./repo";
+import { Blob } from "./blob";
+
+export class Tree extends Resource {
+ sha: string;
+
+ constructor(
+ readonly repo: Repo,
+ readonly blobs: Blob[],
+ readonly parentOid?: string
+ ) {
+ super();
+ }
+
+ async save(): Promise {
+ // Save all the blobs
+ for await (const blob of this.blobs) {
+ await blob.save();
+ }
+
+ // Save the tree
+ // Via: POST https://api.github.com/repos/$GITHUB_REPOSITORY/git/trees
+ const response = await this.github.post(
+ `repos/${this.repo.nameWithOwner}/git/trees`,
+ {
+ tree: this.blobs.map((blob) => {
+ return {
+ path: blob.path,
+ mode: blob.mode,
+ type: blob.type,
+ sha: blob.sha,
+ };
+ }),
+ base_tree: this.parentOid,
+ }
+ );
+
+ this.sha = response.data.sha;
+ this.debug(`Tree: ${this.sha}`);
+ }
+}
diff --git a/package-lock.json b/package-lock.json
new file mode 100644
index 0000000..ae38dbb
--- /dev/null
+++ b/package-lock.json
@@ -0,0 +1,5847 @@
+{
+ "name": "@swinton/commit",
+ "version": "2.0.0",
+ "lockfileVersion": 1,
+ "requires": true,
+ "dependencies": {
+ "@actions/core": {
+ "version": "1.2.6",
+ "resolved": "https://registry.npmjs.org/@actions/core/-/core-1.2.6.tgz",
+ "integrity": "sha512-ZQYitnqiyBc3D+k7LsgSBmMDVkOVidaagDG7j3fOym77jNunWRuYx7VSHa9GNfFZh+zh61xsCjRj4JxMZlDqTA=="
+ },
+ "@babel/code-frame": {
+ "version": "7.10.4",
+ "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.10.4.tgz",
+ "integrity": "sha512-vG6SvB6oYEhvgisZNFRmRCUkLz11c7rp+tbNTynGqc6mS1d5ATd/sGyV6W0KZZnXRKMTzZDRgQT3Ou9jhpAfUg==",
+ "dev": true,
+ "requires": {
+ "@babel/highlight": "^7.10.4"
+ }
+ },
+ "@babel/core": {
+ "version": "7.12.10",
+ "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.12.10.tgz",
+ "integrity": "sha512-eTAlQKq65zHfkHZV0sIVODCPGVgoo1HdBlbSLi9CqOzuZanMv2ihzY+4paiKr1mH+XmYESMAmJ/dpZ68eN6d8w==",
+ "dev": true,
+ "requires": {
+ "@babel/code-frame": "^7.10.4",
+ "@babel/generator": "^7.12.10",
+ "@babel/helper-module-transforms": "^7.12.1",
+ "@babel/helpers": "^7.12.5",
+ "@babel/parser": "^7.12.10",
+ "@babel/template": "^7.12.7",
+ "@babel/traverse": "^7.12.10",
+ "@babel/types": "^7.12.10",
+ "convert-source-map": "^1.7.0",
+ "debug": "^4.1.0",
+ "gensync": "^1.0.0-beta.1",
+ "json5": "^2.1.2",
+ "lodash": "^4.17.19",
+ "semver": "^5.4.1",
+ "source-map": "^0.5.0"
+ },
+ "dependencies": {
+ "semver": {
+ "version": "5.7.1",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz",
+ "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==",
+ "dev": true
+ },
+ "source-map": {
+ "version": "0.5.7",
+ "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz",
+ "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=",
+ "dev": true
+ }
+ }
+ },
+ "@babel/generator": {
+ "version": "7.12.10",
+ "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.12.10.tgz",
+ "integrity": "sha512-6mCdfhWgmqLdtTkhXjnIz0LcdVCd26wS2JXRtj2XY0u5klDsXBREA/pG5NVOuVnF2LUrBGNFtQkIqqTbblg0ww==",
+ "dev": true,
+ "requires": {
+ "@babel/types": "^7.12.10",
+ "jsesc": "^2.5.1",
+ "source-map": "^0.5.0"
+ },
+ "dependencies": {
+ "source-map": {
+ "version": "0.5.7",
+ "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz",
+ "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=",
+ "dev": true
+ }
+ }
+ },
+ "@babel/helper-function-name": {
+ "version": "7.10.4",
+ "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.10.4.tgz",
+ "integrity": "sha512-YdaSyz1n8gY44EmN7x44zBn9zQ1Ry2Y+3GTA+3vH6Mizke1Vw0aWDM66FOYEPw8//qKkmqOckrGgTYa+6sceqQ==",
+ "dev": true,
+ "requires": {
+ "@babel/helper-get-function-arity": "^7.10.4",
+ "@babel/template": "^7.10.4",
+ "@babel/types": "^7.10.4"
+ }
+ },
+ "@babel/helper-get-function-arity": {
+ "version": "7.12.10",
+ "resolved": "https://registry.npmjs.org/@babel/helper-get-function-arity/-/helper-get-function-arity-7.12.10.tgz",
+ "integrity": "sha512-mm0n5BPjR06wh9mPQaDdXWDoll/j5UpCAPl1x8fS71GHm7HA6Ua2V4ylG1Ju8lvcTOietbPNNPaSilKj+pj+Ag==",
+ "dev": true,
+ "requires": {
+ "@babel/types": "^7.12.10"
+ }
+ },
+ "@babel/helper-member-expression-to-functions": {
+ "version": "7.12.7",
+ "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.12.7.tgz",
+ "integrity": "sha512-DCsuPyeWxeHgh1Dus7APn7iza42i/qXqiFPWyBDdOFtvS581JQePsc1F/nD+fHrcswhLlRc2UpYS1NwERxZhHw==",
+ "dev": true,
+ "requires": {
+ "@babel/types": "^7.12.7"
+ }
+ },
+ "@babel/helper-module-imports": {
+ "version": "7.12.5",
+ "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.12.5.tgz",
+ "integrity": "sha512-SR713Ogqg6++uexFRORf/+nPXMmWIn80TALu0uaFb+iQIUoR7bOC7zBWyzBs5b3tBBJXuyD0cRu1F15GyzjOWA==",
+ "dev": true,
+ "requires": {
+ "@babel/types": "^7.12.5"
+ }
+ },
+ "@babel/helper-module-transforms": {
+ "version": "7.12.1",
+ "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.12.1.tgz",
+ "integrity": "sha512-QQzehgFAZ2bbISiCpmVGfiGux8YVFXQ0abBic2Envhej22DVXV9nCFaS5hIQbkyo1AdGb+gNME2TSh3hYJVV/w==",
+ "dev": true,
+ "requires": {
+ "@babel/helper-module-imports": "^7.12.1",
+ "@babel/helper-replace-supers": "^7.12.1",
+ "@babel/helper-simple-access": "^7.12.1",
+ "@babel/helper-split-export-declaration": "^7.11.0",
+ "@babel/helper-validator-identifier": "^7.10.4",
+ "@babel/template": "^7.10.4",
+ "@babel/traverse": "^7.12.1",
+ "@babel/types": "^7.12.1",
+ "lodash": "^4.17.19"
+ }
+ },
+ "@babel/helper-optimise-call-expression": {
+ "version": "7.12.10",
+ "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.12.10.tgz",
+ "integrity": "sha512-4tpbU0SrSTjjt65UMWSrUOPZTsgvPgGG4S8QSTNHacKzpS51IVWGDj0yCwyeZND/i+LSN2g/O63jEXEWm49sYQ==",
+ "dev": true,
+ "requires": {
+ "@babel/types": "^7.12.10"
+ }
+ },
+ "@babel/helper-plugin-utils": {
+ "version": "7.10.4",
+ "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.10.4.tgz",
+ "integrity": "sha512-O4KCvQA6lLiMU9l2eawBPMf1xPP8xPfB3iEQw150hOVTqj/rfXz0ThTb4HEzqQfs2Bmo5Ay8BzxfzVtBrr9dVg==",
+ "dev": true
+ },
+ "@babel/helper-replace-supers": {
+ "version": "7.12.5",
+ "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.12.5.tgz",
+ "integrity": "sha512-5YILoed0ZyIpF4gKcpZitEnXEJ9UoDRki1Ey6xz46rxOzfNMAhVIJMoune1hmPVxh40LRv1+oafz7UsWX+vyWA==",
+ "dev": true,
+ "requires": {
+ "@babel/helper-member-expression-to-functions": "^7.12.1",
+ "@babel/helper-optimise-call-expression": "^7.10.4",
+ "@babel/traverse": "^7.12.5",
+ "@babel/types": "^7.12.5"
+ }
+ },
+ "@babel/helper-simple-access": {
+ "version": "7.12.1",
+ "resolved": "https://registry.npmjs.org/@babel/helper-simple-access/-/helper-simple-access-7.12.1.tgz",
+ "integrity": "sha512-OxBp7pMrjVewSSC8fXDFrHrBcJATOOFssZwv16F3/6Xtc138GHybBfPbm9kfiqQHKhYQrlamWILwlDCeyMFEaA==",
+ "dev": true,
+ "requires": {
+ "@babel/types": "^7.12.1"
+ }
+ },
+ "@babel/helper-split-export-declaration": {
+ "version": "7.11.0",
+ "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.11.0.tgz",
+ "integrity": "sha512-74Vejvp6mHkGE+m+k5vHY93FX2cAtrw1zXrZXRlG4l410Nm9PxfEiVTn1PjDPV5SnmieiueY4AFg2xqhNFuuZg==",
+ "dev": true,
+ "requires": {
+ "@babel/types": "^7.11.0"
+ }
+ },
+ "@babel/helper-validator-identifier": {
+ "version": "7.10.4",
+ "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.10.4.tgz",
+ "integrity": "sha512-3U9y+43hz7ZM+rzG24Qe2mufW5KhvFg/NhnNph+i9mgCtdTCtMJuI1TMkrIUiK7Ix4PYlRF9I5dhqaLYA/ADXw==",
+ "dev": true
+ },
+ "@babel/helpers": {
+ "version": "7.12.5",
+ "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.12.5.tgz",
+ "integrity": "sha512-lgKGMQlKqA8meJqKsW6rUnc4MdUk35Ln0ATDqdM1a/UpARODdI4j5Y5lVfUScnSNkJcdCRAaWkspykNoFg9sJA==",
+ "dev": true,
+ "requires": {
+ "@babel/template": "^7.10.4",
+ "@babel/traverse": "^7.12.5",
+ "@babel/types": "^7.12.5"
+ }
+ },
+ "@babel/highlight": {
+ "version": "7.10.4",
+ "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.10.4.tgz",
+ "integrity": "sha512-i6rgnR/YgPEQzZZnbTHHuZdlE8qyoBNalD6F+q4vAFlcMEcqmkoG+mPqJYJCo63qPf74+Y1UZsl3l6f7/RIkmA==",
+ "dev": true,
+ "requires": {
+ "@babel/helper-validator-identifier": "^7.10.4",
+ "chalk": "^2.0.0",
+ "js-tokens": "^4.0.0"
+ },
+ "dependencies": {
+ "chalk": {
+ "version": "2.4.2",
+ "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
+ "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
+ "dev": true,
+ "requires": {
+ "ansi-styles": "^3.2.1",
+ "escape-string-regexp": "^1.0.5",
+ "supports-color": "^5.3.0"
+ }
+ }
+ }
+ },
+ "@babel/parser": {
+ "version": "7.12.10",
+ "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.12.10.tgz",
+ "integrity": "sha512-PJdRPwyoOqFAWfLytxrWwGrAxghCgh/yTNCYciOz8QgjflA7aZhECPZAa2VUedKg2+QMWkI0L9lynh2SNmNEgA==",
+ "dev": true
+ },
+ "@babel/plugin-syntax-async-generators": {
+ "version": "7.8.4",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz",
+ "integrity": "sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==",
+ "dev": true,
+ "requires": {
+ "@babel/helper-plugin-utils": "^7.8.0"
+ }
+ },
+ "@babel/plugin-syntax-bigint": {
+ "version": "7.8.3",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-bigint/-/plugin-syntax-bigint-7.8.3.tgz",
+ "integrity": "sha512-wnTnFlG+YxQm3vDxpGE57Pj0srRU4sHE/mDkt1qv2YJJSeUAec2ma4WLUnUPeKjyrfntVwe/N6dCXpU+zL3Npg==",
+ "dev": true,
+ "requires": {
+ "@babel/helper-plugin-utils": "^7.8.0"
+ }
+ },
+ "@babel/plugin-syntax-class-properties": {
+ "version": "7.12.1",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-class-properties/-/plugin-syntax-class-properties-7.12.1.tgz",
+ "integrity": "sha512-U40A76x5gTwmESz+qiqssqmeEsKvcSyvtgktrm0uzcARAmM9I1jR221f6Oq+GmHrcD+LvZDag1UTOTe2fL3TeA==",
+ "dev": true,
+ "requires": {
+ "@babel/helper-plugin-utils": "^7.10.4"
+ }
+ },
+ "@babel/plugin-syntax-import-meta": {
+ "version": "7.10.4",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-meta/-/plugin-syntax-import-meta-7.10.4.tgz",
+ "integrity": "sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==",
+ "dev": true,
+ "requires": {
+ "@babel/helper-plugin-utils": "^7.10.4"
+ }
+ },
+ "@babel/plugin-syntax-json-strings": {
+ "version": "7.8.3",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz",
+ "integrity": "sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==",
+ "dev": true,
+ "requires": {
+ "@babel/helper-plugin-utils": "^7.8.0"
+ }
+ },
+ "@babel/plugin-syntax-logical-assignment-operators": {
+ "version": "7.10.4",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-logical-assignment-operators/-/plugin-syntax-logical-assignment-operators-7.10.4.tgz",
+ "integrity": "sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==",
+ "dev": true,
+ "requires": {
+ "@babel/helper-plugin-utils": "^7.10.4"
+ }
+ },
+ "@babel/plugin-syntax-nullish-coalescing-operator": {
+ "version": "7.8.3",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-nullish-coalescing-operator/-/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz",
+ "integrity": "sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==",
+ "dev": true,
+ "requires": {
+ "@babel/helper-plugin-utils": "^7.8.0"
+ }
+ },
+ "@babel/plugin-syntax-numeric-separator": {
+ "version": "7.10.4",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-numeric-separator/-/plugin-syntax-numeric-separator-7.10.4.tgz",
+ "integrity": "sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==",
+ "dev": true,
+ "requires": {
+ "@babel/helper-plugin-utils": "^7.10.4"
+ }
+ },
+ "@babel/plugin-syntax-object-rest-spread": {
+ "version": "7.8.3",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.8.3.tgz",
+ "integrity": "sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==",
+ "dev": true,
+ "requires": {
+ "@babel/helper-plugin-utils": "^7.8.0"
+ }
+ },
+ "@babel/plugin-syntax-optional-catch-binding": {
+ "version": "7.8.3",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.8.3.tgz",
+ "integrity": "sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==",
+ "dev": true,
+ "requires": {
+ "@babel/helper-plugin-utils": "^7.8.0"
+ }
+ },
+ "@babel/plugin-syntax-optional-chaining": {
+ "version": "7.8.3",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz",
+ "integrity": "sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==",
+ "dev": true,
+ "requires": {
+ "@babel/helper-plugin-utils": "^7.8.0"
+ }
+ },
+ "@babel/plugin-syntax-top-level-await": {
+ "version": "7.12.1",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.12.1.tgz",
+ "integrity": "sha512-i7ooMZFS+a/Om0crxZodrTzNEPJHZrlMVGMTEpFAj6rYY/bKCddB0Dk/YxfPuYXOopuhKk/e1jV6h+WUU9XN3A==",
+ "dev": true,
+ "requires": {
+ "@babel/helper-plugin-utils": "^7.10.4"
+ }
+ },
+ "@babel/template": {
+ "version": "7.12.7",
+ "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.12.7.tgz",
+ "integrity": "sha512-GkDzmHS6GV7ZeXfJZ0tLRBhZcMcY0/Lnb+eEbXDBfCAcZCjrZKe6p3J4we/D24O9Y8enxWAg1cWwof59yLh2ow==",
+ "dev": true,
+ "requires": {
+ "@babel/code-frame": "^7.10.4",
+ "@babel/parser": "^7.12.7",
+ "@babel/types": "^7.12.7"
+ }
+ },
+ "@babel/traverse": {
+ "version": "7.12.10",
+ "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.12.10.tgz",
+ "integrity": "sha512-6aEtf0IeRgbYWzta29lePeYSk+YAFIC3kyqESeft8o5CkFlYIMX+EQDDWEiAQ9LHOA3d0oHdgrSsID/CKqXJlg==",
+ "dev": true,
+ "requires": {
+ "@babel/code-frame": "^7.10.4",
+ "@babel/generator": "^7.12.10",
+ "@babel/helper-function-name": "^7.10.4",
+ "@babel/helper-split-export-declaration": "^7.11.0",
+ "@babel/parser": "^7.12.10",
+ "@babel/types": "^7.12.10",
+ "debug": "^4.1.0",
+ "globals": "^11.1.0",
+ "lodash": "^4.17.19"
+ },
+ "dependencies": {
+ "globals": {
+ "version": "11.12.0",
+ "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz",
+ "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==",
+ "dev": true
+ }
+ }
+ },
+ "@babel/types": {
+ "version": "7.12.10",
+ "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.12.10.tgz",
+ "integrity": "sha512-sf6wboJV5mGyip2hIpDSKsr80RszPinEFjsHTalMxZAZkoQ2/2yQzxlcFN52SJqsyPfLtPmenL4g2KB3KJXPDw==",
+ "dev": true,
+ "requires": {
+ "@babel/helper-validator-identifier": "^7.10.4",
+ "lodash": "^4.17.19",
+ "to-fast-properties": "^2.0.0"
+ }
+ },
+ "@bcoe/v8-coverage": {
+ "version": "0.2.3",
+ "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz",
+ "integrity": "sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==",
+ "dev": true
+ },
+ "@cnakazawa/watch": {
+ "version": "1.0.4",
+ "resolved": "https://registry.npmjs.org/@cnakazawa/watch/-/watch-1.0.4.tgz",
+ "integrity": "sha512-v9kIhKwjeZThiWrLmj0y17CWoyddASLj9O2yvbZkbvw/N3rWOYy9zkV66ursAoVr0mV15bL8g0c4QZUE6cdDoQ==",
+ "dev": true,
+ "requires": {
+ "exec-sh": "^0.3.2",
+ "minimist": "^1.2.0"
+ }
+ },
+ "@eslint/eslintrc": {
+ "version": "0.2.2",
+ "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-0.2.2.tgz",
+ "integrity": "sha512-EfB5OHNYp1F4px/LI/FEnGylop7nOqkQ1LRzCM0KccA2U8tvV8w01KBv37LbO7nW4H+YhKyo2LcJhRwjjV17QQ==",
+ "dev": true,
+ "requires": {
+ "ajv": "^6.12.4",
+ "debug": "^4.1.1",
+ "espree": "^7.3.0",
+ "globals": "^12.1.0",
+ "ignore": "^4.0.6",
+ "import-fresh": "^3.2.1",
+ "js-yaml": "^3.13.1",
+ "lodash": "^4.17.19",
+ "minimatch": "^3.0.4",
+ "strip-json-comments": "^3.1.1"
+ },
+ "dependencies": {
+ "ignore": {
+ "version": "4.0.6",
+ "resolved": "https://registry.npmjs.org/ignore/-/ignore-4.0.6.tgz",
+ "integrity": "sha512-cyFDKrqc/YdcWFniJhzI42+AzS+gNwmUzOSFcRCQYwySuBBBy/KjuxWLZ/FHEH6Moq1NizMOBWyTcv8O4OZIMg==",
+ "dev": true
+ }
+ }
+ },
+ "@istanbuljs/load-nyc-config": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/@istanbuljs/load-nyc-config/-/load-nyc-config-1.1.0.tgz",
+ "integrity": "sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==",
+ "dev": true,
+ "requires": {
+ "camelcase": "^5.3.1",
+ "find-up": "^4.1.0",
+ "get-package-type": "^0.1.0",
+ "js-yaml": "^3.13.1",
+ "resolve-from": "^5.0.0"
+ },
+ "dependencies": {
+ "resolve-from": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz",
+ "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==",
+ "dev": true
+ }
+ }
+ },
+ "@istanbuljs/schema": {
+ "version": "0.1.2",
+ "resolved": "https://registry.npmjs.org/@istanbuljs/schema/-/schema-0.1.2.tgz",
+ "integrity": "sha512-tsAQNx32a8CoFhjhijUIhI4kccIAgmGhy8LZMZgGfmXcpMbPRUqn5LWmgRttILi6yeGmBJd2xsPkFMs0PzgPCw==",
+ "dev": true
+ },
+ "@jest/console": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/@jest/console/-/console-26.6.2.tgz",
+ "integrity": "sha512-IY1R2i2aLsLr7Id3S6p2BA82GNWryt4oSvEXLAKc+L2zdi89dSkE8xC1C+0kpATG4JhBJREnQOH7/zmccM2B0g==",
+ "dev": true,
+ "requires": {
+ "@jest/types": "^26.6.2",
+ "@types/node": "*",
+ "chalk": "^4.0.0",
+ "jest-message-util": "^26.6.2",
+ "jest-util": "^26.6.2",
+ "slash": "^3.0.0"
+ }
+ },
+ "@jest/core": {
+ "version": "26.6.3",
+ "resolved": "https://registry.npmjs.org/@jest/core/-/core-26.6.3.tgz",
+ "integrity": "sha512-xvV1kKbhfUqFVuZ8Cyo+JPpipAHHAV3kcDBftiduK8EICXmTFddryy3P7NfZt8Pv37rA9nEJBKCCkglCPt/Xjw==",
+ "dev": true,
+ "requires": {
+ "@jest/console": "^26.6.2",
+ "@jest/reporters": "^26.6.2",
+ "@jest/test-result": "^26.6.2",
+ "@jest/transform": "^26.6.2",
+ "@jest/types": "^26.6.2",
+ "@types/node": "*",
+ "ansi-escapes": "^4.2.1",
+ "chalk": "^4.0.0",
+ "exit": "^0.1.2",
+ "graceful-fs": "^4.2.4",
+ "jest-changed-files": "^26.6.2",
+ "jest-config": "^26.6.3",
+ "jest-haste-map": "^26.6.2",
+ "jest-message-util": "^26.6.2",
+ "jest-regex-util": "^26.0.0",
+ "jest-resolve": "^26.6.2",
+ "jest-resolve-dependencies": "^26.6.3",
+ "jest-runner": "^26.6.3",
+ "jest-runtime": "^26.6.3",
+ "jest-snapshot": "^26.6.2",
+ "jest-util": "^26.6.2",
+ "jest-validate": "^26.6.2",
+ "jest-watcher": "^26.6.2",
+ "micromatch": "^4.0.2",
+ "p-each-series": "^2.1.0",
+ "rimraf": "^3.0.0",
+ "slash": "^3.0.0",
+ "strip-ansi": "^6.0.0"
+ }
+ },
+ "@jest/environment": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/@jest/environment/-/environment-26.6.2.tgz",
+ "integrity": "sha512-nFy+fHl28zUrRsCeMB61VDThV1pVTtlEokBRgqPrcT1JNq4yRNIyTHfyht6PqtUvY9IsuLGTrbG8kPXjSZIZwA==",
+ "dev": true,
+ "requires": {
+ "@jest/fake-timers": "^26.6.2",
+ "@jest/types": "^26.6.2",
+ "@types/node": "*",
+ "jest-mock": "^26.6.2"
+ }
+ },
+ "@jest/fake-timers": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/@jest/fake-timers/-/fake-timers-26.6.2.tgz",
+ "integrity": "sha512-14Uleatt7jdzefLPYM3KLcnUl1ZNikaKq34enpb5XG9i81JpppDb5muZvonvKyrl7ftEHkKS5L5/eB/kxJ+bvA==",
+ "dev": true,
+ "requires": {
+ "@jest/types": "^26.6.2",
+ "@sinonjs/fake-timers": "^6.0.1",
+ "@types/node": "*",
+ "jest-message-util": "^26.6.2",
+ "jest-mock": "^26.6.2",
+ "jest-util": "^26.6.2"
+ }
+ },
+ "@jest/globals": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/@jest/globals/-/globals-26.6.2.tgz",
+ "integrity": "sha512-85Ltnm7HlB/KesBUuALwQ68YTU72w9H2xW9FjZ1eL1U3lhtefjjl5c2MiUbpXt/i6LaPRvoOFJ22yCBSfQ0JIA==",
+ "dev": true,
+ "requires": {
+ "@jest/environment": "^26.6.2",
+ "@jest/types": "^26.6.2",
+ "expect": "^26.6.2"
+ }
+ },
+ "@jest/reporters": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/@jest/reporters/-/reporters-26.6.2.tgz",
+ "integrity": "sha512-h2bW53APG4HvkOnVMo8q3QXa6pcaNt1HkwVsOPMBV6LD/q9oSpxNSYZQYkAnjdMjrJ86UuYeLo+aEZClV6opnw==",
+ "dev": true,
+ "requires": {
+ "@bcoe/v8-coverage": "^0.2.3",
+ "@jest/console": "^26.6.2",
+ "@jest/test-result": "^26.6.2",
+ "@jest/transform": "^26.6.2",
+ "@jest/types": "^26.6.2",
+ "chalk": "^4.0.0",
+ "collect-v8-coverage": "^1.0.0",
+ "exit": "^0.1.2",
+ "glob": "^7.1.2",
+ "graceful-fs": "^4.2.4",
+ "istanbul-lib-coverage": "^3.0.0",
+ "istanbul-lib-instrument": "^4.0.3",
+ "istanbul-lib-report": "^3.0.0",
+ "istanbul-lib-source-maps": "^4.0.0",
+ "istanbul-reports": "^3.0.2",
+ "jest-haste-map": "^26.6.2",
+ "jest-resolve": "^26.6.2",
+ "jest-util": "^26.6.2",
+ "jest-worker": "^26.6.2",
+ "node-notifier": "^8.0.0",
+ "slash": "^3.0.0",
+ "source-map": "^0.6.0",
+ "string-length": "^4.0.1",
+ "terminal-link": "^2.0.0",
+ "v8-to-istanbul": "^7.0.0"
+ }
+ },
+ "@jest/source-map": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/@jest/source-map/-/source-map-26.6.2.tgz",
+ "integrity": "sha512-YwYcCwAnNmOVsZ8mr3GfnzdXDAl4LaenZP5z+G0c8bzC9/dugL8zRmxZzdoTl4IaS3CryS1uWnROLPFmb6lVvA==",
+ "dev": true,
+ "requires": {
+ "callsites": "^3.0.0",
+ "graceful-fs": "^4.2.4",
+ "source-map": "^0.6.0"
+ }
+ },
+ "@jest/test-result": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/@jest/test-result/-/test-result-26.6.2.tgz",
+ "integrity": "sha512-5O7H5c/7YlojphYNrK02LlDIV2GNPYisKwHm2QTKjNZeEzezCbwYs9swJySv2UfPMyZ0VdsmMv7jIlD/IKYQpQ==",
+ "dev": true,
+ "requires": {
+ "@jest/console": "^26.6.2",
+ "@jest/types": "^26.6.2",
+ "@types/istanbul-lib-coverage": "^2.0.0",
+ "collect-v8-coverage": "^1.0.0"
+ }
+ },
+ "@jest/test-sequencer": {
+ "version": "26.6.3",
+ "resolved": "https://registry.npmjs.org/@jest/test-sequencer/-/test-sequencer-26.6.3.tgz",
+ "integrity": "sha512-YHlVIjP5nfEyjlrSr8t/YdNfU/1XEt7c5b4OxcXCjyRhjzLYu/rO69/WHPuYcbCWkz8kAeZVZp2N2+IOLLEPGw==",
+ "dev": true,
+ "requires": {
+ "@jest/test-result": "^26.6.2",
+ "graceful-fs": "^4.2.4",
+ "jest-haste-map": "^26.6.2",
+ "jest-runner": "^26.6.3",
+ "jest-runtime": "^26.6.3"
+ }
+ },
+ "@jest/transform": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/@jest/transform/-/transform-26.6.2.tgz",
+ "integrity": "sha512-E9JjhUgNzvuQ+vVAL21vlyfy12gP0GhazGgJC4h6qUt1jSdUXGWJ1wfu/X7Sd8etSgxV4ovT1pb9v5D6QW4XgA==",
+ "dev": true,
+ "requires": {
+ "@babel/core": "^7.1.0",
+ "@jest/types": "^26.6.2",
+ "babel-plugin-istanbul": "^6.0.0",
+ "chalk": "^4.0.0",
+ "convert-source-map": "^1.4.0",
+ "fast-json-stable-stringify": "^2.0.0",
+ "graceful-fs": "^4.2.4",
+ "jest-haste-map": "^26.6.2",
+ "jest-regex-util": "^26.0.0",
+ "jest-util": "^26.6.2",
+ "micromatch": "^4.0.2",
+ "pirates": "^4.0.1",
+ "slash": "^3.0.0",
+ "source-map": "^0.6.1",
+ "write-file-atomic": "^3.0.0"
+ }
+ },
+ "@jest/types": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/@jest/types/-/types-26.6.2.tgz",
+ "integrity": "sha512-fC6QCp7Sc5sX6g8Tvbmj4XUTbyrik0akgRy03yjXbQaBWWNWGE7SGtJk98m0N8nzegD/7SggrUlivxo5ax4KWQ==",
+ "dev": true,
+ "requires": {
+ "@types/istanbul-lib-coverage": "^2.0.0",
+ "@types/istanbul-reports": "^3.0.0",
+ "@types/node": "*",
+ "@types/yargs": "^15.0.0",
+ "chalk": "^4.0.0"
+ }
+ },
+ "@nodelib/fs.scandir": {
+ "version": "2.1.3",
+ "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.3.tgz",
+ "integrity": "sha512-eGmwYQn3gxo4r7jdQnkrrN6bY478C3P+a/y72IJukF8LjB6ZHeB3c+Ehacj3sYeSmUXGlnA67/PmbM9CVwL7Dw==",
+ "dev": true,
+ "requires": {
+ "@nodelib/fs.stat": "2.0.3",
+ "run-parallel": "^1.1.9"
+ }
+ },
+ "@nodelib/fs.stat": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.3.tgz",
+ "integrity": "sha512-bQBFruR2TAwoevBEd/NWMoAAtNGzTRgdrqnYCc7dhzfoNvqPzLyqlEQnzZ3kVnNrSp25iyxE00/3h2fqGAGArA==",
+ "dev": true
+ },
+ "@nodelib/fs.walk": {
+ "version": "1.2.4",
+ "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.4.tgz",
+ "integrity": "sha512-1V9XOY4rDW0rehzbrcqAmHnz8e7SKvX27gh8Gt2WgB0+pdzdiLV83p72kZPU+jvMbS1qU5mauP2iOvO8rhmurQ==",
+ "dev": true,
+ "requires": {
+ "@nodelib/fs.scandir": "2.1.3",
+ "fastq": "^1.6.0"
+ }
+ },
+ "@sinonjs/commons": {
+ "version": "1.8.1",
+ "resolved": "https://registry.npmjs.org/@sinonjs/commons/-/commons-1.8.1.tgz",
+ "integrity": "sha512-892K+kWUUi3cl+LlqEWIDrhvLgdL79tECi8JZUyq6IviKy/DNhuzCRlbHUjxK89f4ypPMMaFnFuR9Ie6DoIMsw==",
+ "dev": true,
+ "requires": {
+ "type-detect": "4.0.8"
+ }
+ },
+ "@sinonjs/fake-timers": {
+ "version": "6.0.1",
+ "resolved": "https://registry.npmjs.org/@sinonjs/fake-timers/-/fake-timers-6.0.1.tgz",
+ "integrity": "sha512-MZPUxrmFubI36XS1DI3qmI0YdN1gks62JtFZvxR67ljjSNCeK6U08Zx4msEWOXuofgqUt6zPHSi1H9fbjR/NRA==",
+ "dev": true,
+ "requires": {
+ "@sinonjs/commons": "^1.7.0"
+ }
+ },
+ "@types/babel__core": {
+ "version": "7.1.12",
+ "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.1.12.tgz",
+ "integrity": "sha512-wMTHiiTiBAAPebqaPiPDLFA4LYPKr6Ph0Xq/6rq1Ur3v66HXyG+clfR9CNETkD7MQS8ZHvpQOtA53DLws5WAEQ==",
+ "dev": true,
+ "requires": {
+ "@babel/parser": "^7.1.0",
+ "@babel/types": "^7.0.0",
+ "@types/babel__generator": "*",
+ "@types/babel__template": "*",
+ "@types/babel__traverse": "*"
+ }
+ },
+ "@types/babel__generator": {
+ "version": "7.6.2",
+ "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.6.2.tgz",
+ "integrity": "sha512-MdSJnBjl+bdwkLskZ3NGFp9YcXGx5ggLpQQPqtgakVhsWK0hTtNYhjpZLlWQTviGTvF8at+Bvli3jV7faPdgeQ==",
+ "dev": true,
+ "requires": {
+ "@babel/types": "^7.0.0"
+ }
+ },
+ "@types/babel__template": {
+ "version": "7.4.0",
+ "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.0.tgz",
+ "integrity": "sha512-NTPErx4/FiPCGScH7foPyr+/1Dkzkni+rHiYHHoTjvwou7AQzJkNeD60A9CXRy+ZEN2B1bggmkTMCDb+Mv5k+A==",
+ "dev": true,
+ "requires": {
+ "@babel/parser": "^7.1.0",
+ "@babel/types": "^7.0.0"
+ }
+ },
+ "@types/babel__traverse": {
+ "version": "7.11.0",
+ "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.11.0.tgz",
+ "integrity": "sha512-kSjgDMZONiIfSH1Nxcr5JIRMwUetDki63FSQfpTCz8ogF3Ulqm8+mr5f78dUYs6vMiB6gBusQqfQmBvHZj/lwg==",
+ "dev": true,
+ "requires": {
+ "@babel/types": "^7.3.0"
+ }
+ },
+ "@types/graceful-fs": {
+ "version": "4.1.4",
+ "resolved": "https://registry.npmjs.org/@types/graceful-fs/-/graceful-fs-4.1.4.tgz",
+ "integrity": "sha512-mWA/4zFQhfvOA8zWkXobwJvBD7vzcxgrOQ0J5CH1votGqdq9m7+FwtGaqyCZqC3NyyBkc9z4m+iry4LlqcMWJg==",
+ "dev": true,
+ "requires": {
+ "@types/node": "*"
+ }
+ },
+ "@types/istanbul-lib-coverage": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.3.tgz",
+ "integrity": "sha512-sz7iLqvVUg1gIedBOvlkxPlc8/uVzyS5OwGz1cKjXzkl3FpL3al0crU8YGU1WoHkxn0Wxbw5tyi6hvzJKNzFsw==",
+ "dev": true
+ },
+ "@types/istanbul-lib-report": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/@types/istanbul-lib-report/-/istanbul-lib-report-3.0.0.tgz",
+ "integrity": "sha512-plGgXAPfVKFoYfa9NpYDAkseG+g6Jr294RqeqcqDixSbU34MZVJRi/P+7Y8GDpzkEwLaGZZOpKIEmeVZNtKsrg==",
+ "dev": true,
+ "requires": {
+ "@types/istanbul-lib-coverage": "*"
+ }
+ },
+ "@types/istanbul-reports": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/@types/istanbul-reports/-/istanbul-reports-3.0.0.tgz",
+ "integrity": "sha512-nwKNbvnwJ2/mndE9ItP/zc2TCzw6uuodnF4EHYWD+gCQDVBuRQL5UzbZD0/ezy1iKsFU2ZQiDqg4M9dN4+wZgA==",
+ "dev": true,
+ "requires": {
+ "@types/istanbul-lib-report": "*"
+ }
+ },
+ "@types/jest": {
+ "version": "26.0.19",
+ "resolved": "https://registry.npmjs.org/@types/jest/-/jest-26.0.19.tgz",
+ "integrity": "sha512-jqHoirTG61fee6v6rwbnEuKhpSKih0tuhqeFbCmMmErhtu3BYlOZaXWjffgOstMM4S/3iQD31lI5bGLTrs97yQ==",
+ "dev": true,
+ "requires": {
+ "jest-diff": "^26.0.0",
+ "pretty-format": "^26.0.0"
+ }
+ },
+ "@types/json-schema": {
+ "version": "7.0.6",
+ "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.6.tgz",
+ "integrity": "sha512-3c+yGKvVP5Y9TYBEibGNR+kLtijnj7mYrXRg+WpFb2X9xm04g/DXYkfg4hmzJQosc9snFNUPkbYIhu+KAm6jJw==",
+ "dev": true
+ },
+ "@types/node": {
+ "version": "14.14.10",
+ "resolved": "https://registry.npmjs.org/@types/node/-/node-14.14.10.tgz",
+ "integrity": "sha512-J32dgx2hw8vXrSbu4ZlVhn1Nm3GbeCFNw2FWL8S5QKucHGY0cyNwjdQdO+KMBZ4wpmC7KhLCiNsdk1RFRIYUQQ==",
+ "dev": true
+ },
+ "@types/normalize-package-data": {
+ "version": "2.4.0",
+ "resolved": "https://registry.npmjs.org/@types/normalize-package-data/-/normalize-package-data-2.4.0.tgz",
+ "integrity": "sha512-f5j5b/Gf71L+dbqxIpQ4Z2WlmI/mPJ0fOkGGmFgtb6sAu97EPczzbS3/tJKxmcYDj55OX6ssqwDAWOHIYDRDGA==",
+ "dev": true
+ },
+ "@types/prettier": {
+ "version": "2.1.5",
+ "resolved": "https://registry.npmjs.org/@types/prettier/-/prettier-2.1.5.tgz",
+ "integrity": "sha512-UEyp8LwZ4Dg30kVU2Q3amHHyTn1jEdhCIE59ANed76GaT1Vp76DD3ZWSAxgCrw6wJ0TqeoBpqmfUHiUDPs//HQ==",
+ "dev": true
+ },
+ "@types/stack-utils": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/@types/stack-utils/-/stack-utils-2.0.0.tgz",
+ "integrity": "sha512-RJJrrySY7A8havqpGObOB4W92QXKJo63/jFLLgpvOtsGUqbQZ9Sbgl35KMm1DjC6j7AvmmU2bIno+3IyEaemaw==",
+ "dev": true
+ },
+ "@types/yargs": {
+ "version": "15.0.11",
+ "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-15.0.11.tgz",
+ "integrity": "sha512-jfcNBxHFYJ4nPIacsi3woz1+kvUO6s1CyeEhtnDHBjHUMNj5UlW2GynmnSgiJJEdNg9yW5C8lfoNRZrHGv5EqA==",
+ "dev": true,
+ "requires": {
+ "@types/yargs-parser": "*"
+ }
+ },
+ "@types/yargs-parser": {
+ "version": "15.0.0",
+ "resolved": "https://registry.npmjs.org/@types/yargs-parser/-/yargs-parser-15.0.0.tgz",
+ "integrity": "sha512-FA/BWv8t8ZWJ+gEOnLLd8ygxH/2UFbAvgEonyfN6yWGLKc7zVjbpl2Y4CTjid9h2RfgPP6SEt6uHwEOply00yw==",
+ "dev": true
+ },
+ "@typescript-eslint/eslint-plugin": {
+ "version": "4.9.1",
+ "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-4.9.1.tgz",
+ "integrity": "sha512-QRLDSvIPeI1pz5tVuurD+cStNR4sle4avtHhxA+2uyixWGFjKzJ+EaFVRW6dA/jOgjV5DTAjOxboQkRDE8cRlQ==",
+ "dev": true,
+ "requires": {
+ "@typescript-eslint/experimental-utils": "4.9.1",
+ "@typescript-eslint/scope-manager": "4.9.1",
+ "debug": "^4.1.1",
+ "functional-red-black-tree": "^1.0.1",
+ "regexpp": "^3.0.0",
+ "semver": "^7.3.2",
+ "tsutils": "^3.17.1"
+ }
+ },
+ "@typescript-eslint/experimental-utils": {
+ "version": "4.9.1",
+ "resolved": "https://registry.npmjs.org/@typescript-eslint/experimental-utils/-/experimental-utils-4.9.1.tgz",
+ "integrity": "sha512-c3k/xJqk0exLFs+cWSJxIjqLYwdHCuLWhnpnikmPQD2+NGAx9KjLYlBDcSI81EArh9FDYSL6dslAUSwILeWOxg==",
+ "dev": true,
+ "requires": {
+ "@types/json-schema": "^7.0.3",
+ "@typescript-eslint/scope-manager": "4.9.1",
+ "@typescript-eslint/types": "4.9.1",
+ "@typescript-eslint/typescript-estree": "4.9.1",
+ "eslint-scope": "^5.0.0",
+ "eslint-utils": "^2.0.0"
+ }
+ },
+ "@typescript-eslint/parser": {
+ "version": "4.9.1",
+ "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-4.9.1.tgz",
+ "integrity": "sha512-Gv2VpqiomvQ2v4UL+dXlQcZ8zCX4eTkoIW+1aGVWT6yTO+6jbxsw7yQl2z2pPl/4B9qa5JXeIbhJpONKjXIy3g==",
+ "dev": true,
+ "requires": {
+ "@typescript-eslint/scope-manager": "4.9.1",
+ "@typescript-eslint/types": "4.9.1",
+ "@typescript-eslint/typescript-estree": "4.9.1",
+ "debug": "^4.1.1"
+ }
+ },
+ "@typescript-eslint/scope-manager": {
+ "version": "4.9.1",
+ "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-4.9.1.tgz",
+ "integrity": "sha512-sa4L9yUfD/1sg9Kl8OxPxvpUcqxKXRjBeZxBuZSSV1v13hjfEJkn84n0An2hN8oLQ1PmEl2uA6FkI07idXeFgQ==",
+ "dev": true,
+ "requires": {
+ "@typescript-eslint/types": "4.9.1",
+ "@typescript-eslint/visitor-keys": "4.9.1"
+ }
+ },
+ "@typescript-eslint/types": {
+ "version": "4.9.1",
+ "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-4.9.1.tgz",
+ "integrity": "sha512-fjkT+tXR13ks6Le7JiEdagnwEFc49IkOyys7ueWQ4O8k4quKPwPJudrwlVOJCUQhXo45PrfIvIarcrEjFTNwUA==",
+ "dev": true
+ },
+ "@typescript-eslint/typescript-estree": {
+ "version": "4.9.1",
+ "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-4.9.1.tgz",
+ "integrity": "sha512-bzP8vqwX6Vgmvs81bPtCkLtM/Skh36NE6unu6tsDeU/ZFoYthlTXbBmpIrvosgiDKlWTfb2ZpPELHH89aQjeQw==",
+ "dev": true,
+ "requires": {
+ "@typescript-eslint/types": "4.9.1",
+ "@typescript-eslint/visitor-keys": "4.9.1",
+ "debug": "^4.1.1",
+ "globby": "^11.0.1",
+ "is-glob": "^4.0.1",
+ "lodash": "^4.17.15",
+ "semver": "^7.3.2",
+ "tsutils": "^3.17.1"
+ }
+ },
+ "@typescript-eslint/visitor-keys": {
+ "version": "4.9.1",
+ "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-4.9.1.tgz",
+ "integrity": "sha512-9gspzc6UqLQHd7lXQS7oWs+hrYggspv/rk6zzEMhCbYwPE/sF7oxo7GAjkS35Tdlt7wguIG+ViWCPtVZHz/ybQ==",
+ "dev": true,
+ "requires": {
+ "@typescript-eslint/types": "4.9.1",
+ "eslint-visitor-keys": "^2.0.0"
+ }
+ },
+ "@vercel/ncc": {
+ "version": "0.25.1",
+ "resolved": "https://registry.npmjs.org/@vercel/ncc/-/ncc-0.25.1.tgz",
+ "integrity": "sha512-dGecC5+1wLof1MQpey4+6i2KZv4Sfs6WfXkl9KfO32GED4ZPiKxRfvtGPjbjZv0IbqMl6CxtcV1RotXYfd5SSA==",
+ "dev": true
+ },
+ "abab": {
+ "version": "2.0.5",
+ "resolved": "https://registry.npmjs.org/abab/-/abab-2.0.5.tgz",
+ "integrity": "sha512-9IK9EadsbHo6jLWIpxpR6pL0sazTXV6+SQv25ZB+F7Bj9mJNaOc4nCRabwd5M/JwmUa8idz6Eci6eKfJryPs6Q==",
+ "dev": true
+ },
+ "acorn": {
+ "version": "7.4.1",
+ "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.4.1.tgz",
+ "integrity": "sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A==",
+ "dev": true
+ },
+ "acorn-globals": {
+ "version": "6.0.0",
+ "resolved": "https://registry.npmjs.org/acorn-globals/-/acorn-globals-6.0.0.tgz",
+ "integrity": "sha512-ZQl7LOWaF5ePqqcX4hLuv/bLXYQNfNWw2c0/yX/TsPRKamzHcTGQnlCjHT3TsmkOUVEPS3crCxiPfdzE/Trlhg==",
+ "dev": true,
+ "requires": {
+ "acorn": "^7.1.1",
+ "acorn-walk": "^7.1.1"
+ }
+ },
+ "acorn-jsx": {
+ "version": "5.3.1",
+ "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.1.tgz",
+ "integrity": "sha512-K0Ptm/47OKfQRpNQ2J/oIN/3QYiK6FwW+eJbILhsdxh2WTLdl+30o8aGdTbm5JbffpFFAg/g+zi1E+jvJha5ng==",
+ "dev": true
+ },
+ "acorn-walk": {
+ "version": "7.2.0",
+ "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-7.2.0.tgz",
+ "integrity": "sha512-OPdCF6GsMIP+Az+aWfAAOEt2/+iVDKE7oy6lJ098aoe59oAmK76qV6Gw60SbZ8jHuG2wH058GF4pLFbYamYrVA==",
+ "dev": true
+ },
+ "aggregate-error": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/aggregate-error/-/aggregate-error-3.1.0.tgz",
+ "integrity": "sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==",
+ "dev": true,
+ "requires": {
+ "clean-stack": "^2.0.0",
+ "indent-string": "^4.0.0"
+ }
+ },
+ "ajv": {
+ "version": "6.12.6",
+ "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
+ "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
+ "dev": true,
+ "requires": {
+ "fast-deep-equal": "^3.1.1",
+ "fast-json-stable-stringify": "^2.0.0",
+ "json-schema-traverse": "^0.4.1",
+ "uri-js": "^4.2.2"
+ }
+ },
+ "ansi-colors": {
+ "version": "4.1.1",
+ "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.1.tgz",
+ "integrity": "sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==",
+ "dev": true
+ },
+ "ansi-escapes": {
+ "version": "4.3.1",
+ "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.1.tgz",
+ "integrity": "sha512-JWF7ocqNrp8u9oqpgV+wH5ftbt+cfvv+PTjOvKLT3AdYly/LmORARfEVT1iyjwN+4MqE5UmVKoAdIBqeoCHgLA==",
+ "dev": true,
+ "requires": {
+ "type-fest": "^0.11.0"
+ },
+ "dependencies": {
+ "type-fest": {
+ "version": "0.11.0",
+ "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.11.0.tgz",
+ "integrity": "sha512-OdjXJxnCN1AvyLSzeKIgXTXxV+99ZuXl3Hpo9XpJAv9MBcHrrJOQ5kV7ypXOuQie+AmWG25hLbiKdwYTifzcfQ==",
+ "dev": true
+ }
+ }
+ },
+ "ansi-regex": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.0.tgz",
+ "integrity": "sha512-bY6fj56OUQ0hU1KjFNDQuJFezqKdrAyFdIevADiqrWHwSlbmBNMHp5ak2f40Pm8JTFyM2mqxkG6ngkHO11f/lg==",
+ "dev": true
+ },
+ "ansi-styles": {
+ "version": "3.2.1",
+ "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
+ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
+ "dev": true,
+ "requires": {
+ "color-convert": "^1.9.0"
+ }
+ },
+ "anymatch": {
+ "version": "3.1.1",
+ "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.1.tgz",
+ "integrity": "sha512-mM8522psRCqzV+6LhomX5wgp25YVibjh8Wj23I5RPkPppSVSjyKD2A2mBJmWGa+KN7f2D6LNh9jkBCeyLktzjg==",
+ "dev": true,
+ "requires": {
+ "normalize-path": "^3.0.0",
+ "picomatch": "^2.0.4"
+ }
+ },
+ "argparse": {
+ "version": "1.0.10",
+ "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz",
+ "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
+ "dev": true,
+ "requires": {
+ "sprintf-js": "~1.0.2"
+ }
+ },
+ "arr-diff": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-4.0.0.tgz",
+ "integrity": "sha1-1kYQdP6/7HHn4VI1dhoyml3HxSA=",
+ "dev": true
+ },
+ "arr-flatten": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/arr-flatten/-/arr-flatten-1.1.0.tgz",
+ "integrity": "sha512-L3hKV5R/p5o81R7O02IGnwpDmkp6E982XhtbuwSe3O4qOtMMMtodicASA1Cny2U+aCXcNpml+m4dPsvsJ3jatg==",
+ "dev": true
+ },
+ "arr-union": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/arr-union/-/arr-union-3.1.0.tgz",
+ "integrity": "sha1-45sJrqne+Gao8gbiiK9jkZuuOcQ=",
+ "dev": true
+ },
+ "array-union": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz",
+ "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==",
+ "dev": true
+ },
+ "array-unique": {
+ "version": "0.3.2",
+ "resolved": "https://registry.npmjs.org/array-unique/-/array-unique-0.3.2.tgz",
+ "integrity": "sha1-qJS3XUvE9s1nnvMkSp/Y9Gri1Cg=",
+ "dev": true
+ },
+ "asn1": {
+ "version": "0.2.4",
+ "resolved": "https://registry.npmjs.org/asn1/-/asn1-0.2.4.tgz",
+ "integrity": "sha512-jxwzQpLQjSmWXgwaCZE9Nz+glAG01yF1QnWgbhGwHI5A6FRIEY6IVqtHhIepHqI7/kyEyQEagBC5mBEFlIYvdg==",
+ "dev": true,
+ "requires": {
+ "safer-buffer": "~2.1.0"
+ }
+ },
+ "assert-plus": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz",
+ "integrity": "sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU=",
+ "dev": true
+ },
+ "assign-symbols": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/assign-symbols/-/assign-symbols-1.0.0.tgz",
+ "integrity": "sha1-WWZ/QfrdTyDMvCu5a41Pf3jsA2c=",
+ "dev": true
+ },
+ "astral-regex": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/astral-regex/-/astral-regex-1.0.0.tgz",
+ "integrity": "sha512-+Ryf6g3BKoRc7jfp7ad8tM4TtMiaWvbF/1/sQcZPkkS7ag3D5nMBCe2UfOTONtAkaG0tO0ij3C5Lwmf1EiyjHg==",
+ "dev": true
+ },
+ "asynckit": {
+ "version": "0.4.0",
+ "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+ "integrity": "sha1-x57Zf380y48robyXkLzDZkdLS3k=",
+ "dev": true
+ },
+ "atob": {
+ "version": "2.1.2",
+ "resolved": "https://registry.npmjs.org/atob/-/atob-2.1.2.tgz",
+ "integrity": "sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg==",
+ "dev": true
+ },
+ "aws-sign2": {
+ "version": "0.7.0",
+ "resolved": "https://registry.npmjs.org/aws-sign2/-/aws-sign2-0.7.0.tgz",
+ "integrity": "sha1-tG6JCTSpWR8tL2+G1+ap8bP+dqg=",
+ "dev": true
+ },
+ "aws4": {
+ "version": "1.11.0",
+ "resolved": "https://registry.npmjs.org/aws4/-/aws4-1.11.0.tgz",
+ "integrity": "sha512-xh1Rl34h6Fi1DC2WWKfxUTVqRsNnr6LsKz2+hfwDxQJWmrx8+c7ylaqBMcHfl1U1r2dsifOvKX3LQuLNZ+XSvA==",
+ "dev": true
+ },
+ "axios": {
+ "version": "0.21.0",
+ "resolved": "https://registry.npmjs.org/axios/-/axios-0.21.0.tgz",
+ "integrity": "sha512-fmkJBknJKoZwem3/IKSSLpkdNXZeBu5Q7GA/aRsr2btgrptmSCxi2oFjZHqGdK9DoTil9PIHlPIZw2EcRJXRvw==",
+ "requires": {
+ "follow-redirects": "^1.10.0"
+ }
+ },
+ "babel-jest": {
+ "version": "26.6.3",
+ "resolved": "https://registry.npmjs.org/babel-jest/-/babel-jest-26.6.3.tgz",
+ "integrity": "sha512-pl4Q+GAVOHwvjrck6jKjvmGhnO3jHX/xuB9d27f+EJZ/6k+6nMuPjorrYp7s++bKKdANwzElBWnLWaObvTnaZA==",
+ "dev": true,
+ "requires": {
+ "@jest/transform": "^26.6.2",
+ "@jest/types": "^26.6.2",
+ "@types/babel__core": "^7.1.7",
+ "babel-plugin-istanbul": "^6.0.0",
+ "babel-preset-jest": "^26.6.2",
+ "chalk": "^4.0.0",
+ "graceful-fs": "^4.2.4",
+ "slash": "^3.0.0"
+ }
+ },
+ "babel-plugin-istanbul": {
+ "version": "6.0.0",
+ "resolved": "https://registry.npmjs.org/babel-plugin-istanbul/-/babel-plugin-istanbul-6.0.0.tgz",
+ "integrity": "sha512-AF55rZXpe7trmEylbaE1Gv54wn6rwU03aptvRoVIGP8YykoSxqdVLV1TfwflBCE/QtHmqtP8SWlTENqbK8GCSQ==",
+ "dev": true,
+ "requires": {
+ "@babel/helper-plugin-utils": "^7.0.0",
+ "@istanbuljs/load-nyc-config": "^1.0.0",
+ "@istanbuljs/schema": "^0.1.2",
+ "istanbul-lib-instrument": "^4.0.0",
+ "test-exclude": "^6.0.0"
+ }
+ },
+ "babel-plugin-jest-hoist": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/babel-plugin-jest-hoist/-/babel-plugin-jest-hoist-26.6.2.tgz",
+ "integrity": "sha512-PO9t0697lNTmcEHH69mdtYiOIkkOlj9fySqfO3K1eCcdISevLAE0xY59VLLUj0SoiPiTX/JU2CYFpILydUa5Lw==",
+ "dev": true,
+ "requires": {
+ "@babel/template": "^7.3.3",
+ "@babel/types": "^7.3.3",
+ "@types/babel__core": "^7.0.0",
+ "@types/babel__traverse": "^7.0.6"
+ }
+ },
+ "babel-preset-current-node-syntax": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/babel-preset-current-node-syntax/-/babel-preset-current-node-syntax-1.0.0.tgz",
+ "integrity": "sha512-mGkvkpocWJes1CmMKtgGUwCeeq0pOhALyymozzDWYomHTbDLwueDYG6p4TK1YOeYHCzBzYPsWkgTto10JubI1Q==",
+ "dev": true,
+ "requires": {
+ "@babel/plugin-syntax-async-generators": "^7.8.4",
+ "@babel/plugin-syntax-bigint": "^7.8.3",
+ "@babel/plugin-syntax-class-properties": "^7.8.3",
+ "@babel/plugin-syntax-import-meta": "^7.8.3",
+ "@babel/plugin-syntax-json-strings": "^7.8.3",
+ "@babel/plugin-syntax-logical-assignment-operators": "^7.8.3",
+ "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3",
+ "@babel/plugin-syntax-numeric-separator": "^7.8.3",
+ "@babel/plugin-syntax-object-rest-spread": "^7.8.3",
+ "@babel/plugin-syntax-optional-catch-binding": "^7.8.3",
+ "@babel/plugin-syntax-optional-chaining": "^7.8.3",
+ "@babel/plugin-syntax-top-level-await": "^7.8.3"
+ }
+ },
+ "babel-preset-jest": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/babel-preset-jest/-/babel-preset-jest-26.6.2.tgz",
+ "integrity": "sha512-YvdtlVm9t3k777c5NPQIv6cxFFFapys25HiUmuSgHwIZhfifweR5c5Sf5nwE3MAbfu327CYSvps8Yx6ANLyleQ==",
+ "dev": true,
+ "requires": {
+ "babel-plugin-jest-hoist": "^26.6.2",
+ "babel-preset-current-node-syntax": "^1.0.0"
+ }
+ },
+ "balanced-match": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz",
+ "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=",
+ "dev": true
+ },
+ "base": {
+ "version": "0.11.2",
+ "resolved": "https://registry.npmjs.org/base/-/base-0.11.2.tgz",
+ "integrity": "sha512-5T6P4xPgpp0YDFvSWwEZ4NoE3aM4QBQXDzmVbraCkFj8zHM+mba8SyqB5DbZWyR7mYHo6Y7BdQo3MoA4m0TeQg==",
+ "dev": true,
+ "requires": {
+ "cache-base": "^1.0.1",
+ "class-utils": "^0.3.5",
+ "component-emitter": "^1.2.1",
+ "define-property": "^1.0.0",
+ "isobject": "^3.0.1",
+ "mixin-deep": "^1.2.0",
+ "pascalcase": "^0.1.1"
+ },
+ "dependencies": {
+ "define-property": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz",
+ "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=",
+ "dev": true,
+ "requires": {
+ "is-descriptor": "^1.0.0"
+ }
+ },
+ "is-accessor-descriptor": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz",
+ "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==",
+ "dev": true,
+ "requires": {
+ "kind-of": "^6.0.0"
+ }
+ },
+ "is-data-descriptor": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz",
+ "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==",
+ "dev": true,
+ "requires": {
+ "kind-of": "^6.0.0"
+ }
+ },
+ "is-descriptor": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz",
+ "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==",
+ "dev": true,
+ "requires": {
+ "is-accessor-descriptor": "^1.0.0",
+ "is-data-descriptor": "^1.0.0",
+ "kind-of": "^6.0.2"
+ }
+ }
+ }
+ },
+ "base64-stream": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/base64-stream/-/base64-stream-1.0.0.tgz",
+ "integrity": "sha512-BQQZftaO48FcE1Kof9CmXMFaAdqkcNorgc8CxesZv9nMbbTF1EFyQe89UOuh//QMmdtfUDXyO8rgUalemL5ODA=="
+ },
+ "bcrypt-pbkdf": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz",
+ "integrity": "sha1-pDAdOJtqQ/m2f/PKEaP2Y342Dp4=",
+ "dev": true,
+ "requires": {
+ "tweetnacl": "^0.14.3"
+ }
+ },
+ "brace-expansion": {
+ "version": "1.1.11",
+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
+ "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+ "dev": true,
+ "requires": {
+ "balanced-match": "^1.0.0",
+ "concat-map": "0.0.1"
+ }
+ },
+ "braces": {
+ "version": "3.0.2",
+ "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz",
+ "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==",
+ "dev": true,
+ "requires": {
+ "fill-range": "^7.0.1"
+ }
+ },
+ "browser-process-hrtime": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/browser-process-hrtime/-/browser-process-hrtime-1.0.0.tgz",
+ "integrity": "sha512-9o5UecI3GhkpM6DrXr69PblIuWxPKk9Y0jHBRhdocZ2y7YECBFCsHm79Pr3OyR2AvjhDkabFJaDJMYRazHgsow==",
+ "dev": true
+ },
+ "bs-logger": {
+ "version": "0.2.6",
+ "resolved": "https://registry.npmjs.org/bs-logger/-/bs-logger-0.2.6.tgz",
+ "integrity": "sha512-pd8DCoxmbgc7hyPKOvxtqNcjYoOsABPQdcCUjGp3d42VR2CX1ORhk2A87oqqu5R1kk+76nsxZupkmyd+MVtCog==",
+ "dev": true,
+ "requires": {
+ "fast-json-stable-stringify": "2.x"
+ }
+ },
+ "bser": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/bser/-/bser-2.1.1.tgz",
+ "integrity": "sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==",
+ "dev": true,
+ "requires": {
+ "node-int64": "^0.4.0"
+ }
+ },
+ "buffer-from": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.1.tgz",
+ "integrity": "sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A==",
+ "dev": true
+ },
+ "cache-base": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/cache-base/-/cache-base-1.0.1.tgz",
+ "integrity": "sha512-AKcdTnFSWATd5/GCPRxr2ChwIJ85CeyrEyjRHlKxQ56d4XJMGym0uAiKn0xbLOGOl3+yRpOTi484dVCEc5AUzQ==",
+ "dev": true,
+ "requires": {
+ "collection-visit": "^1.0.0",
+ "component-emitter": "^1.2.1",
+ "get-value": "^2.0.6",
+ "has-value": "^1.0.0",
+ "isobject": "^3.0.1",
+ "set-value": "^2.0.0",
+ "to-object-path": "^0.3.0",
+ "union-value": "^1.0.0",
+ "unset-value": "^1.0.0"
+ }
+ },
+ "callsites": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
+ "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
+ "dev": true
+ },
+ "camelcase": {
+ "version": "5.3.1",
+ "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz",
+ "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==",
+ "dev": true
+ },
+ "capture-exit": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/capture-exit/-/capture-exit-2.0.0.tgz",
+ "integrity": "sha512-PiT/hQmTonHhl/HFGN+Lx3JJUznrVYJ3+AQsnthneZbvW7x+f08Tk7yLJTLEOUvBTbduLeeBkxEaYXUOUrRq6g==",
+ "dev": true,
+ "requires": {
+ "rsvp": "^4.8.4"
+ }
+ },
+ "caseless": {
+ "version": "0.12.0",
+ "resolved": "https://registry.npmjs.org/caseless/-/caseless-0.12.0.tgz",
+ "integrity": "sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw=",
+ "dev": true
+ },
+ "chalk": {
+ "version": "4.1.0",
+ "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.0.tgz",
+ "integrity": "sha512-qwx12AxXe2Q5xQ43Ac//I6v5aXTipYrSESdOgzrN+9XjgEpyjpKuvSGaN4qE93f7TQTlerQQ8S+EQ0EyDoVL1A==",
+ "dev": true,
+ "requires": {
+ "ansi-styles": "^4.1.0",
+ "supports-color": "^7.1.0"
+ },
+ "dependencies": {
+ "ansi-styles": {
+ "version": "4.3.0",
+ "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+ "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+ "dev": true,
+ "requires": {
+ "color-convert": "^2.0.1"
+ }
+ },
+ "color-convert": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+ "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+ "dev": true,
+ "requires": {
+ "color-name": "~1.1.4"
+ }
+ },
+ "color-name": {
+ "version": "1.1.4",
+ "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+ "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+ "dev": true
+ },
+ "has-flag": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+ "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+ "dev": true
+ },
+ "supports-color": {
+ "version": "7.2.0",
+ "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+ "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+ "dev": true,
+ "requires": {
+ "has-flag": "^4.0.0"
+ }
+ }
+ }
+ },
+ "char-regex": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/char-regex/-/char-regex-1.0.2.tgz",
+ "integrity": "sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==",
+ "dev": true
+ },
+ "ci-info": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-2.0.0.tgz",
+ "integrity": "sha512-5tK7EtrZ0N+OLFMthtqOj4fI2Jeb88C4CAZPu25LDVUgXJ0A3Js4PMGqrn0JU1W0Mh1/Z8wZzYPxqUrXeBboCQ==",
+ "dev": true
+ },
+ "cjs-module-lexer": {
+ "version": "0.6.0",
+ "resolved": "https://registry.npmjs.org/cjs-module-lexer/-/cjs-module-lexer-0.6.0.tgz",
+ "integrity": "sha512-uc2Vix1frTfnuzxxu1Hp4ktSvM3QaI4oXl4ZUqL1wjTu/BGki9TrCWoqLTg/drR1KwAEarXuRFCG2Svr1GxPFw==",
+ "dev": true
+ },
+ "class-utils": {
+ "version": "0.3.6",
+ "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
+ "integrity": "sha512-qOhPa/Fj7s6TY8H8esGu5QNpMMQxz79h+urzrNYN6mn+9BnxlDGf5QZ+XeCDsxSjPqsSR56XOZOJmpeurnLMeg==",
+ "dev": true,
+ "requires": {
+ "arr-union": "^3.1.0",
+ "define-property": "^0.2.5",
+ "isobject": "^3.0.0",
+ "static-extend": "^0.1.1"
+ },
+ "dependencies": {
+ "define-property": {
+ "version": "0.2.5",
+ "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz",
+ "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=",
+ "dev": true,
+ "requires": {
+ "is-descriptor": "^0.1.0"
+ }
+ }
+ }
+ },
+ "clean-stack": {
+ "version": "2.2.0",
+ "resolved": "https://registry.npmjs.org/clean-stack/-/clean-stack-2.2.0.tgz",
+ "integrity": "sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==",
+ "dev": true
+ },
+ "cliui": {
+ "version": "6.0.0",
+ "resolved": "https://registry.npmjs.org/cliui/-/cliui-6.0.0.tgz",
+ "integrity": "sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ==",
+ "dev": true,
+ "requires": {
+ "string-width": "^4.2.0",
+ "strip-ansi": "^6.0.0",
+ "wrap-ansi": "^6.2.0"
+ },
+ "dependencies": {
+ "emoji-regex": {
+ "version": "8.0.0",
+ "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+ "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+ "dev": true
+ },
+ "is-fullwidth-code-point": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+ "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+ "dev": true
+ },
+ "string-width": {
+ "version": "4.2.0",
+ "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.0.tgz",
+ "integrity": "sha512-zUz5JD+tgqtuDjMhwIg5uFVV3dtqZ9yQJlZVfq4I01/K5Paj5UHj7VyrQOJvzawSVlKpObApbfD0Ed6yJc+1eg==",
+ "dev": true,
+ "requires": {
+ "emoji-regex": "^8.0.0",
+ "is-fullwidth-code-point": "^3.0.0",
+ "strip-ansi": "^6.0.0"
+ }
+ }
+ }
+ },
+ "co": {
+ "version": "4.6.0",
+ "resolved": "https://registry.npmjs.org/co/-/co-4.6.0.tgz",
+ "integrity": "sha1-bqa989hTrlTMuOR7+gvz+QMfsYQ=",
+ "dev": true
+ },
+ "collect-v8-coverage": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/collect-v8-coverage/-/collect-v8-coverage-1.0.1.tgz",
+ "integrity": "sha512-iBPtljfCNcTKNAto0KEtDfZ3qzjJvqE3aTGZsbhjSBlorqpXJlaWWtPO35D+ZImoC3KWejX64o+yPGxhWSTzfg==",
+ "dev": true
+ },
+ "collection-visit": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/collection-visit/-/collection-visit-1.0.0.tgz",
+ "integrity": "sha1-S8A3PBZLwykbTTaMgpzxqApZ3KA=",
+ "dev": true,
+ "requires": {
+ "map-visit": "^1.0.0",
+ "object-visit": "^1.0.0"
+ }
+ },
+ "color-convert": {
+ "version": "1.9.3",
+ "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
+ "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
+ "dev": true,
+ "requires": {
+ "color-name": "1.1.3"
+ }
+ },
+ "color-name": {
+ "version": "1.1.3",
+ "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
+ "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=",
+ "dev": true
+ },
+ "combined-stream": {
+ "version": "1.0.8",
+ "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+ "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+ "dev": true,
+ "requires": {
+ "delayed-stream": "~1.0.0"
+ }
+ },
+ "component-emitter": {
+ "version": "1.3.0",
+ "resolved": "https://registry.npmjs.org/component-emitter/-/component-emitter-1.3.0.tgz",
+ "integrity": "sha512-Rd3se6QB+sO1TwqZjscQrurpEPIfO0/yYnSin6Q/rD3mOutHvUrCAhJub3r90uNb+SESBuE0QYoB90YdfatsRg==",
+ "dev": true
+ },
+ "concat-map": {
+ "version": "0.0.1",
+ "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+ "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=",
+ "dev": true
+ },
+ "convert-source-map": {
+ "version": "1.7.0",
+ "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.7.0.tgz",
+ "integrity": "sha512-4FJkXzKXEDB1snCFZlLP4gpC3JILicCpGbzG9f9G7tGqGCzETQ2hWPrcinA9oU4wtf2biUaEH5065UnMeR33oA==",
+ "dev": true,
+ "requires": {
+ "safe-buffer": "~5.1.1"
+ },
+ "dependencies": {
+ "safe-buffer": {
+ "version": "5.1.2",
+ "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+ "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+ "dev": true
+ }
+ }
+ },
+ "copy-descriptor": {
+ "version": "0.1.1",
+ "resolved": "https://registry.npmjs.org/copy-descriptor/-/copy-descriptor-0.1.1.tgz",
+ "integrity": "sha1-Z29us8OZl8LuGsOpJP1hJHSPV40=",
+ "dev": true
+ },
+ "core-util-is": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz",
+ "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=",
+ "dev": true
+ },
+ "cross-spawn": {
+ "version": "7.0.3",
+ "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz",
+ "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==",
+ "dev": true,
+ "requires": {
+ "path-key": "^3.1.0",
+ "shebang-command": "^2.0.0",
+ "which": "^2.0.1"
+ }
+ },
+ "crypto-random-string": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/crypto-random-string/-/crypto-random-string-2.0.0.tgz",
+ "integrity": "sha512-v1plID3y9r/lPhviJ1wrXpLeyUIGAZ2SHNYTEapm7/8A9nLPoyvVp3RK/EPFqn5kEznyWgYZNsRtYYIWbuG8KA==",
+ "dev": true
+ },
+ "cssom": {
+ "version": "0.4.4",
+ "resolved": "https://registry.npmjs.org/cssom/-/cssom-0.4.4.tgz",
+ "integrity": "sha512-p3pvU7r1MyyqbTk+WbNJIgJjG2VmTIaB10rI93LzVPrmDJKkzKYMtxxyAvQXR/NS6otuzveI7+7BBq3SjBS2mw==",
+ "dev": true
+ },
+ "cssstyle": {
+ "version": "2.3.0",
+ "resolved": "https://registry.npmjs.org/cssstyle/-/cssstyle-2.3.0.tgz",
+ "integrity": "sha512-AZL67abkUzIuvcHqk7c09cezpGNcxUxU4Ioi/05xHk4DQeTkWmGYftIE6ctU6AEt+Gn4n1lDStOtj7FKycP71A==",
+ "dev": true,
+ "requires": {
+ "cssom": "~0.3.6"
+ },
+ "dependencies": {
+ "cssom": {
+ "version": "0.3.8",
+ "resolved": "https://registry.npmjs.org/cssom/-/cssom-0.3.8.tgz",
+ "integrity": "sha512-b0tGHbfegbhPJpxpiBPU2sCkigAqtM9O121le6bbOlgyV+NyGyCmVfJ6QW9eRjz8CpNfWEOYBIMIGRYkLwsIYg==",
+ "dev": true
+ }
+ }
+ },
+ "dashdash": {
+ "version": "1.14.1",
+ "resolved": "https://registry.npmjs.org/dashdash/-/dashdash-1.14.1.tgz",
+ "integrity": "sha1-hTz6D3y+L+1d4gMmuN1YEDX24vA=",
+ "dev": true,
+ "requires": {
+ "assert-plus": "^1.0.0"
+ }
+ },
+ "data-urls": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-2.0.0.tgz",
+ "integrity": "sha512-X5eWTSXO/BJmpdIKCRuKUgSCgAN0OwliVK3yPKbwIWU1Tdw5BRajxlzMidvh+gwko9AfQ9zIj52pzF91Q3YAvQ==",
+ "dev": true,
+ "requires": {
+ "abab": "^2.0.3",
+ "whatwg-mimetype": "^2.3.0",
+ "whatwg-url": "^8.0.0"
+ }
+ },
+ "debug": {
+ "version": "4.3.1",
+ "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.1.tgz",
+ "integrity": "sha512-doEwdvm4PCeK4K3RQN2ZC2BYUBaxwLARCqZmMjtF8a51J2Rb0xpVloFRnCODwqjpwnAoao4pelN8l3RJdv3gRQ==",
+ "dev": true,
+ "requires": {
+ "ms": "2.1.2"
+ }
+ },
+ "decamelize": {
+ "version": "1.2.0",
+ "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz",
+ "integrity": "sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=",
+ "dev": true
+ },
+ "decimal.js": {
+ "version": "10.2.1",
+ "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.2.1.tgz",
+ "integrity": "sha512-KaL7+6Fw6i5A2XSnsbhm/6B+NuEA7TZ4vqxnd5tXz9sbKtrN9Srj8ab4vKVdK8YAqZO9P1kg45Y6YLoduPf+kw==",
+ "dev": true
+ },
+ "decode-uri-component": {
+ "version": "0.2.0",
+ "resolved": "https://registry.npmjs.org/decode-uri-component/-/decode-uri-component-0.2.0.tgz",
+ "integrity": "sha1-6zkTMzRYd1y4TNGh+uBiEGu4dUU=",
+ "dev": true
+ },
+ "deep-is": {
+ "version": "0.1.3",
+ "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.3.tgz",
+ "integrity": "sha1-s2nW+128E+7PUk+RsHD+7cNXzzQ=",
+ "dev": true
+ },
+ "deepmerge": {
+ "version": "4.2.2",
+ "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.2.2.tgz",
+ "integrity": "sha512-FJ3UgI4gIl+PHZm53knsuSFpE+nESMr7M4v9QcgB7S63Kj/6WqMiFQJpBBYz1Pt+66bZpP3Q7Lye0Oo9MPKEdg==",
+ "dev": true
+ },
+ "define-property": {
+ "version": "2.0.2",
+ "resolved": "https://registry.npmjs.org/define-property/-/define-property-2.0.2.tgz",
+ "integrity": "sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==",
+ "dev": true,
+ "requires": {
+ "is-descriptor": "^1.0.2",
+ "isobject": "^3.0.1"
+ },
+ "dependencies": {
+ "is-accessor-descriptor": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz",
+ "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==",
+ "dev": true,
+ "requires": {
+ "kind-of": "^6.0.0"
+ }
+ },
+ "is-data-descriptor": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz",
+ "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==",
+ "dev": true,
+ "requires": {
+ "kind-of": "^6.0.0"
+ }
+ },
+ "is-descriptor": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz",
+ "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==",
+ "dev": true,
+ "requires": {
+ "is-accessor-descriptor": "^1.0.0",
+ "is-data-descriptor": "^1.0.0",
+ "kind-of": "^6.0.2"
+ }
+ }
+ }
+ },
+ "del": {
+ "version": "6.0.0",
+ "resolved": "https://registry.npmjs.org/del/-/del-6.0.0.tgz",
+ "integrity": "sha512-1shh9DQ23L16oXSZKB2JxpL7iMy2E0S9d517ptA1P8iw0alkPtQcrKH7ru31rYtKwF499HkTu+DRzq3TCKDFRQ==",
+ "dev": true,
+ "requires": {
+ "globby": "^11.0.1",
+ "graceful-fs": "^4.2.4",
+ "is-glob": "^4.0.1",
+ "is-path-cwd": "^2.2.0",
+ "is-path-inside": "^3.0.2",
+ "p-map": "^4.0.0",
+ "rimraf": "^3.0.2",
+ "slash": "^3.0.0"
+ }
+ },
+ "delayed-stream": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+ "integrity": "sha1-3zrhmayt+31ECqrgsp4icrJOxhk=",
+ "dev": true
+ },
+ "detect-newline": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/detect-newline/-/detect-newline-3.1.0.tgz",
+ "integrity": "sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA==",
+ "dev": true
+ },
+ "diff-sequences": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/diff-sequences/-/diff-sequences-26.6.2.tgz",
+ "integrity": "sha512-Mv/TDa3nZ9sbc5soK+OoA74BsS3mL37yixCvUAQkiuA4Wz6YtwP/K47n2rv2ovzHZvoiQeA5FTQOschKkEwB0Q==",
+ "dev": true
+ },
+ "dir-glob": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz",
+ "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==",
+ "dev": true,
+ "requires": {
+ "path-type": "^4.0.0"
+ }
+ },
+ "doctrine": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz",
+ "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==",
+ "dev": true,
+ "requires": {
+ "esutils": "^2.0.2"
+ }
+ },
+ "domexception": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/domexception/-/domexception-2.0.1.tgz",
+ "integrity": "sha512-yxJ2mFy/sibVQlu5qHjOkf9J3K6zgmCxgJ94u2EdvDOV09H+32LtRswEcUsmUWN72pVLOEnTSRaIVVzVQgS0dg==",
+ "dev": true,
+ "requires": {
+ "webidl-conversions": "^5.0.0"
+ },
+ "dependencies": {
+ "webidl-conversions": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-5.0.0.tgz",
+ "integrity": "sha512-VlZwKPCkYKxQgeSbH5EyngOmRp7Ww7I9rQLERETtf5ofd9pGeswWiOtogpEO850jziPRarreGxn5QIiTqpb2wA==",
+ "dev": true
+ }
+ }
+ },
+ "ecc-jsbn": {
+ "version": "0.1.2",
+ "resolved": "https://registry.npmjs.org/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz",
+ "integrity": "sha1-OoOpBOVDUyh4dMVkt1SThoSamMk=",
+ "dev": true,
+ "requires": {
+ "jsbn": "~0.1.0",
+ "safer-buffer": "^2.1.0"
+ }
+ },
+ "emittery": {
+ "version": "0.7.2",
+ "resolved": "https://registry.npmjs.org/emittery/-/emittery-0.7.2.tgz",
+ "integrity": "sha512-A8OG5SR/ij3SsJdWDJdkkSYUjQdCUx6APQXem0SaEePBSRg4eymGYwBkKo1Y6DU+af/Jn2dBQqDBvjnr9Vi8nQ==",
+ "dev": true
+ },
+ "emoji-regex": {
+ "version": "7.0.3",
+ "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz",
+ "integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==",
+ "dev": true
+ },
+ "end-of-stream": {
+ "version": "1.4.4",
+ "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.4.tgz",
+ "integrity": "sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==",
+ "dev": true,
+ "requires": {
+ "once": "^1.4.0"
+ }
+ },
+ "enquirer": {
+ "version": "2.3.6",
+ "resolved": "https://registry.npmjs.org/enquirer/-/enquirer-2.3.6.tgz",
+ "integrity": "sha512-yjNnPr315/FjS4zIsUxYguYUPP2e1NK4d7E7ZOLiyYCcbFBiTMyID+2wvm2w6+pZ/odMA7cRkjhsPbltwBOrLg==",
+ "dev": true,
+ "requires": {
+ "ansi-colors": "^4.1.1"
+ }
+ },
+ "error-ex": {
+ "version": "1.3.2",
+ "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz",
+ "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==",
+ "dev": true,
+ "requires": {
+ "is-arrayish": "^0.2.1"
+ }
+ },
+ "escape-string-regexp": {
+ "version": "1.0.5",
+ "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
+ "integrity": "sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=",
+ "dev": true
+ },
+ "escodegen": {
+ "version": "1.14.3",
+ "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.14.3.tgz",
+ "integrity": "sha512-qFcX0XJkdg+PB3xjZZG/wKSuT1PnQWx57+TVSjIMmILd2yC/6ByYElPwJnslDsuWuSAp4AwJGumarAAmJch5Kw==",
+ "dev": true,
+ "requires": {
+ "esprima": "^4.0.1",
+ "estraverse": "^4.2.0",
+ "esutils": "^2.0.2",
+ "optionator": "^0.8.1",
+ "source-map": "~0.6.1"
+ },
+ "dependencies": {
+ "levn": {
+ "version": "0.3.0",
+ "resolved": "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz",
+ "integrity": "sha1-OwmSTt+fCDwEkP3UwLxEIeBHZO4=",
+ "dev": true,
+ "requires": {
+ "prelude-ls": "~1.1.2",
+ "type-check": "~0.3.2"
+ }
+ },
+ "optionator": {
+ "version": "0.8.3",
+ "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.8.3.tgz",
+ "integrity": "sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA==",
+ "dev": true,
+ "requires": {
+ "deep-is": "~0.1.3",
+ "fast-levenshtein": "~2.0.6",
+ "levn": "~0.3.0",
+ "prelude-ls": "~1.1.2",
+ "type-check": "~0.3.2",
+ "word-wrap": "~1.2.3"
+ }
+ },
+ "prelude-ls": {
+ "version": "1.1.2",
+ "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz",
+ "integrity": "sha1-IZMqVJ9eUv/ZqCf1cOBL5iqX2lQ=",
+ "dev": true
+ },
+ "type-check": {
+ "version": "0.3.2",
+ "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.3.2.tgz",
+ "integrity": "sha1-WITKtRLPHTVeP7eE8wgEsrUg23I=",
+ "dev": true,
+ "requires": {
+ "prelude-ls": "~1.1.2"
+ }
+ }
+ }
+ },
+ "eslint": {
+ "version": "7.15.0",
+ "resolved": "https://registry.npmjs.org/eslint/-/eslint-7.15.0.tgz",
+ "integrity": "sha512-Vr64xFDT8w30wFll643e7cGrIkPEU50yIiI36OdSIDoSGguIeaLzBo0vpGvzo9RECUqq7htURfwEtKqwytkqzA==",
+ "dev": true,
+ "requires": {
+ "@babel/code-frame": "^7.0.0",
+ "@eslint/eslintrc": "^0.2.2",
+ "ajv": "^6.10.0",
+ "chalk": "^4.0.0",
+ "cross-spawn": "^7.0.2",
+ "debug": "^4.0.1",
+ "doctrine": "^3.0.0",
+ "enquirer": "^2.3.5",
+ "eslint-scope": "^5.1.1",
+ "eslint-utils": "^2.1.0",
+ "eslint-visitor-keys": "^2.0.0",
+ "espree": "^7.3.1",
+ "esquery": "^1.2.0",
+ "esutils": "^2.0.2",
+ "file-entry-cache": "^6.0.0",
+ "functional-red-black-tree": "^1.0.1",
+ "glob-parent": "^5.0.0",
+ "globals": "^12.1.0",
+ "ignore": "^4.0.6",
+ "import-fresh": "^3.0.0",
+ "imurmurhash": "^0.1.4",
+ "is-glob": "^4.0.0",
+ "js-yaml": "^3.13.1",
+ "json-stable-stringify-without-jsonify": "^1.0.1",
+ "levn": "^0.4.1",
+ "lodash": "^4.17.19",
+ "minimatch": "^3.0.4",
+ "natural-compare": "^1.4.0",
+ "optionator": "^0.9.1",
+ "progress": "^2.0.0",
+ "regexpp": "^3.1.0",
+ "semver": "^7.2.1",
+ "strip-ansi": "^6.0.0",
+ "strip-json-comments": "^3.1.0",
+ "table": "^5.2.3",
+ "text-table": "^0.2.0",
+ "v8-compile-cache": "^2.0.3"
+ },
+ "dependencies": {
+ "ignore": {
+ "version": "4.0.6",
+ "resolved": "https://registry.npmjs.org/ignore/-/ignore-4.0.6.tgz",
+ "integrity": "sha512-cyFDKrqc/YdcWFniJhzI42+AzS+gNwmUzOSFcRCQYwySuBBBy/KjuxWLZ/FHEH6Moq1NizMOBWyTcv8O4OZIMg==",
+ "dev": true
+ }
+ }
+ },
+ "eslint-config-prettier": {
+ "version": "7.0.0",
+ "resolved": "https://registry.npmjs.org/eslint-config-prettier/-/eslint-config-prettier-7.0.0.tgz",
+ "integrity": "sha512-8Y8lGLVPPZdaNA7JXqnvETVC7IiVRgAP6afQu9gOQRn90YY3otMNh+x7Vr2vMePQntF+5erdSUBqSzCmU/AxaQ==",
+ "dev": true
+ },
+ "eslint-plugin-prettier": {
+ "version": "3.2.0",
+ "resolved": "https://registry.npmjs.org/eslint-plugin-prettier/-/eslint-plugin-prettier-3.2.0.tgz",
+ "integrity": "sha512-kOUSJnFjAUFKwVxuzy6sA5yyMx6+o9ino4gCdShzBNx4eyFRudWRYKCFolKjoM40PEiuU6Cn7wBLfq3WsGg7qg==",
+ "dev": true,
+ "requires": {
+ "prettier-linter-helpers": "^1.0.0"
+ }
+ },
+ "eslint-scope": {
+ "version": "5.1.1",
+ "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz",
+ "integrity": "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==",
+ "dev": true,
+ "requires": {
+ "esrecurse": "^4.3.0",
+ "estraverse": "^4.1.1"
+ }
+ },
+ "eslint-utils": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/eslint-utils/-/eslint-utils-2.1.0.tgz",
+ "integrity": "sha512-w94dQYoauyvlDc43XnGB8lU3Zt713vNChgt4EWwhXAP2XkBvndfxF0AgIqKOOasjPIPzj9JqgwkwbCYD0/V3Zg==",
+ "dev": true,
+ "requires": {
+ "eslint-visitor-keys": "^1.1.0"
+ },
+ "dependencies": {
+ "eslint-visitor-keys": {
+ "version": "1.3.0",
+ "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-1.3.0.tgz",
+ "integrity": "sha512-6J72N8UNa462wa/KFODt/PJ3IU60SDpC3QXC1Hjc1BXXpfL2C9R5+AU7jhe0F6GREqVMh4Juu+NY7xn+6dipUQ==",
+ "dev": true
+ }
+ }
+ },
+ "eslint-visitor-keys": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-2.0.0.tgz",
+ "integrity": "sha512-QudtT6av5WXels9WjIM7qz1XD1cWGvX4gGXvp/zBn9nXG02D0utdU3Em2m/QjTnrsk6bBjmCygl3rmj118msQQ==",
+ "dev": true
+ },
+ "espree": {
+ "version": "7.3.1",
+ "resolved": "https://registry.npmjs.org/espree/-/espree-7.3.1.tgz",
+ "integrity": "sha512-v3JCNCE64umkFpmkFGqzVKsOT0tN1Zr+ueqLZfpV1Ob8e+CEgPWa+OxCoGH3tnhimMKIaBm4m/vaRpJ/krRz2g==",
+ "dev": true,
+ "requires": {
+ "acorn": "^7.4.0",
+ "acorn-jsx": "^5.3.1",
+ "eslint-visitor-keys": "^1.3.0"
+ },
+ "dependencies": {
+ "eslint-visitor-keys": {
+ "version": "1.3.0",
+ "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-1.3.0.tgz",
+ "integrity": "sha512-6J72N8UNa462wa/KFODt/PJ3IU60SDpC3QXC1Hjc1BXXpfL2C9R5+AU7jhe0F6GREqVMh4Juu+NY7xn+6dipUQ==",
+ "dev": true
+ }
+ }
+ },
+ "esprima": {
+ "version": "4.0.1",
+ "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
+ "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
+ "dev": true
+ },
+ "esquery": {
+ "version": "1.3.1",
+ "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.3.1.tgz",
+ "integrity": "sha512-olpvt9QG0vniUBZspVRN6lwB7hOZoTRtT+jzR+tS4ffYx2mzbw+z0XCOk44aaLYKApNX5nMm+E+P6o25ip/DHQ==",
+ "dev": true,
+ "requires": {
+ "estraverse": "^5.1.0"
+ },
+ "dependencies": {
+ "estraverse": {
+ "version": "5.2.0",
+ "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.2.0.tgz",
+ "integrity": "sha512-BxbNGGNm0RyRYvUdHpIwv9IWzeM9XClbOxwoATuFdOE7ZE6wHL+HQ5T8hoPM+zHvmKzzsEqhgy0GrQ5X13afiQ==",
+ "dev": true
+ }
+ }
+ },
+ "esrecurse": {
+ "version": "4.3.0",
+ "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz",
+ "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
+ "dev": true,
+ "requires": {
+ "estraverse": "^5.2.0"
+ },
+ "dependencies": {
+ "estraverse": {
+ "version": "5.2.0",
+ "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.2.0.tgz",
+ "integrity": "sha512-BxbNGGNm0RyRYvUdHpIwv9IWzeM9XClbOxwoATuFdOE7ZE6wHL+HQ5T8hoPM+zHvmKzzsEqhgy0GrQ5X13afiQ==",
+ "dev": true
+ }
+ }
+ },
+ "estraverse": {
+ "version": "4.3.0",
+ "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz",
+ "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==",
+ "dev": true
+ },
+ "esutils": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
+ "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
+ "dev": true
+ },
+ "exec-sh": {
+ "version": "0.3.4",
+ "resolved": "https://registry.npmjs.org/exec-sh/-/exec-sh-0.3.4.tgz",
+ "integrity": "sha512-sEFIkc61v75sWeOe72qyrqg2Qg0OuLESziUDk/O/z2qgS15y2gWVFrI6f2Qn/qw/0/NCfCEsmNA4zOjkwEZT1A==",
+ "dev": true
+ },
+ "execa": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/execa/-/execa-1.0.0.tgz",
+ "integrity": "sha512-adbxcyWV46qiHyvSp50TKt05tB4tK3HcmF7/nxfAdhnox83seTDbwnaqKO4sXRy7roHAIFqJP/Rw/AuEbX61LA==",
+ "dev": true,
+ "requires": {
+ "cross-spawn": "^6.0.0",
+ "get-stream": "^4.0.0",
+ "is-stream": "^1.1.0",
+ "npm-run-path": "^2.0.0",
+ "p-finally": "^1.0.0",
+ "signal-exit": "^3.0.0",
+ "strip-eof": "^1.0.0"
+ },
+ "dependencies": {
+ "cross-spawn": {
+ "version": "6.0.5",
+ "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-6.0.5.tgz",
+ "integrity": "sha512-eTVLrBSt7fjbDygz805pMnstIs2VTBNkRm0qxZd+M7A5XDdxVRWO5MxGBXZhjY4cqLYLdtrGqRf8mBPmzwSpWQ==",
+ "dev": true,
+ "requires": {
+ "nice-try": "^1.0.4",
+ "path-key": "^2.0.1",
+ "semver": "^5.5.0",
+ "shebang-command": "^1.2.0",
+ "which": "^1.2.9"
+ }
+ },
+ "path-key": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/path-key/-/path-key-2.0.1.tgz",
+ "integrity": "sha1-QRyttXTFoUDTpLGRDUDYDMn0C0A=",
+ "dev": true
+ },
+ "semver": {
+ "version": "5.7.1",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz",
+ "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==",
+ "dev": true
+ },
+ "shebang-command": {
+ "version": "1.2.0",
+ "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-1.2.0.tgz",
+ "integrity": "sha1-RKrGW2lbAzmJaMOfNj/uXer98eo=",
+ "dev": true,
+ "requires": {
+ "shebang-regex": "^1.0.0"
+ }
+ },
+ "shebang-regex": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-1.0.0.tgz",
+ "integrity": "sha1-2kL0l0DAtC2yypcoVxyxkMmO/qM=",
+ "dev": true
+ },
+ "which": {
+ "version": "1.3.1",
+ "resolved": "https://registry.npmjs.org/which/-/which-1.3.1.tgz",
+ "integrity": "sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==",
+ "dev": true,
+ "requires": {
+ "isexe": "^2.0.0"
+ }
+ }
+ }
+ },
+ "exit": {
+ "version": "0.1.2",
+ "resolved": "https://registry.npmjs.org/exit/-/exit-0.1.2.tgz",
+ "integrity": "sha1-BjJjj42HfMghB9MKD/8aF8uhzQw=",
+ "dev": true
+ },
+ "expand-brackets": {
+ "version": "2.1.4",
+ "resolved": "https://registry.npmjs.org/expand-brackets/-/expand-brackets-2.1.4.tgz",
+ "integrity": "sha1-t3c14xXOMPa27/D4OwQVGiJEliI=",
+ "dev": true,
+ "requires": {
+ "debug": "^2.3.3",
+ "define-property": "^0.2.5",
+ "extend-shallow": "^2.0.1",
+ "posix-character-classes": "^0.1.0",
+ "regex-not": "^1.0.0",
+ "snapdragon": "^0.8.1",
+ "to-regex": "^3.0.1"
+ },
+ "dependencies": {
+ "debug": {
+ "version": "2.6.9",
+ "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+ "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+ "dev": true,
+ "requires": {
+ "ms": "2.0.0"
+ }
+ },
+ "define-property": {
+ "version": "0.2.5",
+ "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz",
+ "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=",
+ "dev": true,
+ "requires": {
+ "is-descriptor": "^0.1.0"
+ }
+ },
+ "extend-shallow": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
+ "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
+ "dev": true,
+ "requires": {
+ "is-extendable": "^0.1.0"
+ }
+ },
+ "ms": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+ "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=",
+ "dev": true
+ }
+ }
+ },
+ "expect": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/expect/-/expect-26.6.2.tgz",
+ "integrity": "sha512-9/hlOBkQl2l/PLHJx6JjoDF6xPKcJEsUlWKb23rKE7KzeDqUZKXKNMW27KIue5JMdBV9HgmoJPcc8HtO85t9IA==",
+ "dev": true,
+ "requires": {
+ "@jest/types": "^26.6.2",
+ "ansi-styles": "^4.0.0",
+ "jest-get-type": "^26.3.0",
+ "jest-matcher-utils": "^26.6.2",
+ "jest-message-util": "^26.6.2",
+ "jest-regex-util": "^26.0.0"
+ },
+ "dependencies": {
+ "ansi-styles": {
+ "version": "4.3.0",
+ "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+ "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+ "dev": true,
+ "requires": {
+ "color-convert": "^2.0.1"
+ }
+ },
+ "color-convert": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+ "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+ "dev": true,
+ "requires": {
+ "color-name": "~1.1.4"
+ }
+ },
+ "color-name": {
+ "version": "1.1.4",
+ "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+ "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+ "dev": true
+ }
+ }
+ },
+ "extend": {
+ "version": "3.0.2",
+ "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz",
+ "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==",
+ "dev": true
+ },
+ "extend-shallow": {
+ "version": "3.0.2",
+ "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz",
+ "integrity": "sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=",
+ "dev": true,
+ "requires": {
+ "assign-symbols": "^1.0.0",
+ "is-extendable": "^1.0.1"
+ },
+ "dependencies": {
+ "is-extendable": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz",
+ "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==",
+ "dev": true,
+ "requires": {
+ "is-plain-object": "^2.0.4"
+ }
+ }
+ }
+ },
+ "extglob": {
+ "version": "2.0.4",
+ "resolved": "https://registry.npmjs.org/extglob/-/extglob-2.0.4.tgz",
+ "integrity": "sha512-Nmb6QXkELsuBr24CJSkilo6UHHgbekK5UiZgfE6UHD3Eb27YC6oD+bhcT+tJ6cl8dmsgdQxnWlcry8ksBIBLpw==",
+ "dev": true,
+ "requires": {
+ "array-unique": "^0.3.2",
+ "define-property": "^1.0.0",
+ "expand-brackets": "^2.1.4",
+ "extend-shallow": "^2.0.1",
+ "fragment-cache": "^0.2.1",
+ "regex-not": "^1.0.0",
+ "snapdragon": "^0.8.1",
+ "to-regex": "^3.0.1"
+ },
+ "dependencies": {
+ "define-property": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz",
+ "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=",
+ "dev": true,
+ "requires": {
+ "is-descriptor": "^1.0.0"
+ }
+ },
+ "extend-shallow": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
+ "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
+ "dev": true,
+ "requires": {
+ "is-extendable": "^0.1.0"
+ }
+ },
+ "is-accessor-descriptor": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz",
+ "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==",
+ "dev": true,
+ "requires": {
+ "kind-of": "^6.0.0"
+ }
+ },
+ "is-data-descriptor": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz",
+ "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==",
+ "dev": true,
+ "requires": {
+ "kind-of": "^6.0.0"
+ }
+ },
+ "is-descriptor": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz",
+ "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==",
+ "dev": true,
+ "requires": {
+ "is-accessor-descriptor": "^1.0.0",
+ "is-data-descriptor": "^1.0.0",
+ "kind-of": "^6.0.2"
+ }
+ }
+ }
+ },
+ "extsprintf": {
+ "version": "1.3.0",
+ "resolved": "https://registry.npmjs.org/extsprintf/-/extsprintf-1.3.0.tgz",
+ "integrity": "sha1-lpGEQOMEGnpBT4xS48V06zw+HgU=",
+ "dev": true
+ },
+ "fast-deep-equal": {
+ "version": "3.1.3",
+ "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+ "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+ "dev": true
+ },
+ "fast-diff": {
+ "version": "1.2.0",
+ "resolved": "https://registry.npmjs.org/fast-diff/-/fast-diff-1.2.0.tgz",
+ "integrity": "sha512-xJuoT5+L99XlZ8twedaRf6Ax2TgQVxvgZOYoPKqZufmJib0tL2tegPBOZb1pVNgIhlqDlA0eO0c3wBvQcmzx4w==",
+ "dev": true
+ },
+ "fast-glob": {
+ "version": "3.2.4",
+ "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.2.4.tgz",
+ "integrity": "sha512-kr/Oo6PX51265qeuCYsyGypiO5uJFgBS0jksyG7FUeCyQzNwYnzrNIMR1NXfkZXsMYXYLRAHgISHBz8gQcxKHQ==",
+ "dev": true,
+ "requires": {
+ "@nodelib/fs.stat": "^2.0.2",
+ "@nodelib/fs.walk": "^1.2.3",
+ "glob-parent": "^5.1.0",
+ "merge2": "^1.3.0",
+ "micromatch": "^4.0.2",
+ "picomatch": "^2.2.1"
+ }
+ },
+ "fast-json-stable-stringify": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+ "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
+ "dev": true
+ },
+ "fast-levenshtein": {
+ "version": "2.0.6",
+ "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
+ "integrity": "sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=",
+ "dev": true
+ },
+ "fastq": {
+ "version": "1.9.0",
+ "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.9.0.tgz",
+ "integrity": "sha512-i7FVWL8HhVY+CTkwFxkN2mk3h+787ixS5S63eb78diVRc1MCssarHq3W5cj0av7YDSwmaV928RNag+U1etRQ7w==",
+ "dev": true,
+ "requires": {
+ "reusify": "^1.0.4"
+ }
+ },
+ "fb-watchman": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/fb-watchman/-/fb-watchman-2.0.1.tgz",
+ "integrity": "sha512-DkPJKQeY6kKwmuMretBhr7G6Vodr7bFwDYTXIkfG1gjvNpaxBTQV3PbXg6bR1c1UP4jPOX0jHUbbHANL9vRjVg==",
+ "dev": true,
+ "requires": {
+ "bser": "2.1.1"
+ }
+ },
+ "file-entry-cache": {
+ "version": "6.0.0",
+ "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.0.tgz",
+ "integrity": "sha512-fqoO76jZ3ZnYrXLDRxBR1YvOvc0k844kcOg40bgsPrE25LAb/PDqTY+ho64Xh2c8ZXgIKldchCFHczG2UVRcWA==",
+ "dev": true,
+ "requires": {
+ "flat-cache": "^3.0.4"
+ }
+ },
+ "fill-range": {
+ "version": "7.0.1",
+ "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
+ "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==",
+ "dev": true,
+ "requires": {
+ "to-regex-range": "^5.0.1"
+ }
+ },
+ "find-up": {
+ "version": "4.1.0",
+ "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz",
+ "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==",
+ "dev": true,
+ "requires": {
+ "locate-path": "^5.0.0",
+ "path-exists": "^4.0.0"
+ }
+ },
+ "flat-cache": {
+ "version": "3.0.4",
+ "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-3.0.4.tgz",
+ "integrity": "sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg==",
+ "dev": true,
+ "requires": {
+ "flatted": "^3.1.0",
+ "rimraf": "^3.0.2"
+ }
+ },
+ "flatted": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.1.0.tgz",
+ "integrity": "sha512-tW+UkmtNg/jv9CSofAKvgVcO7c2URjhTdW1ZTkcAritblu8tajiYy7YisnIflEwtKssCtOxpnBRoCB7iap0/TA==",
+ "dev": true
+ },
+ "follow-redirects": {
+ "version": "1.13.0",
+ "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.13.0.tgz",
+ "integrity": "sha512-aq6gF1BEKje4a9i9+5jimNFIpq4Q1WiwBToeRK5NvZBd/TRsmW8BsJfOEGkr76TbOyPVD3OVDN910EcUNtRYEA=="
+ },
+ "for-in": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/for-in/-/for-in-1.0.2.tgz",
+ "integrity": "sha1-gQaNKVqBQuwKxybG4iAMMPttXoA=",
+ "dev": true
+ },
+ "forever-agent": {
+ "version": "0.6.1",
+ "resolved": "https://registry.npmjs.org/forever-agent/-/forever-agent-0.6.1.tgz",
+ "integrity": "sha1-+8cfDEGt6zf5bFd60e1C2P2sypE=",
+ "dev": true
+ },
+ "form-data": {
+ "version": "2.3.3",
+ "resolved": "https://registry.npmjs.org/form-data/-/form-data-2.3.3.tgz",
+ "integrity": "sha512-1lLKB2Mu3aGP1Q/2eCOx0fNbRMe7XdwktwOruhfqqd0rIJWwN4Dh+E3hrPSlDCXnSR7UtZ1N38rVXm+6+MEhJQ==",
+ "dev": true,
+ "requires": {
+ "asynckit": "^0.4.0",
+ "combined-stream": "^1.0.6",
+ "mime-types": "^2.1.12"
+ }
+ },
+ "fragment-cache": {
+ "version": "0.2.1",
+ "resolved": "https://registry.npmjs.org/fragment-cache/-/fragment-cache-0.2.1.tgz",
+ "integrity": "sha1-QpD60n8T6Jvn8zeZxrxaCr//DRk=",
+ "dev": true,
+ "requires": {
+ "map-cache": "^0.2.2"
+ }
+ },
+ "fs.realpath": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+ "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=",
+ "dev": true
+ },
+ "fsevents": {
+ "version": "2.2.1",
+ "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.2.1.tgz",
+ "integrity": "sha512-bTLYHSeC0UH/EFXS9KqWnXuOl/wHK5Z/d+ghd5AsFMYN7wIGkUCOJyzy88+wJKkZPGON8u4Z9f6U4FdgURE9qA==",
+ "dev": true,
+ "optional": true
+ },
+ "function-bind": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz",
+ "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==",
+ "dev": true
+ },
+ "functional-red-black-tree": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz",
+ "integrity": "sha1-GwqzvVU7Kg1jmdKcDj6gslIHgyc=",
+ "dev": true
+ },
+ "gensync": {
+ "version": "1.0.0-beta.2",
+ "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
+ "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+ "dev": true
+ },
+ "get-caller-file": {
+ "version": "2.0.5",
+ "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+ "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+ "dev": true
+ },
+ "get-package-type": {
+ "version": "0.1.0",
+ "resolved": "https://registry.npmjs.org/get-package-type/-/get-package-type-0.1.0.tgz",
+ "integrity": "sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==",
+ "dev": true
+ },
+ "get-stream": {
+ "version": "4.1.0",
+ "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-4.1.0.tgz",
+ "integrity": "sha512-GMat4EJ5161kIy2HevLlr4luNjBgvmj413KaQA7jt4V8B4RDsfpHk7WQ9GVqfYyyx8OS/L66Kox+rJRNklLK7w==",
+ "dev": true,
+ "requires": {
+ "pump": "^3.0.0"
+ }
+ },
+ "get-value": {
+ "version": "2.0.6",
+ "resolved": "https://registry.npmjs.org/get-value/-/get-value-2.0.6.tgz",
+ "integrity": "sha1-3BXKHGcjh8p2vTesCjlbogQqLCg=",
+ "dev": true
+ },
+ "getpass": {
+ "version": "0.1.7",
+ "resolved": "https://registry.npmjs.org/getpass/-/getpass-0.1.7.tgz",
+ "integrity": "sha1-Xv+OPmhNVprkyysSgmBOi6YhSfo=",
+ "dev": true,
+ "requires": {
+ "assert-plus": "^1.0.0"
+ }
+ },
+ "glob": {
+ "version": "7.1.6",
+ "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz",
+ "integrity": "sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==",
+ "dev": true,
+ "requires": {
+ "fs.realpath": "^1.0.0",
+ "inflight": "^1.0.4",
+ "inherits": "2",
+ "minimatch": "^3.0.4",
+ "once": "^1.3.0",
+ "path-is-absolute": "^1.0.0"
+ }
+ },
+ "glob-parent": {
+ "version": "5.1.1",
+ "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.1.tgz",
+ "integrity": "sha512-FnI+VGOpnlGHWZxthPGR+QhR78fuiK0sNLkHQv+bL9fQi57lNNdquIbna/WrfROrolq8GK5Ek6BiMwqL/voRYQ==",
+ "dev": true,
+ "requires": {
+ "is-glob": "^4.0.1"
+ }
+ },
+ "globals": {
+ "version": "12.4.0",
+ "resolved": "https://registry.npmjs.org/globals/-/globals-12.4.0.tgz",
+ "integrity": "sha512-BWICuzzDvDoH54NHKCseDanAhE3CeDorgDL5MT6LMXXj2WCnd9UC2szdk4AWLfjdgNBCXLUanXYcpBBKOSWGwg==",
+ "dev": true,
+ "requires": {
+ "type-fest": "^0.8.1"
+ }
+ },
+ "globby": {
+ "version": "11.0.1",
+ "resolved": "https://registry.npmjs.org/globby/-/globby-11.0.1.tgz",
+ "integrity": "sha512-iH9RmgwCmUJHi2z5o2l3eTtGBtXek1OYlHrbcxOYugyHLmAsZrPj43OtHThd62Buh/Vv6VyCBD2bdyWcGNQqoQ==",
+ "dev": true,
+ "requires": {
+ "array-union": "^2.1.0",
+ "dir-glob": "^3.0.1",
+ "fast-glob": "^3.1.1",
+ "ignore": "^5.1.4",
+ "merge2": "^1.3.0",
+ "slash": "^3.0.0"
+ }
+ },
+ "graceful-fs": {
+ "version": "4.2.4",
+ "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.4.tgz",
+ "integrity": "sha512-WjKPNJF79dtJAVniUlGGWHYGz2jWxT6VhN/4m1NdkbZ2nOsEF+cI1Edgql5zCRhs/VsQYRvrXctxktVXZUkixw==",
+ "dev": true
+ },
+ "growly": {
+ "version": "1.3.0",
+ "resolved": "https://registry.npmjs.org/growly/-/growly-1.3.0.tgz",
+ "integrity": "sha1-8QdIy+dq+WS3yWyTxrzCivEgwIE=",
+ "dev": true,
+ "optional": true
+ },
+ "har-schema": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/har-schema/-/har-schema-2.0.0.tgz",
+ "integrity": "sha1-qUwiJOvKwEeCoNkDVSHyRzW37JI=",
+ "dev": true
+ },
+ "har-validator": {
+ "version": "5.1.5",
+ "resolved": "https://registry.npmjs.org/har-validator/-/har-validator-5.1.5.tgz",
+ "integrity": "sha512-nmT2T0lljbxdQZfspsno9hgrG3Uir6Ks5afism62poxqBM6sDnMEuPmzTq8XN0OEwqKLLdh1jQI3qyE66Nzb3w==",
+ "dev": true,
+ "requires": {
+ "ajv": "^6.12.3",
+ "har-schema": "^2.0.0"
+ }
+ },
+ "has": {
+ "version": "1.0.3",
+ "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz",
+ "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==",
+ "dev": true,
+ "requires": {
+ "function-bind": "^1.1.1"
+ }
+ },
+ "has-flag": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
+ "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=",
+ "dev": true
+ },
+ "has-value": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/has-value/-/has-value-1.0.0.tgz",
+ "integrity": "sha1-GLKB2lhbHFxR3vJMkw7SmgvmsXc=",
+ "dev": true,
+ "requires": {
+ "get-value": "^2.0.6",
+ "has-values": "^1.0.0",
+ "isobject": "^3.0.0"
+ }
+ },
+ "has-values": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/has-values/-/has-values-1.0.0.tgz",
+ "integrity": "sha1-lbC2P+whRmGab+V/51Yo1aOe/k8=",
+ "dev": true,
+ "requires": {
+ "is-number": "^3.0.0",
+ "kind-of": "^4.0.0"
+ },
+ "dependencies": {
+ "is-number": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz",
+ "integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=",
+ "dev": true,
+ "requires": {
+ "kind-of": "^3.0.2"
+ },
+ "dependencies": {
+ "kind-of": {
+ "version": "3.2.2",
+ "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz",
+ "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
+ "dev": true,
+ "requires": {
+ "is-buffer": "^1.1.5"
+ }
+ }
+ }
+ },
+ "kind-of": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-4.0.0.tgz",
+ "integrity": "sha1-IIE989cSkosgc3hpGkUGb65y3Vc=",
+ "dev": true,
+ "requires": {
+ "is-buffer": "^1.1.5"
+ }
+ }
+ }
+ },
+ "hosted-git-info": {
+ "version": "2.8.8",
+ "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.8.8.tgz",
+ "integrity": "sha512-f/wzC2QaWBs7t9IYqB4T3sR1xviIViXJRJTWBlx2Gf3g0Xi5vI7Yy4koXQ1c9OYDGHN9sBy1DQ2AB8fqZBWhUg==",
+ "dev": true
+ },
+ "html-encoding-sniffer": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-2.0.1.tgz",
+ "integrity": "sha512-D5JbOMBIR/TVZkubHT+OyT2705QvogUW4IBn6nHd756OwieSF9aDYFj4dv6HHEVGYbHaLETa3WggZYWWMyy3ZQ==",
+ "dev": true,
+ "requires": {
+ "whatwg-encoding": "^1.0.5"
+ }
+ },
+ "html-escaper": {
+ "version": "2.0.2",
+ "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz",
+ "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==",
+ "dev": true
+ },
+ "http-signature": {
+ "version": "1.2.0",
+ "resolved": "https://registry.npmjs.org/http-signature/-/http-signature-1.2.0.tgz",
+ "integrity": "sha1-muzZJRFHcvPZW2WmCruPfBj7rOE=",
+ "dev": true,
+ "requires": {
+ "assert-plus": "^1.0.0",
+ "jsprim": "^1.2.2",
+ "sshpk": "^1.7.0"
+ }
+ },
+ "human-signals": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-1.1.1.tgz",
+ "integrity": "sha512-SEQu7vl8KjNL2eoGBLF3+wAjpsNfA9XMlXAYj/3EdaNfAlxKthD1xjEQfGOUhllCGGJVNY34bRr6lPINhNjyZw==",
+ "dev": true
+ },
+ "iconv-lite": {
+ "version": "0.4.24",
+ "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
+ "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
+ "dev": true,
+ "requires": {
+ "safer-buffer": ">= 2.1.2 < 3"
+ }
+ },
+ "ignore": {
+ "version": "5.1.8",
+ "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.1.8.tgz",
+ "integrity": "sha512-BMpfD7PpiETpBl/A6S498BaIJ6Y/ABT93ETbby2fP00v4EbvPBXWEoaR1UBPKs3iR53pJY7EtZk5KACI57i1Uw==",
+ "dev": true
+ },
+ "import-fresh": {
+ "version": "3.2.2",
+ "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.2.2.tgz",
+ "integrity": "sha512-cTPNrlvJT6twpYy+YmKUKrTSjWFs3bjYjAhCwm+z4EOCubZxAuO+hHpRN64TqjEaYSHs7tJAE0w1CKMGmsG/lw==",
+ "dev": true,
+ "requires": {
+ "parent-module": "^1.0.0",
+ "resolve-from": "^4.0.0"
+ }
+ },
+ "import-local": {
+ "version": "3.0.2",
+ "resolved": "https://registry.npmjs.org/import-local/-/import-local-3.0.2.tgz",
+ "integrity": "sha512-vjL3+w0oulAVZ0hBHnxa/Nm5TAurf9YLQJDhqRZyqb+VKGOB6LU8t9H1Nr5CIo16vh9XfJTOoHwU0B71S557gA==",
+ "dev": true,
+ "requires": {
+ "pkg-dir": "^4.2.0",
+ "resolve-cwd": "^3.0.0"
+ }
+ },
+ "imurmurhash": {
+ "version": "0.1.4",
+ "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
+ "integrity": "sha1-khi5srkoojixPcT7a21XbyMUU+o=",
+ "dev": true
+ },
+ "indent-string": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz",
+ "integrity": "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==",
+ "dev": true
+ },
+ "inflight": {
+ "version": "1.0.6",
+ "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+ "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=",
+ "dev": true,
+ "requires": {
+ "once": "^1.3.0",
+ "wrappy": "1"
+ }
+ },
+ "inherits": {
+ "version": "2.0.4",
+ "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+ "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
+ },
+ "ip-regex": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/ip-regex/-/ip-regex-2.1.0.tgz",
+ "integrity": "sha1-+ni/XS5pE8kRzp+BnuUUa7bYROk=",
+ "dev": true
+ },
+ "is-accessor-descriptor": {
+ "version": "0.1.6",
+ "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz",
+ "integrity": "sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=",
+ "dev": true,
+ "requires": {
+ "kind-of": "^3.0.2"
+ },
+ "dependencies": {
+ "kind-of": {
+ "version": "3.2.2",
+ "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz",
+ "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
+ "dev": true,
+ "requires": {
+ "is-buffer": "^1.1.5"
+ }
+ }
+ }
+ },
+ "is-arrayish": {
+ "version": "0.2.1",
+ "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz",
+ "integrity": "sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=",
+ "dev": true
+ },
+ "is-buffer": {
+ "version": "1.1.6",
+ "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.6.tgz",
+ "integrity": "sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==",
+ "dev": true
+ },
+ "is-ci": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/is-ci/-/is-ci-2.0.0.tgz",
+ "integrity": "sha512-YfJT7rkpQB0updsdHLGWrvhBJfcfzNNawYDNIyQXJz0IViGf75O8EBPKSdvw2rF+LGCsX4FZ8tcr3b19LcZq4w==",
+ "dev": true,
+ "requires": {
+ "ci-info": "^2.0.0"
+ }
+ },
+ "is-core-module": {
+ "version": "2.2.0",
+ "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.2.0.tgz",
+ "integrity": "sha512-XRAfAdyyY5F5cOXn7hYQDqh2Xmii+DEfIcQGxK/uNwMHhIkPWO0g8msXcbzLe+MpGoR951MlqM/2iIlU4vKDdQ==",
+ "dev": true,
+ "requires": {
+ "has": "^1.0.3"
+ }
+ },
+ "is-data-descriptor": {
+ "version": "0.1.4",
+ "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz",
+ "integrity": "sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=",
+ "dev": true,
+ "requires": {
+ "kind-of": "^3.0.2"
+ },
+ "dependencies": {
+ "kind-of": {
+ "version": "3.2.2",
+ "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz",
+ "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
+ "dev": true,
+ "requires": {
+ "is-buffer": "^1.1.5"
+ }
+ }
+ }
+ },
+ "is-descriptor": {
+ "version": "0.1.6",
+ "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-0.1.6.tgz",
+ "integrity": "sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==",
+ "dev": true,
+ "requires": {
+ "is-accessor-descriptor": "^0.1.6",
+ "is-data-descriptor": "^0.1.4",
+ "kind-of": "^5.0.0"
+ },
+ "dependencies": {
+ "kind-of": {
+ "version": "5.1.0",
+ "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-5.1.0.tgz",
+ "integrity": "sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw==",
+ "dev": true
+ }
+ }
+ },
+ "is-docker": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/is-docker/-/is-docker-2.1.1.tgz",
+ "integrity": "sha512-ZOoqiXfEwtGknTiuDEy8pN2CfE3TxMHprvNer1mXiqwkOT77Rw3YVrUQ52EqAOU3QAWDQ+bQdx7HJzrv7LS2Hw==",
+ "dev": true,
+ "optional": true
+ },
+ "is-extendable": {
+ "version": "0.1.1",
+ "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz",
+ "integrity": "sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=",
+ "dev": true
+ },
+ "is-extglob": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+ "integrity": "sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=",
+ "dev": true
+ },
+ "is-fullwidth-code-point": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
+ "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=",
+ "dev": true
+ },
+ "is-generator-fn": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/is-generator-fn/-/is-generator-fn-2.1.0.tgz",
+ "integrity": "sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ==",
+ "dev": true
+ },
+ "is-glob": {
+ "version": "4.0.1",
+ "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.1.tgz",
+ "integrity": "sha512-5G0tKtBTFImOqDnLB2hG6Bp2qcKEFduo4tZu9MT/H6NQv/ghhy30o55ufafxJ/LdH79LLs2Kfrn85TLKyA7BUg==",
+ "dev": true,
+ "requires": {
+ "is-extglob": "^2.1.1"
+ }
+ },
+ "is-number": {
+ "version": "7.0.0",
+ "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+ "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+ "dev": true
+ },
+ "is-path-cwd": {
+ "version": "2.2.0",
+ "resolved": "https://registry.npmjs.org/is-path-cwd/-/is-path-cwd-2.2.0.tgz",
+ "integrity": "sha512-w942bTcih8fdJPJmQHFzkS76NEP8Kzzvmw92cXsazb8intwLqPibPPdXf4ANdKV3rYMuuQYGIWtvz9JilB3NFQ==",
+ "dev": true
+ },
+ "is-path-inside": {
+ "version": "3.0.2",
+ "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.2.tgz",
+ "integrity": "sha512-/2UGPSgmtqwo1ktx8NDHjuPwZWmHhO+gj0f93EkhLB5RgW9RZevWYYlIkS6zePc6U2WpOdQYIwHe9YC4DWEBVg==",
+ "dev": true
+ },
+ "is-plain-object": {
+ "version": "2.0.4",
+ "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz",
+ "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==",
+ "dev": true,
+ "requires": {
+ "isobject": "^3.0.1"
+ }
+ },
+ "is-potential-custom-element-name": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.0.tgz",
+ "integrity": "sha1-DFLlS8yjkbssSUsh6GJtczbG45c=",
+ "dev": true
+ },
+ "is-stream": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-1.1.0.tgz",
+ "integrity": "sha1-EtSj3U5o4Lec6428hBc66A2RykQ=",
+ "dev": true
+ },
+ "is-typedarray": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz",
+ "integrity": "sha1-5HnICFjfDBsR3dppQPlgEfzaSpo=",
+ "dev": true
+ },
+ "is-windows": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/is-windows/-/is-windows-1.0.2.tgz",
+ "integrity": "sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==",
+ "dev": true
+ },
+ "is-wsl": {
+ "version": "2.2.0",
+ "resolved": "https://registry.npmjs.org/is-wsl/-/is-wsl-2.2.0.tgz",
+ "integrity": "sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==",
+ "dev": true,
+ "optional": true,
+ "requires": {
+ "is-docker": "^2.0.0"
+ }
+ },
+ "isarray": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
+ "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=",
+ "dev": true
+ },
+ "isexe": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+ "integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=",
+ "dev": true
+ },
+ "isobject": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz",
+ "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=",
+ "dev": true
+ },
+ "isstream": {
+ "version": "0.1.2",
+ "resolved": "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz",
+ "integrity": "sha1-R+Y/evVa+m+S4VAOaQ64uFKcCZo=",
+ "dev": true
+ },
+ "istanbul-lib-coverage": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.0.0.tgz",
+ "integrity": "sha512-UiUIqxMgRDET6eR+o5HbfRYP1l0hqkWOs7vNxC/mggutCMUIhWMm8gAHb8tHlyfD3/l6rlgNA5cKdDzEAf6hEg==",
+ "dev": true
+ },
+ "istanbul-lib-instrument": {
+ "version": "4.0.3",
+ "resolved": "https://registry.npmjs.org/istanbul-lib-instrument/-/istanbul-lib-instrument-4.0.3.tgz",
+ "integrity": "sha512-BXgQl9kf4WTCPCCpmFGoJkz/+uhvm7h7PFKUYxh7qarQd3ER33vHG//qaE8eN25l07YqZPpHXU9I09l/RD5aGQ==",
+ "dev": true,
+ "requires": {
+ "@babel/core": "^7.7.5",
+ "@istanbuljs/schema": "^0.1.2",
+ "istanbul-lib-coverage": "^3.0.0",
+ "semver": "^6.3.0"
+ },
+ "dependencies": {
+ "semver": {
+ "version": "6.3.0",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz",
+ "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==",
+ "dev": true
+ }
+ }
+ },
+ "istanbul-lib-report": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.0.tgz",
+ "integrity": "sha512-wcdi+uAKzfiGT2abPpKZ0hSU1rGQjUQnLvtY5MpQ7QCTahD3VODhcu4wcfY1YtkGaDD5yuydOLINXsfbus9ROw==",
+ "dev": true,
+ "requires": {
+ "istanbul-lib-coverage": "^3.0.0",
+ "make-dir": "^3.0.0",
+ "supports-color": "^7.1.0"
+ },
+ "dependencies": {
+ "has-flag": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+ "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+ "dev": true
+ },
+ "supports-color": {
+ "version": "7.2.0",
+ "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+ "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+ "dev": true,
+ "requires": {
+ "has-flag": "^4.0.0"
+ }
+ }
+ }
+ },
+ "istanbul-lib-source-maps": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/istanbul-lib-source-maps/-/istanbul-lib-source-maps-4.0.0.tgz",
+ "integrity": "sha512-c16LpFRkR8vQXyHZ5nLpY35JZtzj1PQY1iZmesUbf1FZHbIupcWfjgOXBY9YHkLEQ6puz1u4Dgj6qmU/DisrZg==",
+ "dev": true,
+ "requires": {
+ "debug": "^4.1.1",
+ "istanbul-lib-coverage": "^3.0.0",
+ "source-map": "^0.6.1"
+ }
+ },
+ "istanbul-reports": {
+ "version": "3.0.2",
+ "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.0.2.tgz",
+ "integrity": "sha512-9tZvz7AiR3PEDNGiV9vIouQ/EAcqMXFmkcA1CDFTwOB98OZVDL0PH9glHotf5Ugp6GCOTypfzGWI/OqjWNCRUw==",
+ "dev": true,
+ "requires": {
+ "html-escaper": "^2.0.0",
+ "istanbul-lib-report": "^3.0.0"
+ }
+ },
+ "jest": {
+ "version": "26.6.3",
+ "resolved": "https://registry.npmjs.org/jest/-/jest-26.6.3.tgz",
+ "integrity": "sha512-lGS5PXGAzR4RF7V5+XObhqz2KZIDUA1yD0DG6pBVmy10eh0ZIXQImRuzocsI/N2XZ1GrLFwTS27In2i2jlpq1Q==",
+ "dev": true,
+ "requires": {
+ "@jest/core": "^26.6.3",
+ "import-local": "^3.0.2",
+ "jest-cli": "^26.6.3"
+ },
+ "dependencies": {
+ "jest-cli": {
+ "version": "26.6.3",
+ "resolved": "https://registry.npmjs.org/jest-cli/-/jest-cli-26.6.3.tgz",
+ "integrity": "sha512-GF9noBSa9t08pSyl3CY4frMrqp+aQXFGFkf5hEPbh/pIUFYWMK6ZLTfbmadxJVcJrdRoChlWQsA2VkJcDFK8hg==",
+ "dev": true,
+ "requires": {
+ "@jest/core": "^26.6.3",
+ "@jest/test-result": "^26.6.2",
+ "@jest/types": "^26.6.2",
+ "chalk": "^4.0.0",
+ "exit": "^0.1.2",
+ "graceful-fs": "^4.2.4",
+ "import-local": "^3.0.2",
+ "is-ci": "^2.0.0",
+ "jest-config": "^26.6.3",
+ "jest-util": "^26.6.2",
+ "jest-validate": "^26.6.2",
+ "prompts": "^2.0.1",
+ "yargs": "^15.4.1"
+ }
+ }
+ }
+ },
+ "jest-changed-files": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/jest-changed-files/-/jest-changed-files-26.6.2.tgz",
+ "integrity": "sha512-fDS7szLcY9sCtIip8Fjry9oGf3I2ht/QT21bAHm5Dmf0mD4X3ReNUf17y+bO6fR8WgbIZTlbyG1ak/53cbRzKQ==",
+ "dev": true,
+ "requires": {
+ "@jest/types": "^26.6.2",
+ "execa": "^4.0.0",
+ "throat": "^5.0.0"
+ },
+ "dependencies": {
+ "execa": {
+ "version": "4.1.0",
+ "resolved": "https://registry.npmjs.org/execa/-/execa-4.1.0.tgz",
+ "integrity": "sha512-j5W0//W7f8UxAn8hXVnwG8tLwdiUy4FJLcSupCg6maBYZDpyBvTApK7KyuI4bKj8KOh1r2YH+6ucuYtJv1bTZA==",
+ "dev": true,
+ "requires": {
+ "cross-spawn": "^7.0.0",
+ "get-stream": "^5.0.0",
+ "human-signals": "^1.1.1",
+ "is-stream": "^2.0.0",
+ "merge-stream": "^2.0.0",
+ "npm-run-path": "^4.0.0",
+ "onetime": "^5.1.0",
+ "signal-exit": "^3.0.2",
+ "strip-final-newline": "^2.0.0"
+ }
+ },
+ "get-stream": {
+ "version": "5.2.0",
+ "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz",
+ "integrity": "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==",
+ "dev": true,
+ "requires": {
+ "pump": "^3.0.0"
+ }
+ },
+ "is-stream": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.0.tgz",
+ "integrity": "sha512-XCoy+WlUr7d1+Z8GgSuXmpuUFC9fOhRXglJMx+dwLKTkL44Cjd4W1Z5P+BQZpr+cR93aGP4S/s7Ftw6Nd/kiEw==",
+ "dev": true
+ },
+ "npm-run-path": {
+ "version": "4.0.1",
+ "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.1.tgz",
+ "integrity": "sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==",
+ "dev": true,
+ "requires": {
+ "path-key": "^3.0.0"
+ }
+ }
+ }
+ },
+ "jest-config": {
+ "version": "26.6.3",
+ "resolved": "https://registry.npmjs.org/jest-config/-/jest-config-26.6.3.tgz",
+ "integrity": "sha512-t5qdIj/bCj2j7NFVHb2nFB4aUdfucDn3JRKgrZnplb8nieAirAzRSHP8uDEd+qV6ygzg9Pz4YG7UTJf94LPSyg==",
+ "dev": true,
+ "requires": {
+ "@babel/core": "^7.1.0",
+ "@jest/test-sequencer": "^26.6.3",
+ "@jest/types": "^26.6.2",
+ "babel-jest": "^26.6.3",
+ "chalk": "^4.0.0",
+ "deepmerge": "^4.2.2",
+ "glob": "^7.1.1",
+ "graceful-fs": "^4.2.4",
+ "jest-environment-jsdom": "^26.6.2",
+ "jest-environment-node": "^26.6.2",
+ "jest-get-type": "^26.3.0",
+ "jest-jasmine2": "^26.6.3",
+ "jest-regex-util": "^26.0.0",
+ "jest-resolve": "^26.6.2",
+ "jest-util": "^26.6.2",
+ "jest-validate": "^26.6.2",
+ "micromatch": "^4.0.2",
+ "pretty-format": "^26.6.2"
+ }
+ },
+ "jest-diff": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-26.6.2.tgz",
+ "integrity": "sha512-6m+9Z3Gv9wN0WFVasqjCL/06+EFCMTqDEUl/b87HYK2rAPTyfz4ZIuSlPhY51PIQRWx5TaxeF1qmXKe9gfN3sA==",
+ "dev": true,
+ "requires": {
+ "chalk": "^4.0.0",
+ "diff-sequences": "^26.6.2",
+ "jest-get-type": "^26.3.0",
+ "pretty-format": "^26.6.2"
+ }
+ },
+ "jest-docblock": {
+ "version": "26.0.0",
+ "resolved": "https://registry.npmjs.org/jest-docblock/-/jest-docblock-26.0.0.tgz",
+ "integrity": "sha512-RDZ4Iz3QbtRWycd8bUEPxQsTlYazfYn/h5R65Fc6gOfwozFhoImx+affzky/FFBuqISPTqjXomoIGJVKBWoo0w==",
+ "dev": true,
+ "requires": {
+ "detect-newline": "^3.0.0"
+ }
+ },
+ "jest-each": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/jest-each/-/jest-each-26.6.2.tgz",
+ "integrity": "sha512-Mer/f0KaATbjl8MCJ+0GEpNdqmnVmDYqCTJYTvoo7rqmRiDllmp2AYN+06F93nXcY3ur9ShIjS+CO/uD+BbH4A==",
+ "dev": true,
+ "requires": {
+ "@jest/types": "^26.6.2",
+ "chalk": "^4.0.0",
+ "jest-get-type": "^26.3.0",
+ "jest-util": "^26.6.2",
+ "pretty-format": "^26.6.2"
+ }
+ },
+ "jest-environment-jsdom": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/jest-environment-jsdom/-/jest-environment-jsdom-26.6.2.tgz",
+ "integrity": "sha512-jgPqCruTlt3Kwqg5/WVFyHIOJHsiAvhcp2qiR2QQstuG9yWox5+iHpU3ZrcBxW14T4fe5Z68jAfLRh7joCSP2Q==",
+ "dev": true,
+ "requires": {
+ "@jest/environment": "^26.6.2",
+ "@jest/fake-timers": "^26.6.2",
+ "@jest/types": "^26.6.2",
+ "@types/node": "*",
+ "jest-mock": "^26.6.2",
+ "jest-util": "^26.6.2",
+ "jsdom": "^16.4.0"
+ }
+ },
+ "jest-environment-node": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/jest-environment-node/-/jest-environment-node-26.6.2.tgz",
+ "integrity": "sha512-zhtMio3Exty18dy8ee8eJ9kjnRyZC1N4C1Nt/VShN1apyXc8rWGtJ9lI7vqiWcyyXS4BVSEn9lxAM2D+07/Tag==",
+ "dev": true,
+ "requires": {
+ "@jest/environment": "^26.6.2",
+ "@jest/fake-timers": "^26.6.2",
+ "@jest/types": "^26.6.2",
+ "@types/node": "*",
+ "jest-mock": "^26.6.2",
+ "jest-util": "^26.6.2"
+ }
+ },
+ "jest-get-type": {
+ "version": "26.3.0",
+ "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-26.3.0.tgz",
+ "integrity": "sha512-TpfaviN1R2pQWkIihlfEanwOXK0zcxrKEE4MlU6Tn7keoXdN6/3gK/xl0yEh8DOunn5pOVGKf8hB4R9gVh04ig==",
+ "dev": true
+ },
+ "jest-haste-map": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/jest-haste-map/-/jest-haste-map-26.6.2.tgz",
+ "integrity": "sha512-easWIJXIw71B2RdR8kgqpjQrbMRWQBgiBwXYEhtGUTaX+doCjBheluShdDMeR8IMfJiTqH4+zfhtg29apJf/8w==",
+ "dev": true,
+ "requires": {
+ "@jest/types": "^26.6.2",
+ "@types/graceful-fs": "^4.1.2",
+ "@types/node": "*",
+ "anymatch": "^3.0.3",
+ "fb-watchman": "^2.0.0",
+ "fsevents": "^2.1.2",
+ "graceful-fs": "^4.2.4",
+ "jest-regex-util": "^26.0.0",
+ "jest-serializer": "^26.6.2",
+ "jest-util": "^26.6.2",
+ "jest-worker": "^26.6.2",
+ "micromatch": "^4.0.2",
+ "sane": "^4.0.3",
+ "walker": "^1.0.7"
+ }
+ },
+ "jest-jasmine2": {
+ "version": "26.6.3",
+ "resolved": "https://registry.npmjs.org/jest-jasmine2/-/jest-jasmine2-26.6.3.tgz",
+ "integrity": "sha512-kPKUrQtc8aYwBV7CqBg5pu+tmYXlvFlSFYn18ev4gPFtrRzB15N2gW/Roew3187q2w2eHuu0MU9TJz6w0/nPEg==",
+ "dev": true,
+ "requires": {
+ "@babel/traverse": "^7.1.0",
+ "@jest/environment": "^26.6.2",
+ "@jest/source-map": "^26.6.2",
+ "@jest/test-result": "^26.6.2",
+ "@jest/types": "^26.6.2",
+ "@types/node": "*",
+ "chalk": "^4.0.0",
+ "co": "^4.6.0",
+ "expect": "^26.6.2",
+ "is-generator-fn": "^2.0.0",
+ "jest-each": "^26.6.2",
+ "jest-matcher-utils": "^26.6.2",
+ "jest-message-util": "^26.6.2",
+ "jest-runtime": "^26.6.3",
+ "jest-snapshot": "^26.6.2",
+ "jest-util": "^26.6.2",
+ "pretty-format": "^26.6.2",
+ "throat": "^5.0.0"
+ }
+ },
+ "jest-leak-detector": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/jest-leak-detector/-/jest-leak-detector-26.6.2.tgz",
+ "integrity": "sha512-i4xlXpsVSMeKvg2cEKdfhh0H39qlJlP5Ex1yQxwF9ubahboQYMgTtz5oML35AVA3B4Eu+YsmwaiKVev9KCvLxg==",
+ "dev": true,
+ "requires": {
+ "jest-get-type": "^26.3.0",
+ "pretty-format": "^26.6.2"
+ }
+ },
+ "jest-matcher-utils": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-26.6.2.tgz",
+ "integrity": "sha512-llnc8vQgYcNqDrqRDXWwMr9i7rS5XFiCwvh6DTP7Jqa2mqpcCBBlpCbn+trkG0KNhPu/h8rzyBkriOtBstvWhw==",
+ "dev": true,
+ "requires": {
+ "chalk": "^4.0.0",
+ "jest-diff": "^26.6.2",
+ "jest-get-type": "^26.3.0",
+ "pretty-format": "^26.6.2"
+ }
+ },
+ "jest-message-util": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-26.6.2.tgz",
+ "integrity": "sha512-rGiLePzQ3AzwUshu2+Rn+UMFk0pHN58sOG+IaJbk5Jxuqo3NYO1U2/MIR4S1sKgsoYSXSzdtSa0TgrmtUwEbmA==",
+ "dev": true,
+ "requires": {
+ "@babel/code-frame": "^7.0.0",
+ "@jest/types": "^26.6.2",
+ "@types/stack-utils": "^2.0.0",
+ "chalk": "^4.0.0",
+ "graceful-fs": "^4.2.4",
+ "micromatch": "^4.0.2",
+ "pretty-format": "^26.6.2",
+ "slash": "^3.0.0",
+ "stack-utils": "^2.0.2"
+ }
+ },
+ "jest-mock": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/jest-mock/-/jest-mock-26.6.2.tgz",
+ "integrity": "sha512-YyFjePHHp1LzpzYcmgqkJ0nm0gg/lJx2aZFzFy1S6eUqNjXsOqTK10zNRff2dNfssgokjkG65OlWNcIlgd3zew==",
+ "dev": true,
+ "requires": {
+ "@jest/types": "^26.6.2",
+ "@types/node": "*"
+ }
+ },
+ "jest-pnp-resolver": {
+ "version": "1.2.2",
+ "resolved": "https://registry.npmjs.org/jest-pnp-resolver/-/jest-pnp-resolver-1.2.2.tgz",
+ "integrity": "sha512-olV41bKSMm8BdnuMsewT4jqlZ8+3TCARAXjZGT9jcoSnrfUnRCqnMoF9XEeoWjbzObpqF9dRhHQj0Xb9QdF6/w==",
+ "dev": true
+ },
+ "jest-regex-util": {
+ "version": "26.0.0",
+ "resolved": "https://registry.npmjs.org/jest-regex-util/-/jest-regex-util-26.0.0.tgz",
+ "integrity": "sha512-Gv3ZIs/nA48/Zvjrl34bf+oD76JHiGDUxNOVgUjh3j890sblXryjY4rss71fPtD/njchl6PSE2hIhvyWa1eT0A==",
+ "dev": true
+ },
+ "jest-resolve": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/jest-resolve/-/jest-resolve-26.6.2.tgz",
+ "integrity": "sha512-sOxsZOq25mT1wRsfHcbtkInS+Ek7Q8jCHUB0ZUTP0tc/c41QHriU/NunqMfCUWsL4H3MHpvQD4QR9kSYhS7UvQ==",
+ "dev": true,
+ "requires": {
+ "@jest/types": "^26.6.2",
+ "chalk": "^4.0.0",
+ "graceful-fs": "^4.2.4",
+ "jest-pnp-resolver": "^1.2.2",
+ "jest-util": "^26.6.2",
+ "read-pkg-up": "^7.0.1",
+ "resolve": "^1.18.1",
+ "slash": "^3.0.0"
+ }
+ },
+ "jest-resolve-dependencies": {
+ "version": "26.6.3",
+ "resolved": "https://registry.npmjs.org/jest-resolve-dependencies/-/jest-resolve-dependencies-26.6.3.tgz",
+ "integrity": "sha512-pVwUjJkxbhe4RY8QEWzN3vns2kqyuldKpxlxJlzEYfKSvY6/bMvxoFrYYzUO1Gx28yKWN37qyV7rIoIp2h8fTg==",
+ "dev": true,
+ "requires": {
+ "@jest/types": "^26.6.2",
+ "jest-regex-util": "^26.0.0",
+ "jest-snapshot": "^26.6.2"
+ }
+ },
+ "jest-runner": {
+ "version": "26.6.3",
+ "resolved": "https://registry.npmjs.org/jest-runner/-/jest-runner-26.6.3.tgz",
+ "integrity": "sha512-atgKpRHnaA2OvByG/HpGA4g6CSPS/1LK0jK3gATJAoptC1ojltpmVlYC3TYgdmGp+GLuhzpH30Gvs36szSL2JQ==",
+ "dev": true,
+ "requires": {
+ "@jest/console": "^26.6.2",
+ "@jest/environment": "^26.6.2",
+ "@jest/test-result": "^26.6.2",
+ "@jest/types": "^26.6.2",
+ "@types/node": "*",
+ "chalk": "^4.0.0",
+ "emittery": "^0.7.1",
+ "exit": "^0.1.2",
+ "graceful-fs": "^4.2.4",
+ "jest-config": "^26.6.3",
+ "jest-docblock": "^26.0.0",
+ "jest-haste-map": "^26.6.2",
+ "jest-leak-detector": "^26.6.2",
+ "jest-message-util": "^26.6.2",
+ "jest-resolve": "^26.6.2",
+ "jest-runtime": "^26.6.3",
+ "jest-util": "^26.6.2",
+ "jest-worker": "^26.6.2",
+ "source-map-support": "^0.5.6",
+ "throat": "^5.0.0"
+ }
+ },
+ "jest-runtime": {
+ "version": "26.6.3",
+ "resolved": "https://registry.npmjs.org/jest-runtime/-/jest-runtime-26.6.3.tgz",
+ "integrity": "sha512-lrzyR3N8sacTAMeonbqpnSka1dHNux2uk0qqDXVkMv2c/A3wYnvQ4EXuI013Y6+gSKSCxdaczvf4HF0mVXHRdw==",
+ "dev": true,
+ "requires": {
+ "@jest/console": "^26.6.2",
+ "@jest/environment": "^26.6.2",
+ "@jest/fake-timers": "^26.6.2",
+ "@jest/globals": "^26.6.2",
+ "@jest/source-map": "^26.6.2",
+ "@jest/test-result": "^26.6.2",
+ "@jest/transform": "^26.6.2",
+ "@jest/types": "^26.6.2",
+ "@types/yargs": "^15.0.0",
+ "chalk": "^4.0.0",
+ "cjs-module-lexer": "^0.6.0",
+ "collect-v8-coverage": "^1.0.0",
+ "exit": "^0.1.2",
+ "glob": "^7.1.3",
+ "graceful-fs": "^4.2.4",
+ "jest-config": "^26.6.3",
+ "jest-haste-map": "^26.6.2",
+ "jest-message-util": "^26.6.2",
+ "jest-mock": "^26.6.2",
+ "jest-regex-util": "^26.0.0",
+ "jest-resolve": "^26.6.2",
+ "jest-snapshot": "^26.6.2",
+ "jest-util": "^26.6.2",
+ "jest-validate": "^26.6.2",
+ "slash": "^3.0.0",
+ "strip-bom": "^4.0.0",
+ "yargs": "^15.4.1"
+ }
+ },
+ "jest-serializer": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/jest-serializer/-/jest-serializer-26.6.2.tgz",
+ "integrity": "sha512-S5wqyz0DXnNJPd/xfIzZ5Xnp1HrJWBczg8mMfMpN78OJ5eDxXyf+Ygld9wX1DnUWbIbhM1YDY95NjR4CBXkb2g==",
+ "dev": true,
+ "requires": {
+ "@types/node": "*",
+ "graceful-fs": "^4.2.4"
+ }
+ },
+ "jest-snapshot": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/jest-snapshot/-/jest-snapshot-26.6.2.tgz",
+ "integrity": "sha512-OLhxz05EzUtsAmOMzuupt1lHYXCNib0ECyuZ/PZOx9TrZcC8vL0x+DUG3TL+GLX3yHG45e6YGjIm0XwDc3q3og==",
+ "dev": true,
+ "requires": {
+ "@babel/types": "^7.0.0",
+ "@jest/types": "^26.6.2",
+ "@types/babel__traverse": "^7.0.4",
+ "@types/prettier": "^2.0.0",
+ "chalk": "^4.0.0",
+ "expect": "^26.6.2",
+ "graceful-fs": "^4.2.4",
+ "jest-diff": "^26.6.2",
+ "jest-get-type": "^26.3.0",
+ "jest-haste-map": "^26.6.2",
+ "jest-matcher-utils": "^26.6.2",
+ "jest-message-util": "^26.6.2",
+ "jest-resolve": "^26.6.2",
+ "natural-compare": "^1.4.0",
+ "pretty-format": "^26.6.2",
+ "semver": "^7.3.2"
+ }
+ },
+ "jest-util": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-26.6.2.tgz",
+ "integrity": "sha512-MDW0fKfsn0OI7MS7Euz6h8HNDXVQ0gaM9uW6RjfDmd1DAFcaxX9OqIakHIqhbnmF08Cf2DLDG+ulq8YQQ0Lp0Q==",
+ "dev": true,
+ "requires": {
+ "@jest/types": "^26.6.2",
+ "@types/node": "*",
+ "chalk": "^4.0.0",
+ "graceful-fs": "^4.2.4",
+ "is-ci": "^2.0.0",
+ "micromatch": "^4.0.2"
+ }
+ },
+ "jest-validate": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/jest-validate/-/jest-validate-26.6.2.tgz",
+ "integrity": "sha512-NEYZ9Aeyj0i5rQqbq+tpIOom0YS1u2MVu6+euBsvpgIme+FOfRmoC4R5p0JiAUpaFvFy24xgrpMknarR/93XjQ==",
+ "dev": true,
+ "requires": {
+ "@jest/types": "^26.6.2",
+ "camelcase": "^6.0.0",
+ "chalk": "^4.0.0",
+ "jest-get-type": "^26.3.0",
+ "leven": "^3.1.0",
+ "pretty-format": "^26.6.2"
+ },
+ "dependencies": {
+ "camelcase": {
+ "version": "6.2.0",
+ "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.2.0.tgz",
+ "integrity": "sha512-c7wVvbw3f37nuobQNtgsgG9POC9qMbNuMQmTCqZv23b6MIz0fcYpBiOlv9gEN/hdLdnZTDQhg6e9Dq5M1vKvfg==",
+ "dev": true
+ }
+ }
+ },
+ "jest-watcher": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/jest-watcher/-/jest-watcher-26.6.2.tgz",
+ "integrity": "sha512-WKJob0P/Em2csiVthsI68p6aGKTIcsfjH9Gsx1f0A3Italz43e3ho0geSAVsmj09RWOELP1AZ/DXyJgOgDKxXQ==",
+ "dev": true,
+ "requires": {
+ "@jest/test-result": "^26.6.2",
+ "@jest/types": "^26.6.2",
+ "@types/node": "*",
+ "ansi-escapes": "^4.2.1",
+ "chalk": "^4.0.0",
+ "jest-util": "^26.6.2",
+ "string-length": "^4.0.1"
+ }
+ },
+ "jest-worker": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-26.6.2.tgz",
+ "integrity": "sha512-KWYVV1c4i+jbMpaBC+U++4Va0cp8OisU185o73T1vo99hqi7w8tSJfUXYswwqqrjzwxa6KpRK54WhPvwf5w6PQ==",
+ "dev": true,
+ "requires": {
+ "@types/node": "*",
+ "merge-stream": "^2.0.0",
+ "supports-color": "^7.0.0"
+ },
+ "dependencies": {
+ "has-flag": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+ "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+ "dev": true
+ },
+ "supports-color": {
+ "version": "7.2.0",
+ "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+ "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+ "dev": true,
+ "requires": {
+ "has-flag": "^4.0.0"
+ }
+ }
+ }
+ },
+ "js-tokens": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+ "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+ "dev": true
+ },
+ "js-yaml": {
+ "version": "3.14.1",
+ "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz",
+ "integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==",
+ "dev": true,
+ "requires": {
+ "argparse": "^1.0.7",
+ "esprima": "^4.0.0"
+ }
+ },
+ "jsbn": {
+ "version": "0.1.1",
+ "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-0.1.1.tgz",
+ "integrity": "sha1-peZUwuWi3rXyAdls77yoDA7y9RM=",
+ "dev": true
+ },
+ "jsdom": {
+ "version": "16.4.0",
+ "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-16.4.0.tgz",
+ "integrity": "sha512-lYMm3wYdgPhrl7pDcRmvzPhhrGVBeVhPIqeHjzeiHN3DFmD1RBpbExbi8vU7BJdH8VAZYovR8DMt0PNNDM7k8w==",
+ "dev": true,
+ "requires": {
+ "abab": "^2.0.3",
+ "acorn": "^7.1.1",
+ "acorn-globals": "^6.0.0",
+ "cssom": "^0.4.4",
+ "cssstyle": "^2.2.0",
+ "data-urls": "^2.0.0",
+ "decimal.js": "^10.2.0",
+ "domexception": "^2.0.1",
+ "escodegen": "^1.14.1",
+ "html-encoding-sniffer": "^2.0.1",
+ "is-potential-custom-element-name": "^1.0.0",
+ "nwsapi": "^2.2.0",
+ "parse5": "5.1.1",
+ "request": "^2.88.2",
+ "request-promise-native": "^1.0.8",
+ "saxes": "^5.0.0",
+ "symbol-tree": "^3.2.4",
+ "tough-cookie": "^3.0.1",
+ "w3c-hr-time": "^1.0.2",
+ "w3c-xmlserializer": "^2.0.0",
+ "webidl-conversions": "^6.1.0",
+ "whatwg-encoding": "^1.0.5",
+ "whatwg-mimetype": "^2.3.0",
+ "whatwg-url": "^8.0.0",
+ "ws": "^7.2.3",
+ "xml-name-validator": "^3.0.0"
+ }
+ },
+ "jsesc": {
+ "version": "2.5.2",
+ "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-2.5.2.tgz",
+ "integrity": "sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==",
+ "dev": true
+ },
+ "json-parse-even-better-errors": {
+ "version": "2.3.1",
+ "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz",
+ "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==",
+ "dev": true
+ },
+ "json-schema": {
+ "version": "0.2.3",
+ "resolved": "https://registry.npmjs.org/json-schema/-/json-schema-0.2.3.tgz",
+ "integrity": "sha1-tIDIkuWaLwWVTOcnvT8qTogvnhM=",
+ "dev": true
+ },
+ "json-schema-traverse": {
+ "version": "0.4.1",
+ "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+ "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+ "dev": true
+ },
+ "json-stable-stringify-without-jsonify": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
+ "integrity": "sha1-nbe1lJatPzz+8wp1FC0tkwrXJlE=",
+ "dev": true
+ },
+ "json-stringify-safe": {
+ "version": "5.0.1",
+ "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz",
+ "integrity": "sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus=",
+ "dev": true
+ },
+ "json5": {
+ "version": "2.1.3",
+ "resolved": "https://registry.npmjs.org/json5/-/json5-2.1.3.tgz",
+ "integrity": "sha512-KXPvOm8K9IJKFM0bmdn8QXh7udDh1g/giieX0NLCaMnb4hEiVFqnop2ImTXCc5e0/oHz3LTqmHGtExn5hfMkOA==",
+ "dev": true,
+ "requires": {
+ "minimist": "^1.2.5"
+ }
+ },
+ "jsprim": {
+ "version": "1.4.1",
+ "resolved": "https://registry.npmjs.org/jsprim/-/jsprim-1.4.1.tgz",
+ "integrity": "sha1-MT5mvB5cwG5Di8G3SZwuXFastqI=",
+ "dev": true,
+ "requires": {
+ "assert-plus": "1.0.0",
+ "extsprintf": "1.3.0",
+ "json-schema": "0.2.3",
+ "verror": "1.10.0"
+ }
+ },
+ "kind-of": {
+ "version": "6.0.3",
+ "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz",
+ "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==",
+ "dev": true
+ },
+ "kleur": {
+ "version": "3.0.3",
+ "resolved": "https://registry.npmjs.org/kleur/-/kleur-3.0.3.tgz",
+ "integrity": "sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==",
+ "dev": true
+ },
+ "leven": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/leven/-/leven-3.1.0.tgz",
+ "integrity": "sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==",
+ "dev": true
+ },
+ "levn": {
+ "version": "0.4.1",
+ "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
+ "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
+ "dev": true,
+ "requires": {
+ "prelude-ls": "^1.2.1",
+ "type-check": "~0.4.0"
+ }
+ },
+ "lines-and-columns": {
+ "version": "1.1.6",
+ "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.1.6.tgz",
+ "integrity": "sha1-HADHQ7QzzQpOgHWPe2SldEDZ/wA=",
+ "dev": true
+ },
+ "locate-path": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz",
+ "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==",
+ "dev": true,
+ "requires": {
+ "p-locate": "^4.1.0"
+ }
+ },
+ "lodash": {
+ "version": "4.17.20",
+ "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.20.tgz",
+ "integrity": "sha512-PlhdFcillOINfeV7Ni6oF1TAEayyZBoZ8bcshTHqOYJYlrqzRK5hagpagky5o4HfCzzd1TRkXPMFq6cKk9rGmA==",
+ "dev": true
+ },
+ "lodash.memoize": {
+ "version": "4.1.2",
+ "resolved": "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-4.1.2.tgz",
+ "integrity": "sha1-vMbEmkKihA7Zl/Mj6tpezRguC/4=",
+ "dev": true
+ },
+ "lodash.sortby": {
+ "version": "4.7.0",
+ "resolved": "https://registry.npmjs.org/lodash.sortby/-/lodash.sortby-4.7.0.tgz",
+ "integrity": "sha1-7dFMgk4sycHgsKG0K7UhBRakJDg=",
+ "dev": true
+ },
+ "lru-cache": {
+ "version": "6.0.0",
+ "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz",
+ "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==",
+ "dev": true,
+ "requires": {
+ "yallist": "^4.0.0"
+ }
+ },
+ "make-dir": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-3.1.0.tgz",
+ "integrity": "sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==",
+ "dev": true,
+ "requires": {
+ "semver": "^6.0.0"
+ },
+ "dependencies": {
+ "semver": {
+ "version": "6.3.0",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz",
+ "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==",
+ "dev": true
+ }
+ }
+ },
+ "make-error": {
+ "version": "1.3.6",
+ "resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz",
+ "integrity": "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==",
+ "dev": true
+ },
+ "makeerror": {
+ "version": "1.0.11",
+ "resolved": "https://registry.npmjs.org/makeerror/-/makeerror-1.0.11.tgz",
+ "integrity": "sha1-4BpckQnyr3lmDk6LlYd5AYT1qWw=",
+ "dev": true,
+ "requires": {
+ "tmpl": "1.0.x"
+ }
+ },
+ "map-cache": {
+ "version": "0.2.2",
+ "resolved": "https://registry.npmjs.org/map-cache/-/map-cache-0.2.2.tgz",
+ "integrity": "sha1-wyq9C9ZSXZsFFkW7TyasXcmKDb8=",
+ "dev": true
+ },
+ "map-visit": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/map-visit/-/map-visit-1.0.0.tgz",
+ "integrity": "sha1-7Nyo8TFE5mDxtb1B8S80edmN+48=",
+ "dev": true,
+ "requires": {
+ "object-visit": "^1.0.0"
+ }
+ },
+ "merge-stream": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz",
+ "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==",
+ "dev": true
+ },
+ "merge2": {
+ "version": "1.4.1",
+ "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
+ "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
+ "dev": true
+ },
+ "micromatch": {
+ "version": "4.0.2",
+ "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.2.tgz",
+ "integrity": "sha512-y7FpHSbMUMoyPbYUSzO6PaZ6FyRnQOpHuKwbo1G+Knck95XVU4QAiKdGEnj5wwoS7PlOgthX/09u5iFJ+aYf5Q==",
+ "dev": true,
+ "requires": {
+ "braces": "^3.0.1",
+ "picomatch": "^2.0.5"
+ }
+ },
+ "mime-db": {
+ "version": "1.44.0",
+ "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.44.0.tgz",
+ "integrity": "sha512-/NOTfLrsPBVeH7YtFPgsVWveuL+4SjjYxaQ1xtM1KMFj7HdxlBlxeyNLzhyJVx7r4rZGJAZ/6lkKCitSc/Nmpg==",
+ "dev": true
+ },
+ "mime-types": {
+ "version": "2.1.27",
+ "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.27.tgz",
+ "integrity": "sha512-JIhqnCasI9yD+SsmkquHBxTSEuZdQX5BuQnS2Vc7puQQQ+8yiP5AY5uWhpdv4YL4VM5c6iliiYWPgJ/nJQLp7w==",
+ "dev": true,
+ "requires": {
+ "mime-db": "1.44.0"
+ }
+ },
+ "mimic-fn": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz",
+ "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==",
+ "dev": true
+ },
+ "minimatch": {
+ "version": "3.0.4",
+ "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
+ "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
+ "dev": true,
+ "requires": {
+ "brace-expansion": "^1.1.7"
+ }
+ },
+ "minimist": {
+ "version": "1.2.5",
+ "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.5.tgz",
+ "integrity": "sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==",
+ "dev": true
+ },
+ "mixin-deep": {
+ "version": "1.3.2",
+ "resolved": "https://registry.npmjs.org/mixin-deep/-/mixin-deep-1.3.2.tgz",
+ "integrity": "sha512-WRoDn//mXBiJ1H40rqa3vH0toePwSsGb45iInWlTySa+Uu4k3tYUSxa2v1KqAiLtvlrSzaExqS1gtk96A9zvEA==",
+ "dev": true,
+ "requires": {
+ "for-in": "^1.0.2",
+ "is-extendable": "^1.0.1"
+ },
+ "dependencies": {
+ "is-extendable": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz",
+ "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==",
+ "dev": true,
+ "requires": {
+ "is-plain-object": "^2.0.4"
+ }
+ }
+ }
+ },
+ "mkdirp": {
+ "version": "1.0.4",
+ "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz",
+ "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==",
+ "dev": true
+ },
+ "ms": {
+ "version": "2.1.2",
+ "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
+ "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==",
+ "dev": true
+ },
+ "multistream": {
+ "version": "4.0.1",
+ "resolved": "https://registry.npmjs.org/multistream/-/multistream-4.0.1.tgz",
+ "integrity": "sha512-LNPIR/LD0JUw2beGlSv4sgTSnGbZp16d/PG2rnIrYjkeCaepNmBTobuiaNQATCPiYgn+BBuQTm70UlvwRfLZ3Q==",
+ "requires": {
+ "readable-stream": "^3.6.0"
+ }
+ },
+ "nanomatch": {
+ "version": "1.2.13",
+ "resolved": "https://registry.npmjs.org/nanomatch/-/nanomatch-1.2.13.tgz",
+ "integrity": "sha512-fpoe2T0RbHwBTBUOftAfBPaDEi06ufaUai0mE6Yn1kacc3SnTErfb/h+X94VXzI64rKFHYImXSvdwGGCmwOqCA==",
+ "dev": true,
+ "requires": {
+ "arr-diff": "^4.0.0",
+ "array-unique": "^0.3.2",
+ "define-property": "^2.0.2",
+ "extend-shallow": "^3.0.2",
+ "fragment-cache": "^0.2.1",
+ "is-windows": "^1.0.2",
+ "kind-of": "^6.0.2",
+ "object.pick": "^1.3.0",
+ "regex-not": "^1.0.0",
+ "snapdragon": "^0.8.1",
+ "to-regex": "^3.0.1"
+ }
+ },
+ "natural-compare": {
+ "version": "1.4.0",
+ "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
+ "integrity": "sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc=",
+ "dev": true
+ },
+ "nice-try": {
+ "version": "1.0.5",
+ "resolved": "https://registry.npmjs.org/nice-try/-/nice-try-1.0.5.tgz",
+ "integrity": "sha512-1nh45deeb5olNY7eX82BkPO7SSxR5SSYJiPTrTdFUVYwAl8CKMA5N9PjTYkHiRjisVcxcQ1HXdLhx2qxxJzLNQ==",
+ "dev": true
+ },
+ "node-int64": {
+ "version": "0.4.0",
+ "resolved": "https://registry.npmjs.org/node-int64/-/node-int64-0.4.0.tgz",
+ "integrity": "sha1-h6kGXNs1XTGC2PlM4RGIuCXGijs=",
+ "dev": true
+ },
+ "node-modules-regexp": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/node-modules-regexp/-/node-modules-regexp-1.0.0.tgz",
+ "integrity": "sha1-jZ2+KJZKSsVxLpExZCEHxx6Q7EA=",
+ "dev": true
+ },
+ "node-notifier": {
+ "version": "8.0.0",
+ "resolved": "https://registry.npmjs.org/node-notifier/-/node-notifier-8.0.0.tgz",
+ "integrity": "sha512-46z7DUmcjoYdaWyXouuFNNfUo6eFa94t23c53c+lG/9Cvauk4a98rAUp9672X5dxGdQmLpPzTxzu8f/OeEPaFA==",
+ "dev": true,
+ "optional": true,
+ "requires": {
+ "growly": "^1.3.0",
+ "is-wsl": "^2.2.0",
+ "semver": "^7.3.2",
+ "shellwords": "^0.1.1",
+ "uuid": "^8.3.0",
+ "which": "^2.0.2"
+ }
+ },
+ "normalize-package-data": {
+ "version": "2.5.0",
+ "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.5.0.tgz",
+ "integrity": "sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==",
+ "dev": true,
+ "requires": {
+ "hosted-git-info": "^2.1.4",
+ "resolve": "^1.10.0",
+ "semver": "2 || 3 || 4 || 5",
+ "validate-npm-package-license": "^3.0.1"
+ },
+ "dependencies": {
+ "semver": {
+ "version": "5.7.1",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz",
+ "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==",
+ "dev": true
+ }
+ }
+ },
+ "normalize-path": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+ "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+ "dev": true
+ },
+ "npm-run-path": {
+ "version": "2.0.2",
+ "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-2.0.2.tgz",
+ "integrity": "sha1-NakjLfo11wZ7TLLd8jV7GHFTbF8=",
+ "dev": true,
+ "requires": {
+ "path-key": "^2.0.0"
+ },
+ "dependencies": {
+ "path-key": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/path-key/-/path-key-2.0.1.tgz",
+ "integrity": "sha1-QRyttXTFoUDTpLGRDUDYDMn0C0A=",
+ "dev": true
+ }
+ }
+ },
+ "nwsapi": {
+ "version": "2.2.0",
+ "resolved": "https://registry.npmjs.org/nwsapi/-/nwsapi-2.2.0.tgz",
+ "integrity": "sha512-h2AatdwYH+JHiZpv7pt/gSX1XoRGb7L/qSIeuqA6GwYoF9w1vP1cw42TO0aI2pNyshRK5893hNSl+1//vHK7hQ==",
+ "dev": true
+ },
+ "oauth-sign": {
+ "version": "0.9.0",
+ "resolved": "https://registry.npmjs.org/oauth-sign/-/oauth-sign-0.9.0.tgz",
+ "integrity": "sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ==",
+ "dev": true
+ },
+ "object-copy": {
+ "version": "0.1.0",
+ "resolved": "https://registry.npmjs.org/object-copy/-/object-copy-0.1.0.tgz",
+ "integrity": "sha1-fn2Fi3gb18mRpBupde04EnVOmYw=",
+ "dev": true,
+ "requires": {
+ "copy-descriptor": "^0.1.0",
+ "define-property": "^0.2.5",
+ "kind-of": "^3.0.3"
+ },
+ "dependencies": {
+ "define-property": {
+ "version": "0.2.5",
+ "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz",
+ "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=",
+ "dev": true,
+ "requires": {
+ "is-descriptor": "^0.1.0"
+ }
+ },
+ "kind-of": {
+ "version": "3.2.2",
+ "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz",
+ "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
+ "dev": true,
+ "requires": {
+ "is-buffer": "^1.1.5"
+ }
+ }
+ }
+ },
+ "object-visit": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/object-visit/-/object-visit-1.0.1.tgz",
+ "integrity": "sha1-95xEk68MU3e1n+OdOV5BBC3QRbs=",
+ "dev": true,
+ "requires": {
+ "isobject": "^3.0.0"
+ }
+ },
+ "object.pick": {
+ "version": "1.3.0",
+ "resolved": "https://registry.npmjs.org/object.pick/-/object.pick-1.3.0.tgz",
+ "integrity": "sha1-h6EKxMFpS9Lhy/U1kaZhQftd10c=",
+ "dev": true,
+ "requires": {
+ "isobject": "^3.0.1"
+ }
+ },
+ "once": {
+ "version": "1.4.0",
+ "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+ "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
+ "dev": true,
+ "requires": {
+ "wrappy": "1"
+ }
+ },
+ "onetime": {
+ "version": "5.1.2",
+ "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz",
+ "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==",
+ "dev": true,
+ "requires": {
+ "mimic-fn": "^2.1.0"
+ }
+ },
+ "optionator": {
+ "version": "0.9.1",
+ "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.1.tgz",
+ "integrity": "sha512-74RlY5FCnhq4jRxVUPKDaRwrVNXMqsGsiW6AJw4XK8hmtm10wC0ypZBLw5IIp85NZMr91+qd1RvvENwg7jjRFw==",
+ "dev": true,
+ "requires": {
+ "deep-is": "^0.1.3",
+ "fast-levenshtein": "^2.0.6",
+ "levn": "^0.4.1",
+ "prelude-ls": "^1.2.1",
+ "type-check": "^0.4.0",
+ "word-wrap": "^1.2.3"
+ }
+ },
+ "p-each-series": {
+ "version": "2.2.0",
+ "resolved": "https://registry.npmjs.org/p-each-series/-/p-each-series-2.2.0.tgz",
+ "integrity": "sha512-ycIL2+1V32th+8scbpTvyHNaHe02z0sjgh91XXjAk+ZeXoPN4Z46DVUnzdso0aX4KckKw0FNNFHdjZ2UsZvxiA==",
+ "dev": true
+ },
+ "p-finally": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/p-finally/-/p-finally-1.0.0.tgz",
+ "integrity": "sha1-P7z7FbiZpEEjs0ttzBi3JDNqLK4=",
+ "dev": true
+ },
+ "p-limit": {
+ "version": "2.3.0",
+ "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz",
+ "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==",
+ "dev": true,
+ "requires": {
+ "p-try": "^2.0.0"
+ }
+ },
+ "p-locate": {
+ "version": "4.1.0",
+ "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz",
+ "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==",
+ "dev": true,
+ "requires": {
+ "p-limit": "^2.2.0"
+ }
+ },
+ "p-map": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/p-map/-/p-map-4.0.0.tgz",
+ "integrity": "sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==",
+ "dev": true,
+ "requires": {
+ "aggregate-error": "^3.0.0"
+ }
+ },
+ "p-try": {
+ "version": "2.2.0",
+ "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz",
+ "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==",
+ "dev": true
+ },
+ "parent-module": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
+ "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
+ "dev": true,
+ "requires": {
+ "callsites": "^3.0.0"
+ }
+ },
+ "parse-json": {
+ "version": "5.1.0",
+ "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.1.0.tgz",
+ "integrity": "sha512-+mi/lmVVNKFNVyLXV31ERiy2CY5E1/F6QtJFEzoChPRwwngMNXRDQ9GJ5WdE2Z2P4AujsOi0/+2qHID68KwfIQ==",
+ "dev": true,
+ "requires": {
+ "@babel/code-frame": "^7.0.0",
+ "error-ex": "^1.3.1",
+ "json-parse-even-better-errors": "^2.3.0",
+ "lines-and-columns": "^1.1.6"
+ }
+ },
+ "parse5": {
+ "version": "5.1.1",
+ "resolved": "https://registry.npmjs.org/parse5/-/parse5-5.1.1.tgz",
+ "integrity": "sha512-ugq4DFI0Ptb+WWjAdOK16+u/nHfiIrcE+sh8kZMaM0WllQKLI9rOUq6c2b7cwPkXdzfQESqvoqK6ug7U/Yyzug==",
+ "dev": true
+ },
+ "pascalcase": {
+ "version": "0.1.1",
+ "resolved": "https://registry.npmjs.org/pascalcase/-/pascalcase-0.1.1.tgz",
+ "integrity": "sha1-s2PlXoAGym/iF4TS2yK9FdeRfxQ=",
+ "dev": true
+ },
+ "path-exists": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
+ "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
+ "dev": true
+ },
+ "path-is-absolute": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+ "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=",
+ "dev": true
+ },
+ "path-key": {
+ "version": "3.1.1",
+ "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+ "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+ "dev": true
+ },
+ "path-parse": {
+ "version": "1.0.6",
+ "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.6.tgz",
+ "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==",
+ "dev": true
+ },
+ "path-type": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz",
+ "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==",
+ "dev": true
+ },
+ "performance-now": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz",
+ "integrity": "sha1-Ywn04OX6kT7BxpMHrjZLSzd8nns=",
+ "dev": true
+ },
+ "picomatch": {
+ "version": "2.2.2",
+ "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.2.2.tgz",
+ "integrity": "sha512-q0M/9eZHzmr0AulXyPwNfZjtwZ/RBZlbN3K3CErVrk50T2ASYI7Bye0EvekFY3IP1Nt2DHu0re+V2ZHIpMkuWg==",
+ "dev": true
+ },
+ "pirates": {
+ "version": "4.0.1",
+ "resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.1.tgz",
+ "integrity": "sha512-WuNqLTbMI3tmfef2TKxlQmAiLHKtFhlsCZnPIpuv2Ow0RDVO8lfy1Opf4NUzlMXLjPl+Men7AuVdX6TA+s+uGA==",
+ "dev": true,
+ "requires": {
+ "node-modules-regexp": "^1.0.0"
+ }
+ },
+ "pkg-dir": {
+ "version": "4.2.0",
+ "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-4.2.0.tgz",
+ "integrity": "sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==",
+ "dev": true,
+ "requires": {
+ "find-up": "^4.0.0"
+ }
+ },
+ "posix-character-classes": {
+ "version": "0.1.1",
+ "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
+ "integrity": "sha1-AerA/jta9xoqbAL+q7jB/vfgDqs=",
+ "dev": true
+ },
+ "prelude-ls": {
+ "version": "1.2.1",
+ "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
+ "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
+ "dev": true
+ },
+ "prettier": {
+ "version": "2.2.1",
+ "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.2.1.tgz",
+ "integrity": "sha512-PqyhM2yCjg/oKkFPtTGUojv7gnZAoG80ttl45O6x2Ug/rMJw4wcc9k6aaf2hibP7BGVCCM33gZoGjyvt9mm16Q==",
+ "dev": true
+ },
+ "prettier-linter-helpers": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/prettier-linter-helpers/-/prettier-linter-helpers-1.0.0.tgz",
+ "integrity": "sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w==",
+ "dev": true,
+ "requires": {
+ "fast-diff": "^1.1.2"
+ }
+ },
+ "pretty-format": {
+ "version": "26.6.2",
+ "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-26.6.2.tgz",
+ "integrity": "sha512-7AeGuCYNGmycyQbCqd/3PWH4eOoX/OiCa0uphp57NVTeAGdJGaAliecxwBDHYQCIvrW7aDBZCYeNTP/WX69mkg==",
+ "dev": true,
+ "requires": {
+ "@jest/types": "^26.6.2",
+ "ansi-regex": "^5.0.0",
+ "ansi-styles": "^4.0.0",
+ "react-is": "^17.0.1"
+ },
+ "dependencies": {
+ "ansi-styles": {
+ "version": "4.3.0",
+ "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+ "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+ "dev": true,
+ "requires": {
+ "color-convert": "^2.0.1"
+ }
+ },
+ "color-convert": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+ "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+ "dev": true,
+ "requires": {
+ "color-name": "~1.1.4"
+ }
+ },
+ "color-name": {
+ "version": "1.1.4",
+ "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+ "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+ "dev": true
+ }
+ }
+ },
+ "progress": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz",
+ "integrity": "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==",
+ "dev": true
+ },
+ "prompts": {
+ "version": "2.4.0",
+ "resolved": "https://registry.npmjs.org/prompts/-/prompts-2.4.0.tgz",
+ "integrity": "sha512-awZAKrk3vN6CroQukBL+R9051a4R3zCZBlJm/HBfrSZ8iTpYix3VX1vU4mveiLpiwmOJT4wokTF9m6HUk4KqWQ==",
+ "dev": true,
+ "requires": {
+ "kleur": "^3.0.3",
+ "sisteransi": "^1.0.5"
+ }
+ },
+ "psl": {
+ "version": "1.8.0",
+ "resolved": "https://registry.npmjs.org/psl/-/psl-1.8.0.tgz",
+ "integrity": "sha512-RIdOzyoavK+hA18OGGWDqUTsCLhtA7IcZ/6NCs4fFJaHBDab+pDDmDIByWFRQJq2Cd7r1OoQxBGKOaztq+hjIQ==",
+ "dev": true
+ },
+ "pump": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.0.tgz",
+ "integrity": "sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==",
+ "dev": true,
+ "requires": {
+ "end-of-stream": "^1.1.0",
+ "once": "^1.3.1"
+ }
+ },
+ "punycode": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.1.1.tgz",
+ "integrity": "sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==",
+ "dev": true
+ },
+ "qs": {
+ "version": "6.5.2",
+ "resolved": "https://registry.npmjs.org/qs/-/qs-6.5.2.tgz",
+ "integrity": "sha512-N5ZAX4/LxJmF+7wN74pUD6qAh9/wnvdQcjq9TZjevvXzSUo7bfmw91saqMjzGS2xq91/odN2dW/WOl7qQHNDGA==",
+ "dev": true
+ },
+ "react-is": {
+ "version": "17.0.1",
+ "resolved": "https://registry.npmjs.org/react-is/-/react-is-17.0.1.tgz",
+ "integrity": "sha512-NAnt2iGDXohE5LI7uBnLnqvLQMtzhkiAOLXTmv+qnF9Ky7xAPcX8Up/xWIhxvLVGJvuLiNc4xQLtuqDRzb4fSA==",
+ "dev": true
+ },
+ "read-pkg": {
+ "version": "5.2.0",
+ "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-5.2.0.tgz",
+ "integrity": "sha512-Ug69mNOpfvKDAc2Q8DRpMjjzdtrnv9HcSMX+4VsZxD1aZ6ZzrIE7rlzXBtWTyhULSMKg076AW6WR5iZpD0JiOg==",
+ "dev": true,
+ "requires": {
+ "@types/normalize-package-data": "^2.4.0",
+ "normalize-package-data": "^2.5.0",
+ "parse-json": "^5.0.0",
+ "type-fest": "^0.6.0"
+ },
+ "dependencies": {
+ "type-fest": {
+ "version": "0.6.0",
+ "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.6.0.tgz",
+ "integrity": "sha512-q+MB8nYR1KDLrgr4G5yemftpMC7/QLqVndBmEEdqzmNj5dcFOO4Oo8qlwZE3ULT3+Zim1F8Kq4cBnikNhlCMlg==",
+ "dev": true
+ }
+ }
+ },
+ "read-pkg-up": {
+ "version": "7.0.1",
+ "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-7.0.1.tgz",
+ "integrity": "sha512-zK0TB7Xd6JpCLmlLmufqykGE+/TlOePD6qKClNW7hHDKFh/J7/7gCWGR7joEQEW1bKq3a3yUZSObOoWLFQ4ohg==",
+ "dev": true,
+ "requires": {
+ "find-up": "^4.1.0",
+ "read-pkg": "^5.2.0",
+ "type-fest": "^0.8.1"
+ }
+ },
+ "readable-stream": {
+ "version": "3.6.0",
+ "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz",
+ "integrity": "sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==",
+ "requires": {
+ "inherits": "^2.0.3",
+ "string_decoder": "^1.1.1",
+ "util-deprecate": "^1.0.1"
+ }
+ },
+ "regex-not": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/regex-not/-/regex-not-1.0.2.tgz",
+ "integrity": "sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A==",
+ "dev": true,
+ "requires": {
+ "extend-shallow": "^3.0.2",
+ "safe-regex": "^1.1.0"
+ }
+ },
+ "regexpp": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/regexpp/-/regexpp-3.1.0.tgz",
+ "integrity": "sha512-ZOIzd8yVsQQA7j8GCSlPGXwg5PfmA1mrq0JP4nGhh54LaKN3xdai/vHUDu74pKwV8OxseMS65u2NImosQcSD0Q==",
+ "dev": true
+ },
+ "remove-trailing-separator": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/remove-trailing-separator/-/remove-trailing-separator-1.1.0.tgz",
+ "integrity": "sha1-wkvOKig62tW8P1jg1IJJuSN52O8=",
+ "dev": true
+ },
+ "repeat-element": {
+ "version": "1.1.3",
+ "resolved": "https://registry.npmjs.org/repeat-element/-/repeat-element-1.1.3.tgz",
+ "integrity": "sha512-ahGq0ZnV5m5XtZLMb+vP76kcAM5nkLqk0lpqAuojSKGgQtn4eRi4ZZGm2olo2zKFH+sMsWaqOCW1dqAnOru72g==",
+ "dev": true
+ },
+ "repeat-string": {
+ "version": "1.6.1",
+ "resolved": "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz",
+ "integrity": "sha1-jcrkcOHIirwtYA//Sndihtp15jc=",
+ "dev": true
+ },
+ "request": {
+ "version": "2.88.2",
+ "resolved": "https://registry.npmjs.org/request/-/request-2.88.2.tgz",
+ "integrity": "sha512-MsvtOrfG9ZcrOwAW+Qi+F6HbD0CWXEh9ou77uOb7FM2WPhwT7smM833PzanhJLsgXjN89Ir6V2PczXNnMpwKhw==",
+ "dev": true,
+ "requires": {
+ "aws-sign2": "~0.7.0",
+ "aws4": "^1.8.0",
+ "caseless": "~0.12.0",
+ "combined-stream": "~1.0.6",
+ "extend": "~3.0.2",
+ "forever-agent": "~0.6.1",
+ "form-data": "~2.3.2",
+ "har-validator": "~5.1.3",
+ "http-signature": "~1.2.0",
+ "is-typedarray": "~1.0.0",
+ "isstream": "~0.1.2",
+ "json-stringify-safe": "~5.0.1",
+ "mime-types": "~2.1.19",
+ "oauth-sign": "~0.9.0",
+ "performance-now": "^2.1.0",
+ "qs": "~6.5.2",
+ "safe-buffer": "^5.1.2",
+ "tough-cookie": "~2.5.0",
+ "tunnel-agent": "^0.6.0",
+ "uuid": "^3.3.2"
+ },
+ "dependencies": {
+ "tough-cookie": {
+ "version": "2.5.0",
+ "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.5.0.tgz",
+ "integrity": "sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g==",
+ "dev": true,
+ "requires": {
+ "psl": "^1.1.28",
+ "punycode": "^2.1.1"
+ }
+ },
+ "uuid": {
+ "version": "3.4.0",
+ "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.4.0.tgz",
+ "integrity": "sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A==",
+ "dev": true
+ }
+ }
+ },
+ "request-promise-core": {
+ "version": "1.1.4",
+ "resolved": "https://registry.npmjs.org/request-promise-core/-/request-promise-core-1.1.4.tgz",
+ "integrity": "sha512-TTbAfBBRdWD7aNNOoVOBH4pN/KigV6LyapYNNlAPA8JwbovRti1E88m3sYAwsLi5ryhPKsE9APwnjFTgdUjTpw==",
+ "dev": true,
+ "requires": {
+ "lodash": "^4.17.19"
+ }
+ },
+ "request-promise-native": {
+ "version": "1.0.9",
+ "resolved": "https://registry.npmjs.org/request-promise-native/-/request-promise-native-1.0.9.tgz",
+ "integrity": "sha512-wcW+sIUiWnKgNY0dqCpOZkUbF/I+YPi+f09JZIDa39Ec+q82CpSYniDp+ISgTTbKmnpJWASeJBPZmoxH84wt3g==",
+ "dev": true,
+ "requires": {
+ "request-promise-core": "1.1.4",
+ "stealthy-require": "^1.1.1",
+ "tough-cookie": "^2.3.3"
+ },
+ "dependencies": {
+ "tough-cookie": {
+ "version": "2.5.0",
+ "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.5.0.tgz",
+ "integrity": "sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g==",
+ "dev": true,
+ "requires": {
+ "psl": "^1.1.28",
+ "punycode": "^2.1.1"
+ }
+ }
+ }
+ },
+ "require-directory": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+ "integrity": "sha1-jGStX9MNqxyXbiNE/+f3kqam30I=",
+ "dev": true
+ },
+ "require-main-filename": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/require-main-filename/-/require-main-filename-2.0.0.tgz",
+ "integrity": "sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg==",
+ "dev": true
+ },
+ "resolve": {
+ "version": "1.19.0",
+ "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.19.0.tgz",
+ "integrity": "sha512-rArEXAgsBG4UgRGcynxWIWKFvh/XZCcS8UJdHhwy91zwAvCZIbcs+vAbflgBnNjYMs/i/i+/Ux6IZhML1yPvxg==",
+ "dev": true,
+ "requires": {
+ "is-core-module": "^2.1.0",
+ "path-parse": "^1.0.6"
+ }
+ },
+ "resolve-cwd": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/resolve-cwd/-/resolve-cwd-3.0.0.tgz",
+ "integrity": "sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==",
+ "dev": true,
+ "requires": {
+ "resolve-from": "^5.0.0"
+ },
+ "dependencies": {
+ "resolve-from": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz",
+ "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==",
+ "dev": true
+ }
+ }
+ },
+ "resolve-from": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
+ "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
+ "dev": true
+ },
+ "resolve-url": {
+ "version": "0.2.1",
+ "resolved": "https://registry.npmjs.org/resolve-url/-/resolve-url-0.2.1.tgz",
+ "integrity": "sha1-LGN/53yJOv0qZj/iGqkIAGjiBSo=",
+ "dev": true
+ },
+ "ret": {
+ "version": "0.1.15",
+ "resolved": "https://registry.npmjs.org/ret/-/ret-0.1.15.tgz",
+ "integrity": "sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg==",
+ "dev": true
+ },
+ "reusify": {
+ "version": "1.0.4",
+ "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz",
+ "integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==",
+ "dev": true
+ },
+ "rimraf": {
+ "version": "3.0.2",
+ "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz",
+ "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==",
+ "dev": true,
+ "requires": {
+ "glob": "^7.1.3"
+ }
+ },
+ "rsvp": {
+ "version": "4.8.5",
+ "resolved": "https://registry.npmjs.org/rsvp/-/rsvp-4.8.5.tgz",
+ "integrity": "sha512-nfMOlASu9OnRJo1mbEk2cz0D56a1MBNrJ7orjRZQG10XDyuvwksKbuXNp6qa+kbn839HwjwhBzhFmdsaEAfauA==",
+ "dev": true
+ },
+ "run-parallel": {
+ "version": "1.1.10",
+ "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.1.10.tgz",
+ "integrity": "sha512-zb/1OuZ6flOlH6tQyMPUrE3x3Ulxjlo9WIVXR4yVYi4H9UXQaeIsPbLn2R3O3vQCnDKkAl2qHiuocKKX4Tz/Sw==",
+ "dev": true
+ },
+ "safe-buffer": {
+ "version": "5.2.1",
+ "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+ "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="
+ },
+ "safe-regex": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/safe-regex/-/safe-regex-1.1.0.tgz",
+ "integrity": "sha1-QKNmnzsHfR6UPURinhV91IAjvy4=",
+ "dev": true,
+ "requires": {
+ "ret": "~0.1.10"
+ }
+ },
+ "safer-buffer": {
+ "version": "2.1.2",
+ "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+ "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+ "dev": true
+ },
+ "sane": {
+ "version": "4.1.0",
+ "resolved": "https://registry.npmjs.org/sane/-/sane-4.1.0.tgz",
+ "integrity": "sha512-hhbzAgTIX8O7SHfp2c8/kREfEn4qO/9q8C9beyY6+tvZ87EpoZ3i1RIEvp27YBswnNbY9mWd6paKVmKbAgLfZA==",
+ "dev": true,
+ "requires": {
+ "@cnakazawa/watch": "^1.0.3",
+ "anymatch": "^2.0.0",
+ "capture-exit": "^2.0.0",
+ "exec-sh": "^0.3.2",
+ "execa": "^1.0.0",
+ "fb-watchman": "^2.0.0",
+ "micromatch": "^3.1.4",
+ "minimist": "^1.1.1",
+ "walker": "~1.0.5"
+ },
+ "dependencies": {
+ "anymatch": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-2.0.0.tgz",
+ "integrity": "sha512-5teOsQWABXHHBFP9y3skS5P3d/WfWXpv3FUpy+LorMrNYaT9pI4oLMQX7jzQ2KklNpGpWHzdCXTDT2Y3XGlZBw==",
+ "dev": true,
+ "requires": {
+ "micromatch": "^3.1.4",
+ "normalize-path": "^2.1.1"
+ }
+ },
+ "braces": {
+ "version": "2.3.2",
+ "resolved": "https://registry.npmjs.org/braces/-/braces-2.3.2.tgz",
+ "integrity": "sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w==",
+ "dev": true,
+ "requires": {
+ "arr-flatten": "^1.1.0",
+ "array-unique": "^0.3.2",
+ "extend-shallow": "^2.0.1",
+ "fill-range": "^4.0.0",
+ "isobject": "^3.0.1",
+ "repeat-element": "^1.1.2",
+ "snapdragon": "^0.8.1",
+ "snapdragon-node": "^2.0.1",
+ "split-string": "^3.0.2",
+ "to-regex": "^3.0.1"
+ },
+ "dependencies": {
+ "extend-shallow": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
+ "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
+ "dev": true,
+ "requires": {
+ "is-extendable": "^0.1.0"
+ }
+ }
+ }
+ },
+ "fill-range": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-4.0.0.tgz",
+ "integrity": "sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc=",
+ "dev": true,
+ "requires": {
+ "extend-shallow": "^2.0.1",
+ "is-number": "^3.0.0",
+ "repeat-string": "^1.6.1",
+ "to-regex-range": "^2.1.0"
+ },
+ "dependencies": {
+ "extend-shallow": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
+ "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
+ "dev": true,
+ "requires": {
+ "is-extendable": "^0.1.0"
+ }
+ }
+ }
+ },
+ "is-number": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz",
+ "integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=",
+ "dev": true,
+ "requires": {
+ "kind-of": "^3.0.2"
+ },
+ "dependencies": {
+ "kind-of": {
+ "version": "3.2.2",
+ "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz",
+ "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
+ "dev": true,
+ "requires": {
+ "is-buffer": "^1.1.5"
+ }
+ }
+ }
+ },
+ "micromatch": {
+ "version": "3.1.10",
+ "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-3.1.10.tgz",
+ "integrity": "sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==",
+ "dev": true,
+ "requires": {
+ "arr-diff": "^4.0.0",
+ "array-unique": "^0.3.2",
+ "braces": "^2.3.1",
+ "define-property": "^2.0.2",
+ "extend-shallow": "^3.0.2",
+ "extglob": "^2.0.4",
+ "fragment-cache": "^0.2.1",
+ "kind-of": "^6.0.2",
+ "nanomatch": "^1.2.9",
+ "object.pick": "^1.3.0",
+ "regex-not": "^1.0.0",
+ "snapdragon": "^0.8.1",
+ "to-regex": "^3.0.2"
+ }
+ },
+ "normalize-path": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-2.1.1.tgz",
+ "integrity": "sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=",
+ "dev": true,
+ "requires": {
+ "remove-trailing-separator": "^1.0.1"
+ }
+ },
+ "to-regex-range": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-2.1.1.tgz",
+ "integrity": "sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg=",
+ "dev": true,
+ "requires": {
+ "is-number": "^3.0.0",
+ "repeat-string": "^1.6.1"
+ }
+ }
+ }
+ },
+ "saxes": {
+ "version": "5.0.1",
+ "resolved": "https://registry.npmjs.org/saxes/-/saxes-5.0.1.tgz",
+ "integrity": "sha512-5LBh1Tls8c9xgGjw3QrMwETmTMVk0oFgvrFSvWx62llR2hcEInrKNZ2GZCCuuy2lvWrdl5jhbpeqc5hRYKFOcw==",
+ "dev": true,
+ "requires": {
+ "xmlchars": "^2.2.0"
+ }
+ },
+ "semver": {
+ "version": "7.3.4",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.4.tgz",
+ "integrity": "sha512-tCfb2WLjqFAtXn4KEdxIhalnRtoKFN7nAwj0B3ZXCbQloV2tq5eDbcTmT68JJD3nRJq24/XgxtQKFIpQdtvmVw==",
+ "dev": true,
+ "requires": {
+ "lru-cache": "^6.0.0"
+ }
+ },
+ "set-blocking": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz",
+ "integrity": "sha1-BF+XgtARrppoA93TgrJDkrPYkPc=",
+ "dev": true
+ },
+ "set-value": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/set-value/-/set-value-2.0.1.tgz",
+ "integrity": "sha512-JxHc1weCN68wRY0fhCoXpyK55m/XPHafOmK4UWD7m2CI14GMcFypt4w/0+NV5f/ZMby2F6S2wwA7fgynh9gWSw==",
+ "dev": true,
+ "requires": {
+ "extend-shallow": "^2.0.1",
+ "is-extendable": "^0.1.1",
+ "is-plain-object": "^2.0.3",
+ "split-string": "^3.0.1"
+ },
+ "dependencies": {
+ "extend-shallow": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
+ "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
+ "dev": true,
+ "requires": {
+ "is-extendable": "^0.1.0"
+ }
+ }
+ }
+ },
+ "shebang-command": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+ "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+ "dev": true,
+ "requires": {
+ "shebang-regex": "^3.0.0"
+ }
+ },
+ "shebang-regex": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+ "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+ "dev": true
+ },
+ "shellwords": {
+ "version": "0.1.1",
+ "resolved": "https://registry.npmjs.org/shellwords/-/shellwords-0.1.1.tgz",
+ "integrity": "sha512-vFwSUfQvqybiICwZY5+DAWIPLKsWO31Q91JSKl3UYv+K5c2QRPzn0qzec6QPu1Qc9eHYItiP3NdJqNVqetYAww==",
+ "dev": true,
+ "optional": true
+ },
+ "signal-exit": {
+ "version": "3.0.3",
+ "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.3.tgz",
+ "integrity": "sha512-VUJ49FC8U1OxwZLxIbTTrDvLnf/6TDgxZcK8wxR8zs13xpx7xbG60ndBlhNrFi2EMuFRoeDoJO7wthSLq42EjA==",
+ "dev": true
+ },
+ "sisteransi": {
+ "version": "1.0.5",
+ "resolved": "https://registry.npmjs.org/sisteransi/-/sisteransi-1.0.5.tgz",
+ "integrity": "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==",
+ "dev": true
+ },
+ "slash": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz",
+ "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==",
+ "dev": true
+ },
+ "slice-ansi": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-2.1.0.tgz",
+ "integrity": "sha512-Qu+VC3EwYLldKa1fCxuuvULvSJOKEgk9pi8dZeCVK7TqBfUNTH4sFkk4joj8afVSfAYgJoSOetjx9QWOJ5mYoQ==",
+ "dev": true,
+ "requires": {
+ "ansi-styles": "^3.2.0",
+ "astral-regex": "^1.0.0",
+ "is-fullwidth-code-point": "^2.0.0"
+ }
+ },
+ "snapdragon": {
+ "version": "0.8.2",
+ "resolved": "https://registry.npmjs.org/snapdragon/-/snapdragon-0.8.2.tgz",
+ "integrity": "sha512-FtyOnWN/wCHTVXOMwvSv26d+ko5vWlIDD6zoUJ7LW8vh+ZBC8QdljveRP+crNrtBwioEUWy/4dMtbBjA4ioNlg==",
+ "dev": true,
+ "requires": {
+ "base": "^0.11.1",
+ "debug": "^2.2.0",
+ "define-property": "^0.2.5",
+ "extend-shallow": "^2.0.1",
+ "map-cache": "^0.2.2",
+ "source-map": "^0.5.6",
+ "source-map-resolve": "^0.5.0",
+ "use": "^3.1.0"
+ },
+ "dependencies": {
+ "debug": {
+ "version": "2.6.9",
+ "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+ "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+ "dev": true,
+ "requires": {
+ "ms": "2.0.0"
+ }
+ },
+ "define-property": {
+ "version": "0.2.5",
+ "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz",
+ "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=",
+ "dev": true,
+ "requires": {
+ "is-descriptor": "^0.1.0"
+ }
+ },
+ "extend-shallow": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
+ "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
+ "dev": true,
+ "requires": {
+ "is-extendable": "^0.1.0"
+ }
+ },
+ "ms": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+ "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=",
+ "dev": true
+ },
+ "source-map": {
+ "version": "0.5.7",
+ "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz",
+ "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=",
+ "dev": true
+ }
+ }
+ },
+ "snapdragon-node": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/snapdragon-node/-/snapdragon-node-2.1.1.tgz",
+ "integrity": "sha512-O27l4xaMYt/RSQ5TR3vpWCAB5Kb/czIcqUFOM/C4fYcLnbZUc1PkjTAMjof2pBWaSTwOUd6qUHcFGVGj7aIwnw==",
+ "dev": true,
+ "requires": {
+ "define-property": "^1.0.0",
+ "isobject": "^3.0.0",
+ "snapdragon-util": "^3.0.1"
+ },
+ "dependencies": {
+ "define-property": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz",
+ "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=",
+ "dev": true,
+ "requires": {
+ "is-descriptor": "^1.0.0"
+ }
+ },
+ "is-accessor-descriptor": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz",
+ "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==",
+ "dev": true,
+ "requires": {
+ "kind-of": "^6.0.0"
+ }
+ },
+ "is-data-descriptor": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz",
+ "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==",
+ "dev": true,
+ "requires": {
+ "kind-of": "^6.0.0"
+ }
+ },
+ "is-descriptor": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz",
+ "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==",
+ "dev": true,
+ "requires": {
+ "is-accessor-descriptor": "^1.0.0",
+ "is-data-descriptor": "^1.0.0",
+ "kind-of": "^6.0.2"
+ }
+ }
+ }
+ },
+ "snapdragon-util": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/snapdragon-util/-/snapdragon-util-3.0.1.tgz",
+ "integrity": "sha512-mbKkMdQKsjX4BAL4bRYTj21edOf8cN7XHdYUJEe+Zn99hVEYcMvKPct1IqNe7+AZPirn8BCDOQBHQZknqmKlZQ==",
+ "dev": true,
+ "requires": {
+ "kind-of": "^3.2.0"
+ },
+ "dependencies": {
+ "kind-of": {
+ "version": "3.2.2",
+ "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz",
+ "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
+ "dev": true,
+ "requires": {
+ "is-buffer": "^1.1.5"
+ }
+ }
+ }
+ },
+ "source-map": {
+ "version": "0.6.1",
+ "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+ "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+ "dev": true
+ },
+ "source-map-resolve": {
+ "version": "0.5.3",
+ "resolved": "https://registry.npmjs.org/source-map-resolve/-/source-map-resolve-0.5.3.tgz",
+ "integrity": "sha512-Htz+RnsXWk5+P2slx5Jh3Q66vhQj1Cllm0zvnaY98+NFx+Dv2CF/f5O/t8x+KaNdrdIAsruNzoh/KpialbqAnw==",
+ "dev": true,
+ "requires": {
+ "atob": "^2.1.2",
+ "decode-uri-component": "^0.2.0",
+ "resolve-url": "^0.2.1",
+ "source-map-url": "^0.4.0",
+ "urix": "^0.1.0"
+ }
+ },
+ "source-map-support": {
+ "version": "0.5.19",
+ "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.19.tgz",
+ "integrity": "sha512-Wonm7zOCIJzBGQdB+thsPar0kYuCIzYvxZwlBa87yi/Mdjv7Tip2cyVbLj5o0cFPN4EVkuTwb3GDDyUx2DGnGw==",
+ "dev": true,
+ "requires": {
+ "buffer-from": "^1.0.0",
+ "source-map": "^0.6.0"
+ }
+ },
+ "source-map-url": {
+ "version": "0.4.0",
+ "resolved": "https://registry.npmjs.org/source-map-url/-/source-map-url-0.4.0.tgz",
+ "integrity": "sha1-PpNdfd1zYxuXZZlW1VEo6HtQhKM=",
+ "dev": true
+ },
+ "spdx-correct": {
+ "version": "3.1.1",
+ "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.1.1.tgz",
+ "integrity": "sha512-cOYcUWwhCuHCXi49RhFRCyJEK3iPj1Ziz9DpViV3tbZOwXD49QzIN3MpOLJNxh2qwq2lJJZaKMVw9qNi4jTC0w==",
+ "dev": true,
+ "requires": {
+ "spdx-expression-parse": "^3.0.0",
+ "spdx-license-ids": "^3.0.0"
+ }
+ },
+ "spdx-exceptions": {
+ "version": "2.3.0",
+ "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.3.0.tgz",
+ "integrity": "sha512-/tTrYOC7PPI1nUAgx34hUpqXuyJG+DTHJTnIULG4rDygi4xu/tfgmq1e1cIRwRzwZgo4NLySi+ricLkZkw4i5A==",
+ "dev": true
+ },
+ "spdx-expression-parse": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz",
+ "integrity": "sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==",
+ "dev": true,
+ "requires": {
+ "spdx-exceptions": "^2.1.0",
+ "spdx-license-ids": "^3.0.0"
+ }
+ },
+ "spdx-license-ids": {
+ "version": "3.0.7",
+ "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.7.tgz",
+ "integrity": "sha512-U+MTEOO0AiDzxwFvoa4JVnMV6mZlJKk2sBLt90s7G0Gd0Mlknc7kxEn3nuDPNZRta7O2uy8oLcZLVT+4sqNZHQ==",
+ "dev": true
+ },
+ "split-string": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/split-string/-/split-string-3.1.0.tgz",
+ "integrity": "sha512-NzNVhJDYpwceVVii8/Hu6DKfD2G+NrQHlS/V/qgv763EYudVwEcMQNxd2lh+0VrUByXN/oJkl5grOhYWvQUYiw==",
+ "dev": true,
+ "requires": {
+ "extend-shallow": "^3.0.0"
+ }
+ },
+ "sprintf-js": {
+ "version": "1.0.3",
+ "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz",
+ "integrity": "sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=",
+ "dev": true
+ },
+ "sshpk": {
+ "version": "1.16.1",
+ "resolved": "https://registry.npmjs.org/sshpk/-/sshpk-1.16.1.tgz",
+ "integrity": "sha512-HXXqVUq7+pcKeLqqZj6mHFUMvXtOJt1uoUx09pFW6011inTMxqI8BA8PM95myrIyyKwdnzjdFjLiE6KBPVtJIg==",
+ "dev": true,
+ "requires": {
+ "asn1": "~0.2.3",
+ "assert-plus": "^1.0.0",
+ "bcrypt-pbkdf": "^1.0.0",
+ "dashdash": "^1.12.0",
+ "ecc-jsbn": "~0.1.1",
+ "getpass": "^0.1.1",
+ "jsbn": "~0.1.0",
+ "safer-buffer": "^2.0.2",
+ "tweetnacl": "~0.14.0"
+ }
+ },
+ "stack-utils": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/stack-utils/-/stack-utils-2.0.3.tgz",
+ "integrity": "sha512-gL//fkxfWUsIlFL2Tl42Cl6+HFALEaB1FU76I/Fy+oZjRreP7OPMXFlGbxM7NQsI0ZpUfw76sHnv0WNYuTb7Iw==",
+ "dev": true,
+ "requires": {
+ "escape-string-regexp": "^2.0.0"
+ },
+ "dependencies": {
+ "escape-string-regexp": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz",
+ "integrity": "sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==",
+ "dev": true
+ }
+ }
+ },
+ "static-extend": {
+ "version": "0.1.2",
+ "resolved": "https://registry.npmjs.org/static-extend/-/static-extend-0.1.2.tgz",
+ "integrity": "sha1-YICcOcv/VTNyJv1eC1IPNB8ftcY=",
+ "dev": true,
+ "requires": {
+ "define-property": "^0.2.5",
+ "object-copy": "^0.1.0"
+ },
+ "dependencies": {
+ "define-property": {
+ "version": "0.2.5",
+ "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz",
+ "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=",
+ "dev": true,
+ "requires": {
+ "is-descriptor": "^0.1.0"
+ }
+ }
+ }
+ },
+ "stealthy-require": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/stealthy-require/-/stealthy-require-1.1.1.tgz",
+ "integrity": "sha1-NbCYdbT/SfJqd35QmzCQoyJr8ks=",
+ "dev": true
+ },
+ "string-length": {
+ "version": "4.0.1",
+ "resolved": "https://registry.npmjs.org/string-length/-/string-length-4.0.1.tgz",
+ "integrity": "sha512-PKyXUd0LK0ePjSOnWn34V2uD6acUWev9uy0Ft05k0E8xRW+SKcA0F7eMr7h5xlzfn+4O3N+55rduYyet3Jk+jw==",
+ "dev": true,
+ "requires": {
+ "char-regex": "^1.0.2",
+ "strip-ansi": "^6.0.0"
+ }
+ },
+ "string-width": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz",
+ "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==",
+ "dev": true,
+ "requires": {
+ "emoji-regex": "^7.0.1",
+ "is-fullwidth-code-point": "^2.0.0",
+ "strip-ansi": "^5.1.0"
+ },
+ "dependencies": {
+ "ansi-regex": {
+ "version": "4.1.0",
+ "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.0.tgz",
+ "integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==",
+ "dev": true
+ },
+ "strip-ansi": {
+ "version": "5.2.0",
+ "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz",
+ "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==",
+ "dev": true,
+ "requires": {
+ "ansi-regex": "^4.1.0"
+ }
+ }
+ }
+ },
+ "string_decoder": {
+ "version": "1.3.0",
+ "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
+ "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
+ "requires": {
+ "safe-buffer": "~5.2.0"
+ }
+ },
+ "strip-ansi": {
+ "version": "6.0.0",
+ "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.0.tgz",
+ "integrity": "sha512-AuvKTrTfQNYNIctbR1K/YGTR1756GycPsg7b9bdV9Duqur4gv6aKqHXah67Z8ImS7WEz5QVcOtlfW2rZEugt6w==",
+ "dev": true,
+ "requires": {
+ "ansi-regex": "^5.0.0"
+ }
+ },
+ "strip-bom": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-4.0.0.tgz",
+ "integrity": "sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==",
+ "dev": true
+ },
+ "strip-eof": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/strip-eof/-/strip-eof-1.0.0.tgz",
+ "integrity": "sha1-u0P/VZim6wXYm1n80SnJgzE2Br8=",
+ "dev": true
+ },
+ "strip-final-newline": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-2.0.0.tgz",
+ "integrity": "sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==",
+ "dev": true
+ },
+ "strip-json-comments": {
+ "version": "3.1.1",
+ "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
+ "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
+ "dev": true
+ },
+ "supports-color": {
+ "version": "5.5.0",
+ "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
+ "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+ "dev": true,
+ "requires": {
+ "has-flag": "^3.0.0"
+ }
+ },
+ "supports-hyperlinks": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/supports-hyperlinks/-/supports-hyperlinks-2.1.0.tgz",
+ "integrity": "sha512-zoE5/e+dnEijk6ASB6/qrK+oYdm2do1hjoLWrqUC/8WEIW1gbxFcKuBof7sW8ArN6e+AYvsE8HBGiVRWL/F5CA==",
+ "dev": true,
+ "requires": {
+ "has-flag": "^4.0.0",
+ "supports-color": "^7.0.0"
+ },
+ "dependencies": {
+ "has-flag": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+ "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+ "dev": true
+ },
+ "supports-color": {
+ "version": "7.2.0",
+ "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+ "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+ "dev": true,
+ "requires": {
+ "has-flag": "^4.0.0"
+ }
+ }
+ }
+ },
+ "symbol-tree": {
+ "version": "3.2.4",
+ "resolved": "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.4.tgz",
+ "integrity": "sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==",
+ "dev": true
+ },
+ "table": {
+ "version": "5.4.6",
+ "resolved": "https://registry.npmjs.org/table/-/table-5.4.6.tgz",
+ "integrity": "sha512-wmEc8m4fjnob4gt5riFRtTu/6+4rSe12TpAELNSqHMfF3IqnA+CH37USM6/YR3qRZv7e56kAEAtd6nKZaxe0Ug==",
+ "dev": true,
+ "requires": {
+ "ajv": "^6.10.2",
+ "lodash": "^4.17.14",
+ "slice-ansi": "^2.1.0",
+ "string-width": "^3.0.0"
+ }
+ },
+ "temp-dir": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/temp-dir/-/temp-dir-2.0.0.tgz",
+ "integrity": "sha512-aoBAniQmmwtcKp/7BzsH8Cxzv8OL736p7v1ihGb5e9DJ9kTwGWHrQrVB5+lfVDzfGrdRzXch+ig7LHaY1JTOrg==",
+ "dev": true
+ },
+ "tempy": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/tempy/-/tempy-1.0.0.tgz",
+ "integrity": "sha512-eLXG5B1G0mRPHmgH2WydPl5v4jH35qEn3y/rA/aahKhIa91Pn119SsU7n7v/433gtT9ONzC8ISvNHIh2JSTm0w==",
+ "dev": true,
+ "requires": {
+ "del": "^6.0.0",
+ "is-stream": "^2.0.0",
+ "temp-dir": "^2.0.0",
+ "type-fest": "^0.16.0",
+ "unique-string": "^2.0.0"
+ },
+ "dependencies": {
+ "is-stream": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.0.tgz",
+ "integrity": "sha512-XCoy+WlUr7d1+Z8GgSuXmpuUFC9fOhRXglJMx+dwLKTkL44Cjd4W1Z5P+BQZpr+cR93aGP4S/s7Ftw6Nd/kiEw==",
+ "dev": true
+ },
+ "type-fest": {
+ "version": "0.16.0",
+ "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.16.0.tgz",
+ "integrity": "sha512-eaBzG6MxNzEn9kiwvtre90cXaNLkmadMWa1zQMs3XORCXNbsH/OewwbxC5ia9dCxIxnTAsSxXJaa/p5y8DlvJg==",
+ "dev": true
+ }
+ }
+ },
+ "terminal-link": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/terminal-link/-/terminal-link-2.1.1.tgz",
+ "integrity": "sha512-un0FmiRUQNr5PJqy9kP7c40F5BOfpGlYTrxonDChEZB7pzZxRNp/bt+ymiy9/npwXya9KH99nJ/GXFIiUkYGFQ==",
+ "dev": true,
+ "requires": {
+ "ansi-escapes": "^4.2.1",
+ "supports-hyperlinks": "^2.0.0"
+ }
+ },
+ "test-exclude": {
+ "version": "6.0.0",
+ "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-6.0.0.tgz",
+ "integrity": "sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==",
+ "dev": true,
+ "requires": {
+ "@istanbuljs/schema": "^0.1.2",
+ "glob": "^7.1.4",
+ "minimatch": "^3.0.4"
+ }
+ },
+ "text-table": {
+ "version": "0.2.0",
+ "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz",
+ "integrity": "sha1-f17oI66AUgfACvLfSoTsP8+lcLQ=",
+ "dev": true
+ },
+ "throat": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/throat/-/throat-5.0.0.tgz",
+ "integrity": "sha512-fcwX4mndzpLQKBS1DVYhGAcYaYt7vsHNIvQV+WXMvnow5cgjPphq5CaayLaGsjRdSCKZFNGt7/GYAuXaNOiYCA==",
+ "dev": true
+ },
+ "tmpl": {
+ "version": "1.0.4",
+ "resolved": "https://registry.npmjs.org/tmpl/-/tmpl-1.0.4.tgz",
+ "integrity": "sha1-I2QN17QtAEM5ERQIIOXPRA5SHdE=",
+ "dev": true
+ },
+ "to-fast-properties": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz",
+ "integrity": "sha1-3F5pjL0HkmW8c+A3doGk5Og/YW4=",
+ "dev": true
+ },
+ "to-object-path": {
+ "version": "0.3.0",
+ "resolved": "https://registry.npmjs.org/to-object-path/-/to-object-path-0.3.0.tgz",
+ "integrity": "sha1-KXWIt7Dn4KwI4E5nL4XB9JmeF68=",
+ "dev": true,
+ "requires": {
+ "kind-of": "^3.0.2"
+ },
+ "dependencies": {
+ "kind-of": {
+ "version": "3.2.2",
+ "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz",
+ "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
+ "dev": true,
+ "requires": {
+ "is-buffer": "^1.1.5"
+ }
+ }
+ }
+ },
+ "to-regex": {
+ "version": "3.0.2",
+ "resolved": "https://registry.npmjs.org/to-regex/-/to-regex-3.0.2.tgz",
+ "integrity": "sha512-FWtleNAtZ/Ki2qtqej2CXTOayOH9bHDQF+Q48VpWyDXjbYxA4Yz8iDB31zXOBUlOHHKidDbqGVrTUvQMPmBGBw==",
+ "dev": true,
+ "requires": {
+ "define-property": "^2.0.2",
+ "extend-shallow": "^3.0.2",
+ "regex-not": "^1.0.2",
+ "safe-regex": "^1.1.0"
+ }
+ },
+ "to-regex-range": {
+ "version": "5.0.1",
+ "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+ "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+ "dev": true,
+ "requires": {
+ "is-number": "^7.0.0"
+ }
+ },
+ "tough-cookie": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-3.0.1.tgz",
+ "integrity": "sha512-yQyJ0u4pZsv9D4clxO69OEjLWYw+jbgspjTue4lTQZLfV0c5l1VmK2y1JK8E9ahdpltPOaAThPcp5nKPUgSnsg==",
+ "dev": true,
+ "requires": {
+ "ip-regex": "^2.1.0",
+ "psl": "^1.1.28",
+ "punycode": "^2.1.1"
+ }
+ },
+ "tr46": {
+ "version": "2.0.2",
+ "resolved": "https://registry.npmjs.org/tr46/-/tr46-2.0.2.tgz",
+ "integrity": "sha512-3n1qG+/5kg+jrbTzwAykB5yRYtQCTqOGKq5U5PE3b0a1/mzo6snDhjGS0zJVJunO0NrT3Dg1MLy5TjWP/UJppg==",
+ "dev": true,
+ "requires": {
+ "punycode": "^2.1.1"
+ }
+ },
+ "ts-jest": {
+ "version": "26.4.4",
+ "resolved": "https://registry.npmjs.org/ts-jest/-/ts-jest-26.4.4.tgz",
+ "integrity": "sha512-3lFWKbLxJm34QxyVNNCgXX1u4o/RV0myvA2y2Bxm46iGIjKlaY0own9gIckbjZJPn+WaJEnfPPJ20HHGpoq4yg==",
+ "dev": true,
+ "requires": {
+ "@types/jest": "26.x",
+ "bs-logger": "0.x",
+ "buffer-from": "1.x",
+ "fast-json-stable-stringify": "2.x",
+ "jest-util": "^26.1.0",
+ "json5": "2.x",
+ "lodash.memoize": "4.x",
+ "make-error": "1.x",
+ "mkdirp": "1.x",
+ "semver": "7.x",
+ "yargs-parser": "20.x"
+ },
+ "dependencies": {
+ "yargs-parser": {
+ "version": "20.2.4",
+ "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.4.tgz",
+ "integrity": "sha512-WOkpgNhPTlE73h4VFAFsOnomJVaovO8VqLDzy5saChRBFQFBoMYirowyW+Q9HB4HFF4Z7VZTiG3iSzJJA29yRA==",
+ "dev": true
+ }
+ }
+ },
+ "tslib": {
+ "version": "1.14.1",
+ "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz",
+ "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==",
+ "dev": true
+ },
+ "tsutils": {
+ "version": "3.17.1",
+ "resolved": "https://registry.npmjs.org/tsutils/-/tsutils-3.17.1.tgz",
+ "integrity": "sha512-kzeQ5B8H3w60nFY2g8cJIuH7JDpsALXySGtwGJ0p2LSjLgay3NdIpqq5SoOBe46bKDW2iq25irHCr8wjomUS2g==",
+ "dev": true,
+ "requires": {
+ "tslib": "^1.8.1"
+ }
+ },
+ "tunnel-agent": {
+ "version": "0.6.0",
+ "resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz",
+ "integrity": "sha1-J6XeoGs2sEoKmWZ3SykIaPD8QP0=",
+ "dev": true,
+ "requires": {
+ "safe-buffer": "^5.0.1"
+ }
+ },
+ "tweetnacl": {
+ "version": "0.14.5",
+ "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-0.14.5.tgz",
+ "integrity": "sha1-WuaBd/GS1EViadEIr6k/+HQ/T2Q=",
+ "dev": true
+ },
+ "type-check": {
+ "version": "0.4.0",
+ "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
+ "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==",
+ "dev": true,
+ "requires": {
+ "prelude-ls": "^1.2.1"
+ }
+ },
+ "type-detect": {
+ "version": "4.0.8",
+ "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz",
+ "integrity": "sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==",
+ "dev": true
+ },
+ "type-fest": {
+ "version": "0.8.1",
+ "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.8.1.tgz",
+ "integrity": "sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==",
+ "dev": true
+ },
+ "typedarray-to-buffer": {
+ "version": "3.1.5",
+ "resolved": "https://registry.npmjs.org/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz",
+ "integrity": "sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==",
+ "dev": true,
+ "requires": {
+ "is-typedarray": "^1.0.0"
+ }
+ },
+ "typescript": {
+ "version": "4.1.2",
+ "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.1.2.tgz",
+ "integrity": "sha512-thGloWsGH3SOxv1SoY7QojKi0tc+8FnOmiarEGMbd/lar7QOEd3hvlx3Fp5y6FlDUGl9L+pd4n2e+oToGMmhRQ==",
+ "dev": true
+ },
+ "union-value": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/union-value/-/union-value-1.0.1.tgz",
+ "integrity": "sha512-tJfXmxMeWYnczCVs7XAEvIV7ieppALdyepWMkHkwciRpZraG/xwT+s2JN8+pr1+8jCRf80FFzvr+MpQeeoF4Xg==",
+ "dev": true,
+ "requires": {
+ "arr-union": "^3.1.0",
+ "get-value": "^2.0.6",
+ "is-extendable": "^0.1.1",
+ "set-value": "^2.0.1"
+ }
+ },
+ "unique-string": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/unique-string/-/unique-string-2.0.0.tgz",
+ "integrity": "sha512-uNaeirEPvpZWSgzwsPGtU2zVSTrn/8L5q/IexZmH0eH6SA73CmAA5U4GwORTxQAZs95TAXLNqeLoPPNO5gZfWg==",
+ "dev": true,
+ "requires": {
+ "crypto-random-string": "^2.0.0"
+ }
+ },
+ "unset-value": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/unset-value/-/unset-value-1.0.0.tgz",
+ "integrity": "sha1-g3aHP30jNRef+x5vw6jtDfyKtVk=",
+ "dev": true,
+ "requires": {
+ "has-value": "^0.3.1",
+ "isobject": "^3.0.0"
+ },
+ "dependencies": {
+ "has-value": {
+ "version": "0.3.1",
+ "resolved": "https://registry.npmjs.org/has-value/-/has-value-0.3.1.tgz",
+ "integrity": "sha1-ex9YutpiyoJ+wKIHgCVlSEWZXh8=",
+ "dev": true,
+ "requires": {
+ "get-value": "^2.0.3",
+ "has-values": "^0.1.4",
+ "isobject": "^2.0.0"
+ },
+ "dependencies": {
+ "isobject": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/isobject/-/isobject-2.1.0.tgz",
+ "integrity": "sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk=",
+ "dev": true,
+ "requires": {
+ "isarray": "1.0.0"
+ }
+ }
+ }
+ },
+ "has-values": {
+ "version": "0.1.4",
+ "resolved": "https://registry.npmjs.org/has-values/-/has-values-0.1.4.tgz",
+ "integrity": "sha1-bWHeldkd/Km5oCCJrThL/49it3E=",
+ "dev": true
+ }
+ }
+ },
+ "uri-js": {
+ "version": "4.4.0",
+ "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.0.tgz",
+ "integrity": "sha512-B0yRTzYdUCCn9n+F4+Gh4yIDtMQcaJsmYBDsTSG8g/OejKBodLQ2IHfN3bM7jUsRXndopT7OIXWdYqc1fjmV6g==",
+ "dev": true,
+ "requires": {
+ "punycode": "^2.1.0"
+ }
+ },
+ "urix": {
+ "version": "0.1.0",
+ "resolved": "https://registry.npmjs.org/urix/-/urix-0.1.0.tgz",
+ "integrity": "sha1-2pN/emLiH+wf0Y1Js1wpNQZ6bHI=",
+ "dev": true
+ },
+ "use": {
+ "version": "3.1.1",
+ "resolved": "https://registry.npmjs.org/use/-/use-3.1.1.tgz",
+ "integrity": "sha512-cwESVXlO3url9YWlFW/TA9cshCEhtu7IKJ/p5soJ/gGpj7vbvFrAY/eIioQ6Dw23KjZhYgiIo8HOs1nQ2vr/oQ==",
+ "dev": true
+ },
+ "util-deprecate": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+ "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8="
+ },
+ "uuid": {
+ "version": "8.3.2",
+ "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
+ "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==",
+ "dev": true,
+ "optional": true
+ },
+ "v8-compile-cache": {
+ "version": "2.2.0",
+ "resolved": "https://registry.npmjs.org/v8-compile-cache/-/v8-compile-cache-2.2.0.tgz",
+ "integrity": "sha512-gTpR5XQNKFwOd4clxfnhaqvfqMpqEwr4tOtCyz4MtYZX2JYhfr1JvBFKdS+7K/9rfpZR3VLX+YWBbKoxCgS43Q==",
+ "dev": true
+ },
+ "v8-to-istanbul": {
+ "version": "7.0.0",
+ "resolved": "https://registry.npmjs.org/v8-to-istanbul/-/v8-to-istanbul-7.0.0.tgz",
+ "integrity": "sha512-fLL2rFuQpMtm9r8hrAV2apXX/WqHJ6+IC4/eQVdMDGBUgH/YMV4Gv3duk3kjmyg6uiQWBAA9nJwue4iJUOkHeA==",
+ "dev": true,
+ "requires": {
+ "@types/istanbul-lib-coverage": "^2.0.1",
+ "convert-source-map": "^1.6.0",
+ "source-map": "^0.7.3"
+ },
+ "dependencies": {
+ "source-map": {
+ "version": "0.7.3",
+ "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.3.tgz",
+ "integrity": "sha512-CkCj6giN3S+n9qrYiBTX5gystlENnRW5jZeNLHpe6aue+SrHcG5VYwujhW9s4dY31mEGsxBDrHR6oI69fTXsaQ==",
+ "dev": true
+ }
+ }
+ },
+ "validate-npm-package-license": {
+ "version": "3.0.4",
+ "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz",
+ "integrity": "sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==",
+ "dev": true,
+ "requires": {
+ "spdx-correct": "^3.0.0",
+ "spdx-expression-parse": "^3.0.0"
+ }
+ },
+ "verror": {
+ "version": "1.10.0",
+ "resolved": "https://registry.npmjs.org/verror/-/verror-1.10.0.tgz",
+ "integrity": "sha1-OhBcoXBTr1XW4nDB+CiGguGNpAA=",
+ "dev": true,
+ "requires": {
+ "assert-plus": "^1.0.0",
+ "core-util-is": "1.0.2",
+ "extsprintf": "^1.2.0"
+ }
+ },
+ "w3c-hr-time": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/w3c-hr-time/-/w3c-hr-time-1.0.2.tgz",
+ "integrity": "sha512-z8P5DvDNjKDoFIHK7q8r8lackT6l+jo/Ye3HOle7l9nICP9lf1Ci25fy9vHd0JOWewkIFzXIEig3TdKT7JQ5fQ==",
+ "dev": true,
+ "requires": {
+ "browser-process-hrtime": "^1.0.0"
+ }
+ },
+ "w3c-xmlserializer": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/w3c-xmlserializer/-/w3c-xmlserializer-2.0.0.tgz",
+ "integrity": "sha512-4tzD0mF8iSiMiNs30BiLO3EpfGLZUT2MSX/G+o7ZywDzliWQ3OPtTZ0PTC3B3ca1UAf4cJMHB+2Bf56EriJuRA==",
+ "dev": true,
+ "requires": {
+ "xml-name-validator": "^3.0.0"
+ }
+ },
+ "walker": {
+ "version": "1.0.7",
+ "resolved": "https://registry.npmjs.org/walker/-/walker-1.0.7.tgz",
+ "integrity": "sha1-L3+bj9ENZ3JisYqITijRlhjgKPs=",
+ "dev": true,
+ "requires": {
+ "makeerror": "1.0.x"
+ }
+ },
+ "webidl-conversions": {
+ "version": "6.1.0",
+ "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-6.1.0.tgz",
+ "integrity": "sha512-qBIvFLGiBpLjfwmYAaHPXsn+ho5xZnGvyGvsarywGNc8VyQJUMHJ8OBKGGrPER0okBeMDaan4mNBlgBROxuI8w==",
+ "dev": true
+ },
+ "whatwg-encoding": {
+ "version": "1.0.5",
+ "resolved": "https://registry.npmjs.org/whatwg-encoding/-/whatwg-encoding-1.0.5.tgz",
+ "integrity": "sha512-b5lim54JOPN9HtzvK9HFXvBma/rnfFeqsic0hSpjtDbVxR3dJKLc+KB4V6GgiGOvl7CY/KNh8rxSo9DKQrnUEw==",
+ "dev": true,
+ "requires": {
+ "iconv-lite": "0.4.24"
+ }
+ },
+ "whatwg-mimetype": {
+ "version": "2.3.0",
+ "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-2.3.0.tgz",
+ "integrity": "sha512-M4yMwr6mAnQz76TbJm914+gPpB/nCwvZbJU28cUD6dR004SAxDLOOSUaB1JDRqLtaOV/vi0IC5lEAGFgrjGv/g==",
+ "dev": true
+ },
+ "whatwg-url": {
+ "version": "8.4.0",
+ "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-8.4.0.tgz",
+ "integrity": "sha512-vwTUFf6V4zhcPkWp/4CQPr1TW9Ml6SF4lVyaIMBdJw5i6qUUJ1QWM4Z6YYVkfka0OUIzVo/0aNtGVGk256IKWw==",
+ "dev": true,
+ "requires": {
+ "lodash.sortby": "^4.7.0",
+ "tr46": "^2.0.2",
+ "webidl-conversions": "^6.1.0"
+ }
+ },
+ "which": {
+ "version": "2.0.2",
+ "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+ "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+ "dev": true,
+ "requires": {
+ "isexe": "^2.0.0"
+ }
+ },
+ "which-module": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/which-module/-/which-module-2.0.0.tgz",
+ "integrity": "sha1-2e8H3Od7mQK4o6j6SzHD4/fm6Ho=",
+ "dev": true
+ },
+ "word-wrap": {
+ "version": "1.2.3",
+ "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.3.tgz",
+ "integrity": "sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==",
+ "dev": true
+ },
+ "wrap-ansi": {
+ "version": "6.2.0",
+ "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-6.2.0.tgz",
+ "integrity": "sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==",
+ "dev": true,
+ "requires": {
+ "ansi-styles": "^4.0.0",
+ "string-width": "^4.1.0",
+ "strip-ansi": "^6.0.0"
+ },
+ "dependencies": {
+ "ansi-styles": {
+ "version": "4.3.0",
+ "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+ "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+ "dev": true,
+ "requires": {
+ "color-convert": "^2.0.1"
+ }
+ },
+ "color-convert": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+ "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+ "dev": true,
+ "requires": {
+ "color-name": "~1.1.4"
+ }
+ },
+ "color-name": {
+ "version": "1.1.4",
+ "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+ "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+ "dev": true
+ },
+ "emoji-regex": {
+ "version": "8.0.0",
+ "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+ "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+ "dev": true
+ },
+ "is-fullwidth-code-point": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+ "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+ "dev": true
+ },
+ "string-width": {
+ "version": "4.2.0",
+ "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.0.tgz",
+ "integrity": "sha512-zUz5JD+tgqtuDjMhwIg5uFVV3dtqZ9yQJlZVfq4I01/K5Paj5UHj7VyrQOJvzawSVlKpObApbfD0Ed6yJc+1eg==",
+ "dev": true,
+ "requires": {
+ "emoji-regex": "^8.0.0",
+ "is-fullwidth-code-point": "^3.0.0",
+ "strip-ansi": "^6.0.0"
+ }
+ }
+ }
+ },
+ "wrappy": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+ "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=",
+ "dev": true
+ },
+ "write-file-atomic": {
+ "version": "3.0.3",
+ "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-3.0.3.tgz",
+ "integrity": "sha512-AvHcyZ5JnSfq3ioSyjrBkH9yW4m7Ayk8/9My/DD9onKeu/94fwrMocemO2QAJFAlnnDN+ZDS+ZjAR5ua1/PV/Q==",
+ "dev": true,
+ "requires": {
+ "imurmurhash": "^0.1.4",
+ "is-typedarray": "^1.0.0",
+ "signal-exit": "^3.0.2",
+ "typedarray-to-buffer": "^3.1.5"
+ }
+ },
+ "ws": {
+ "version": "7.4.1",
+ "resolved": "https://registry.npmjs.org/ws/-/ws-7.4.1.tgz",
+ "integrity": "sha512-pTsP8UAfhy3sk1lSk/O/s4tjD0CRwvMnzvwr4OKGX7ZvqZtUyx4KIJB5JWbkykPoc55tixMGgTNoh3k4FkNGFQ==",
+ "dev": true
+ },
+ "xml-name-validator": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-3.0.0.tgz",
+ "integrity": "sha512-A5CUptxDsvxKJEU3yO6DuWBSJz/qizqzJKOMIfUJHETbBw/sFaDxgd6fxm1ewUaM0jZ444Fc5vC5ROYurg/4Pw==",
+ "dev": true
+ },
+ "xmlchars": {
+ "version": "2.2.0",
+ "resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz",
+ "integrity": "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==",
+ "dev": true
+ },
+ "y18n": {
+ "version": "4.0.1",
+ "resolved": "https://registry.npmjs.org/y18n/-/y18n-4.0.1.tgz",
+ "integrity": "sha512-wNcy4NvjMYL8gogWWYAO7ZFWFfHcbdbE57tZO8e4cbpj8tfUcwrwqSl3ad8HxpYWCdXcJUCeKKZS62Av1affwQ==",
+ "dev": true
+ },
+ "yallist": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
+ "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
+ "dev": true
+ },
+ "yargs": {
+ "version": "15.4.1",
+ "resolved": "https://registry.npmjs.org/yargs/-/yargs-15.4.1.tgz",
+ "integrity": "sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A==",
+ "dev": true,
+ "requires": {
+ "cliui": "^6.0.0",
+ "decamelize": "^1.2.0",
+ "find-up": "^4.1.0",
+ "get-caller-file": "^2.0.1",
+ "require-directory": "^2.1.1",
+ "require-main-filename": "^2.0.0",
+ "set-blocking": "^2.0.0",
+ "string-width": "^4.2.0",
+ "which-module": "^2.0.0",
+ "y18n": "^4.0.0",
+ "yargs-parser": "^18.1.2"
+ },
+ "dependencies": {
+ "emoji-regex": {
+ "version": "8.0.0",
+ "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+ "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+ "dev": true
+ },
+ "is-fullwidth-code-point": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+ "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+ "dev": true
+ },
+ "string-width": {
+ "version": "4.2.0",
+ "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.0.tgz",
+ "integrity": "sha512-zUz5JD+tgqtuDjMhwIg5uFVV3dtqZ9yQJlZVfq4I01/K5Paj5UHj7VyrQOJvzawSVlKpObApbfD0Ed6yJc+1eg==",
+ "dev": true,
+ "requires": {
+ "emoji-regex": "^8.0.0",
+ "is-fullwidth-code-point": "^3.0.0",
+ "strip-ansi": "^6.0.0"
+ }
+ }
+ }
+ },
+ "yargs-parser": {
+ "version": "18.1.3",
+ "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-18.1.3.tgz",
+ "integrity": "sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ==",
+ "dev": true,
+ "requires": {
+ "camelcase": "^5.0.0",
+ "decamelize": "^1.2.0"
+ }
+ }
+ }
+}
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..03ee3d7
--- /dev/null
+++ b/package.json
@@ -0,0 +1,44 @@
+{
+ "name": "@swinton/commit",
+ "version": "2.0.0",
+ "description": "Create a verified commit with GitHub Actions",
+ "main": "dist/index.js",
+ "scripts": {
+ "start": "node dist/index.js",
+ "lint": "tsc --noEmit && eslint '*/**/*.{js,ts,tsx}'",
+ "test": "jest",
+ "build": "ncc build index.ts -o dist"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/swinton/commit.git"
+ },
+ "keywords": [],
+ "author": "Steve Winton (https://github.com/swinton)",
+ "license": "ISC",
+ "bugs": {
+ "url": "https://github.com/swinton/commit/issues"
+ },
+ "homepage": "https://github.com/swinton/commit#readme",
+ "devDependencies": {
+ "@types/jest": "^26.0.19",
+ "@types/node": "^14.14.10",
+ "@typescript-eslint/eslint-plugin": "^4.9.1",
+ "@typescript-eslint/parser": "^4.9.1",
+ "@vercel/ncc": "^0.25.1",
+ "eslint": "^7.15.0",
+ "eslint-config-prettier": "^7.0.0",
+ "eslint-plugin-prettier": "^3.2.0",
+ "jest": "^26.6.3",
+ "prettier": "^2.2.1",
+ "tempy": "^1.0.0",
+ "ts-jest": "^26.4.4",
+ "typescript": "^4.1.2"
+ },
+ "dependencies": {
+ "@actions/core": "^1.2.6",
+ "axios": "^0.21.0",
+ "base64-stream": "^1.0.0",
+ "multistream": "^4.0.1"
+ }
+}
diff --git a/tests/blob.test.ts b/tests/blob.test.ts
new file mode 100644
index 0000000..4f73f89
--- /dev/null
+++ b/tests/blob.test.ts
@@ -0,0 +1,41 @@
+import fs from "fs";
+import { join } from "path";
+import { finished } from "stream";
+import { promisify } from "util";
+import tempy from "tempy";
+
+import { Repo } from "../lib/repo";
+import { Blob } from "../lib/blob";
+
+describe("Blob", () => {
+ let repo: Repo;
+ let blob: Blob;
+
+ beforeEach(() => {
+ repo = new Repo("foo/bar");
+ blob = new Blob(repo, __dirname, "fixtures/blob.txt");
+ });
+
+ test("mode", () => {
+ expect(blob.mode).toBe("100644");
+ });
+
+ test("path", () => {
+ expect(blob.path).toBe("fixtures/blob.txt");
+ });
+
+ test("stream", async () => {
+ const source = blob.stream;
+ const dest = fs.createWriteStream(tempy.file({ extension: "json" }));
+ await promisify(finished)(source.pipe(dest));
+ expect(
+ JSON.parse(fs.readFileSync(dest.path.toString()).toString())
+ ).toEqual(
+ JSON.parse(
+ fs
+ .readFileSync(join(__dirname, "fixtures", "blob.payload.json"))
+ .toString()
+ )
+ );
+ });
+});
diff --git a/tests/fixtures/blob.payload.json b/tests/fixtures/blob.payload.json
new file mode 100644
index 0000000..f70d3e3
--- /dev/null
+++ b/tests/fixtures/blob.payload.json
@@ -0,0 +1,4 @@
+{
+ "content": "Keep it logically awesome.
Mind your words, they are important.
Keep it logically awesome.
Non-blocking is better than blocking.
Responsive is better than fast.
Favor focus over features.
Keep it logically awesome.
Approachable is better than simple.
Responsive is better than fast.
Keep it logically awesome.
Approachable is better than simple.
Encourage flow.
Speak like a human.
Anything added dilutes everything else.
Practicality beats purity.
Half measures are as bad as nothing at all.
Anything added dilutes everything else.
Approachable is better than simple.
Avoid administrative distraction.
Approachable is better than simple.
Encourage flow.
Practicality beats purity.
Approachable is better than simple.
Avoid administrative distraction.
Non-blocking is better than blocking.
Favor focus over features.
Half measures are as bad as nothing at all.
Responsive is better than fast.
Design for failure.
Responsive is better than fast.
Keep it logically awesome.
Design for failure.
Non-blocking is better than blocking.
Responsive is better than fast.
Mind your words, they are important.
It's not fully shipped until it's fast.
Anything added dilutes everything else.
Encourage flow.
Avoid administrative distraction.
Keep it logically awesome.
Responsive is better than fast.
Anything added dilutes everything else.
Avoid administrative distraction.
Encourage flow.
Anything added dilutes everything else.
Speak like a human.
Non-blocking is better than blocking.
Practicality beats purity.
Favor focus over features.
Mind your words, they are important.
It's not fully shipped until it's fast.
Encourage flow.
It's not fully shipped until it's fast.
Speak like a human.
Keep it logically awesome.
Design for failure.
Responsive is better than fast.
Non-blocking is better than blocking.
Mind your words, they are important.
Design for failure.
Avoid administrative distraction.
Design for failure.
It's not fully shipped until it's fast.
Avoid administrative distraction.
Avoid administrative distraction.
Anything added dilutes everything else.
Encourage flow.
Avoid administrative distraction.
Encourage flow.
Approachable is better than simple.
Anything added dilutes everything else.
Anything added dilutes everything else.
Responsive is better than fast.
Design for failure.
Speak like a human.
Practicality beats purity.
Avoid administrative distraction.
Responsive is better than fast.
It's not fully shipped until it's fast.
Favor focus over features.
Approachable is better than simple.
It's not fully shipped until it's fast.
Keep it logically awesome.
Encourage flow.
Keep it logically awesome.
Responsive is better than fast.
Responsive is better than fast.
Half measures are as bad as nothing at all.
Avoid administrative distraction.
Mind your words, they are important.
Practicality beats purity.
Mind your words, they are important.
Favor focus over features.
Keep it logically awesome.
Anything added dilutes everything else.
Speak like a human.
It's not fully shipped until it's fast.
Mind your words, they are important.
Keep it logically awesome.
Speak like a human.
Encourage flow.
Favor focus over features.
Practicality beats purity.
Half measures are as bad as nothing at all.
Speak like a human.
It's not fully shipped until it's fast.
Mind your words, they are important.
It's not fully shipped until it's fast.
Non-blocking is better than blocking.
Mind your words, they are important.
Responsive is better than fast.
Speak like a human.
Favor focus over features.
Approachable is better than simple.
Keep it logically awesome.
Favor focus over features.
Half measures are as bad as nothing at all.
Avoid administrative distraction.
Anything added dilutes everything else.
Keep it logically awesome.
Mind your words, they are important.
Responsive is better than fast.
Design for failure.
Keep it logically awesome.
Mind your words, they are important.
Non-blocking is better than blocking.
Anything added dilutes everything else.
Avoid administrative distraction.
Practicality beats purity.
Favor focus over features.
Keep it logically awesome.
Favor focus over features.
Keep it logically awesome.
Anything added dilutes everything else.
Practicality beats purity.
Mind your words, they are important.
Anything added dilutes everything else.
Speak like a human.
It's not fully shipped until it's fast.
Half measures are as bad as nothing at all.
It's not fully shipped until it's fast.
Design for failure.
Non-blocking is better than blocking.
Encourage flow.
Practicality beats purity.
Favor focus over features.
Approachable is better than simple.
Favor focus over features.
Approachable is better than simple.
Anything added dilutes everything else.
Practicality beats purity.
Responsive is better than fast.
Avoid administrative distraction.
It's not fully shipped until it's fast.
It's not fully shipped until it's fast.
Speak like a human.
Keep it logically awesome.
Non-blocking is better than blocking.
Speak like a human.
Practicality beats purity.
Design for failure.
Approachable is better than simple.
Design for failure.
Speak like a human.
Approachable is better than simple.
Design for failure.
Encourage flow.
Half measures are as bad as nothing at all.
Mind your words, they are important.
Responsive is better than fast.
Responsive is better than fast.
Mind your words, they are important.
Favor focus over features.
Practicality beats purity.
Approachable is better than simple.
Favor focus over features.
Keep it logically awesome.
Avoid administrative distraction.
Avoid administrative distraction.
Responsive is better than fast.
Half measures are as bad as nothing at all.
Design for failure.
Design for failure.
Encourage flow.
Half measures are as bad as nothing at all.
Speak like a human.
Encourage flow.
Speak like a human.
Non-blocking is better than blocking.
Half measures are as bad as nothing at all.
Non-blocking is better than blocking.
Mind your words, they are important.
Half measures are as bad as nothing at all.
Design for failure.
Favor focus over features.
Anything added dilutes everything else.
Avoid administrative distraction.
It's not fully shipped until it's fast.
Design for failure.
Keep it logically awesome.
Anything added dilutes everything else.
Avoid administrative distraction.
Practicality beats purity.
Approachable is better than simple.
Approachable is better than simple.
Anything added dilutes everything else.
Avoid administrative distraction.
Keep it logically awesome.
Responsive is better than fast.
Non-blocking is better than blocking.
Encourage flow.
Mind your words, they are important.
Speak like a human.
Practicality beats purity.
Approachable is better than simple.
Keep it logically awesome.
Practicality beats purity.
Practicality beats purity.
Mind your words, they are important.
Design for failure.
Responsive is better than fast.
Approachable is better than simple.
Design for failure.
Encourage flow.
Practicality beats purity.
It's not fully shipped until it's fast.
Anything added dilutes everything else.
Half measures are as bad as nothing at all.
Responsive is better than fast.
Half measures are as bad as nothing at all.
Keep it logically awesome.
Half measures are as bad as nothing at all.
Approachable is better than simple.
Speak like a human.
Avoid administrative distraction.
Encourage flow.
Non-blocking is better than blocking.
Speak like a human.
Encourage flow.
Anything added dilutes everything else.
Speak like a human.
Practicality beats purity.
Speak like a human.
It's not fully shipped until it's fast.
Favor focus over features.
Practicality beats purity.
Half measures are as bad as nothing at all.
Keep it logically awesome.
Responsive is better than fast.
Design for failure.
Approachable is better than simple.
Non-blocking is better than blocking.
Half measures are as bad as nothing at all.
Speak like a human.
Approachable is better than simple.
Responsive is better than fast.
Design for failure.
Design for failure.
Favor focus over features.
Non-blocking is better than blocking.
Speak like a human.
Mind your words, they are important.
Design for failure.
Half measures are as bad as nothing at all.
Practicality beats purity.
Practicality beats purity.
Keep it logically awesome.
Encourage flow.
Anything added dilutes everything else.
Half measures are as bad as nothing at all.
Encourage flow.
Mind your words, they are important.
Keep it logically awesome.
Practicality beats purity.
Half measures are as bad as nothing at all.
Responsive is better than fast.
Favor focus over features.
It's not fully shipped until it's fast.
Favor focus over features.
Responsive is better than fast.
Half measures are as bad as nothing at all.
Design for failure.
Non-blocking is better than blocking.
Mind your words, they are important.
Practicality beats purity.
Non-blocking is better than blocking.
Encourage flow.
Keep it logically awesome.
Approachable is better than simple.
Design for failure.
Speak like a human.
Half measures are as bad as nothing at all.
Practicality beats purity.
Encourage flow.
Half measures are as bad as nothing at all.
Favor focus over features.
Mind your words, they are important.
Speak like a human.
Practicality beats purity.
Anything added dilutes everything else.
Avoid administrative distraction.
Keep it logically awesome.
Responsive is better than fast.
It's not fully shipped until it's fast.
It's not fully shipped until it's fast.
Favor focus over features.
Non-blocking is better than blocking.
Mind your words, they are important.
Approachable is better than simple.
Non-blocking is better than blocking.
Anything added dilutes everything else.
Encourage flow.
Mind your words, they are important.
Approachable is better than simple.
Avoid administrative distraction.
Avoid administrative distraction.
Speak like a human.
Responsive is better than fast.
Approachable is better than simple.
Anything added dilutes everything else.
Encourage flow.
Anything added dilutes everything else.
Half measures are as bad as nothing at all.
Favor focus over features.
Design for failure.
Avoid administrative distraction.
Design for failure.
It's not fully shipped until it's fast.
Half measures are as bad as nothing at all.
Practicality beats purity.
Encourage flow.
Favor focus over features.
It's not fully shipped until it's fast.
Half measures are as bad as nothing at all.
Practicality beats purity.
Anything added dilutes everything else.
Design for failure.
Non-blocking is better than blocking.
Keep it logically awesome.
Favor focus over features.
Responsive is better than fast.
Mind your words, they are important.
Encourage flow.
Avoid administrative distraction.
Keep it logically awesome.
Practicality beats purity.
Half measures are as bad as nothing at all.
Approachable is better than simple.
It's not fully shipped until it's fast.
Responsive is better than fast.
Keep it logically awesome.
Mind your words, they are important.
Responsive is better than fast.
Keep it logically awesome.
Approachable is better than simple.
Non-blocking is better than blocking.
Design for failure.
Half measures are as bad as nothing at all.
Responsive is better than fast.
Practicality beats purity.
Keep it logically awesome.
Approachable is better than simple.
Half measures are as bad as nothing at all.
Favor focus over features.
Practicality beats purity.
Encourage flow.
Avoid administrative distraction.
Approachable is better than simple.
Anything added dilutes everything else.
Mind your words, they are important.
Keep it logically awesome.
Avoid administrative distraction.
Speak like a human.
Approachable is better than simple.
Non-blocking is better than blocking.
Speak like a human.
Mind your words, they are important.
Design for failure.
Anything added dilutes everything else.
Practicality beats purity.
It's not fully shipped until it's fast.
Speak like a human.
Anything added dilutes everything else.
Avoid administrative distraction.
Non-blocking is better than blocking.
Avoid administrative distraction.
Non-blocking is better than blocking.
Avoid administrative distraction.
Practicality beats purity.
Speak like a human.
Half measures are as bad as nothing at all.
Anything added dilutes everything else.
Speak like a human.
Non-blocking is better than blocking.
Speak like a human.
Keep it logically awesome.
Mind your words, they are important.
Non-blocking is better than blocking.
Mind your words, they are important.
Avoid administrative distraction.
Half measures are as bad as nothing at all.
Design for failure.
Design for failure.
Favor focus over features.
It's not fully shipped until it's fast.
Avoid administrative distraction.
Half measures are as bad as nothing at all.
Favor focus over features.
It's not fully shipped until it's fast.
Speak like a human.
Half measures are as bad as nothing at all.
Encourage flow.
Non-blocking is better than blocking.
Favor focus over features.
Anything added dilutes everything else.
Keep it logically awesome.
Mind your words, they are important.
It's not fully shipped until it's fast.
Half measures are as bad as nothing at all.
Approachable is better than simple.
Responsive is better than fast.
Design for failure.
Design for failure.
Encourage flow.
Avoid administrative distraction.
Approachable is better than simple.
Design for failure.
Design for failure.
Encourage flow.
It's not fully shipped until it's fast.
Half measures are as bad as nothing at all.
Design for failure.
Anything added dilutes everything else.
Half measures are as bad as nothing at all.
Half measures are as bad as nothing at all.
Practicality beats purity.
Non-blocking is better than blocking.
Practicality beats purity.
It's not fully shipped until it's fast.
Mind your words, they are important.
Non-blocking is better than blocking.
It's not fully shipped until it's fast.
Design for failure.
Encourage flow.
Non-blocking is better than blocking.
Design for failure.
Non-blocking is better than blocking.
Non-blocking is better than blocking.
Half measures are as bad as nothing at all.
Practicality beats purity.
Speak like a human.
Practicality beats purity.
Responsive is better than fast.
Speak like a human.
Non-blocking is better than blocking.
Half measures are as bad as nothing at all.
Anything added dilutes everything else.
Design for failure.
Half measures are as bad as nothing at all.
Non-blocking is better than blocking.
Favor focus over features.
Non-blocking is better than blocking.
Speak like a human.
Encourage flow.
Anything added dilutes everything else.
Favor focus over features.
It's not fully shipped until it's fast.
Responsive is better than fast.
Responsive is better than fast.
Keep it logically awesome.
Practicality beats purity.
Practicality beats purity.
Design for failure.
Design for failure.
Mind your words, they are important.
Keep it logically awesome.
Anything added dilutes everything else.
Half measures are as bad as nothing at all.
Approachable is better than simple.
Practicality beats purity.
Half measures are as bad as nothing at all.
It's not fully shipped until it's fast.
Mind your words, they are important.
Responsive is better than fast.
Mind your words, they are important.
Speak like a human.
Practicality beats purity.
Approachable is better than simple.
Practicality beats purity.
Keep it logically awesome.
Responsive is better than fast.
Anything added dilutes everything else.
Keep it logically awesome.
Non-blocking is better than blocking.
Favor focus over features.
Anything added dilutes everything else.
Non-blocking is better than blocking.
Practicality beats purity.
Practicality beats purity.
Non-blocking is better than blocking.
Design for failure.
Speak like a human.
Avoid administrative distraction.
Design for failure.
Avoid administrative distraction.
Favor focus over features.
Half measures are as bad as nothing at all.
Design for failure.
Half measures are as bad as nothing at all.
Responsive is better than fast.
Half measures are as bad as nothing at all.
Design for failure.
Responsive is better than fast.
Keep it logically awesome.
Half measures are as bad as nothing at all.
Design for failure.
Mind your words, they are important.
Mind your words, they are important.
Non-blocking is better than blocking.
Speak like a human.
Favor focus over features.
Non-blocking is better than blocking.
Design for failure.
Non-blocking is better than blocking.
Non-blocking is better than blocking.
Design for failure.
Non-blocking is better than blocking.
Anything added dilutes everything else.
Avoid administrative distraction.
Responsive is better than fast.
Half measures are as bad as nothing at all.
It's not fully shipped until it's fast.
Encourage flow.
Favor focus over features.
Half measures are as bad as nothing at all.
Approachable is better than simple.
Anything added dilutes everything else.
It's not fully shipped until it's fast.
Mind your words, they are important.
Responsive is better than fast.
Avoid administrative distraction.
Speak like a human.
Keep it logically awesome.
Responsive is better than fast.
Encourage flow.
It's not fully shipped until it's fast.
Design for failure.
It's not fully shipped until it's fast.
Practicality beats purity.
Keep it logically awesome.
Mind your words, they are important.
Speak like a human.
Favor focus over features.
Design for failure.
Encourage flow.
It's not fully shipped until it's fast.
Half measures are as bad as nothing at all.
It's not fully shipped until it's fast.
Encourage flow.
Responsive is better than fast.
Design for failure.
Favor focus over features.
Practicality beats purity.
Anything added dilutes everything else.
Mind your words, they are important.
Design for failure.
Responsive is better than fast.
Avoid administrative distraction.
Practicality beats purity.
Responsive is better than fast.
Keep it logically awesome.
Non-blocking is better than blocking.
Practicality beats purity.
It's not fully shipped until it's fast.
Half measures are as bad as nothing at all.
Half measures are as bad as nothing at all.
Responsive is better than fast.
Half measures are as bad as nothing at all.
Half measures are as bad as nothing at all.
Practicality beats purity.
Avoid administrative distraction.
Mind your words, they are important.
Favor focus over features.
Half measures are as bad as nothing at all.
It's not fully shipped until it's fast.
Design for failure.
Avoid administrative distraction.
Half measures are as bad as nothing at all.
Speak like a human.
Non-blocking is better than blocking.
Design for failure.
Anything added dilutes everything else.
Encourage flow.
Keep it logically awesome.
Speak like a human.
It's not fully shipped until it's fast.
Keep it logically awesome.
Non-blocking is better than blocking.
Anything added dilutes everything else.
Practicality beats purity.
Anything added dilutes everything else.
Mind your words, they are important.
Half measures are as bad as nothing at all.
Mind your words, they are important.
Avoid administrative distraction.
Mind your words, they are important.
Speak like a human.
Non-blocking is better than blocking.
Half measures are as bad as nothing at all.
Favor focus over features.
Responsive is better than fast.
Responsive is better than fast.
Mind your words, they are important.
Avoid administrative distraction.
Design for failure.
Speak like a human.
Favor focus over features.
Encourage flow.
Encourage flow.
Avoid administrative distraction.
Non-blocking is better than blocking.
Mind your words, they are important.
Encourage flow.
Half measures are as bad as nothing at all.
Approachable is better than simple.
Practicality beats purity.
Keep it logically awesome.
Responsive is better than fast.
Favor focus over features.
It's not fully shipped until it's fast.
Favor focus over features.
Speak like a human.
Non-blocking is better than blocking.
Anything added dilutes everything else.
Non-blocking is better than blocking.
Approachable is better than simple.
Avoid administrative distraction.
Avoid administrative distraction.
Responsive is better than fast.
Encourage flow.
Keep it logically awesome.
Responsive is better than fast.
Responsive is better than fast.
Responsive is better than fast.
Mind your words, they are important.
Approachable is better than simple.
Practicality beats purity.
Anything added dilutes everything else.
Keep it logically awesome.
Practicality beats purity.
Responsive is better than fast.
Approachable is better than simple.
Anything added dilutes everything else.
Keep it logically awesome.
Encourage flow.
Practicality beats purity.
Anything added dilutes everything else.
It's not fully shipped until it's fast.
Speak like a human.
It's not fully shipped until it's fast.
Anything added dilutes everything else.
It's not fully shipped until it's fast.
Approachable is better than simple.
Mind your words, they are important.
Half measures are as bad as nothing at all.
Non-blocking is better than blocking.
Speak like a human.
Non-blocking is better than blocking.
Practicality beats purity.
Favor focus over features.
Favor focus over features.
Anything added dilutes everything else.
Half measures are as bad as nothing at all.
Favor focus over features.
It's not fully shipped until it's fast.
Avoid administrative distraction.
It's not fully shipped until it's fast.
Half measures are as bad as nothing at all.
Keep it logically awesome.
Responsive is better than fast.
Practicality beats purity.
Favor focus over features.
Half measures are as bad as nothing at all.
Responsive is better than fast.
Approachable is better than simple.
Avoid administrative distraction.
It's not fully shipped until it's fast.
Anything added dilutes everything else.
Favor focus over features.
Design for failure.
Mind your words, they are important.
Favor focus over features.
Half measures are as bad as nothing at all.
It's not fully shipped until it's fast.
Speak like a human.
Favor focus over features.
It's not fully shipped until it's fast.
Non-blocking is better than blocking.
Half measures are as bad as nothing at all.
Half measures are as bad as nothing at all.
Avoid administrative distraction.
Anything added dilutes everything else.
Keep it logically awesome.
Practicality beats purity.
Favor focus over features.
Avoid administrative distraction.
Non-blocking is better than blocking.
Anything added dilutes everything else.
Responsive is better than fast.
Anything added dilutes everything else.
Practicality beats purity.
Non-blocking is better than blocking.
Anything added dilutes everything else.
Anything added dilutes everything else.
Responsive is better than fast.
Design for failure.
Mind your words, they are important.
Approachable is better than simple.
Encourage flow.
Non-blocking is better than blocking.
Non-blocking is better than blocking.
It's not fully shipped until it's fast.
Mind your words, they are important.
Encourage flow.
It's not fully shipped until it's fast.
Responsive is better than fast.
Non-blocking is better than blocking.
Encourage flow.
Mind your words, they are important.
Practicality beats purity.
Anything added dilutes everything else.
Non-blocking is better than blocking.
Favor focus over features.
Mind your words, they are important.
Half measures are as bad as nothing at all.
Non-blocking is better than blocking.
Avoid administrative distraction.
Practicality beats purity.
Speak like a human.
Keep it logically awesome.
It's not fully shipped until it's fast.
Non-blocking is better than blocking.
Anything added dilutes everything else.
Favor focus over features.
Approachable is better than simple.
Non-blocking is better than blocking.
Encourage flow.
Avoid administrative distraction.
Half measures are as bad as nothing at all.
It's not fully shipped until it's fast.
Mind your words, they are important.
Keep it logically awesome.
Favor focus over features.
Avoid administrative distraction.
Half measures are as bad as nothing at all.
It's not fully shipped until it's fast.
Responsive is better than fast.
Keep it logically awesome.
Encourage flow.
Encourage flow.
Avoid administrative distraction.
Half measures are as bad as nothing at all.
Responsive is better than fast.
Responsive is better than fast.
Avoid administrative distraction.
Responsive is better than fast.
Practicality beats purity.
Keep it logically awesome.
Approachable is better than simple.
Keep it logically awesome.
It's not fully shipped until it's fast.
Keep it logically awesome.
Approachable is better than simple.
Responsive is better than fast.
Keep it logically awesome.
Keep it logically awesome.
Encourage flow.
Approachable is better than simple.
Encourage flow.
Non-blocking is better than blocking.
Practicality beats purity.
Encourage flow.
Mind your words, they are important.
Responsive is better than fast.
It's not fully shipped until it's fast.
Half measures are as bad as nothing at all.
Non-blocking is better than blocking.
Encourage flow.
Design for failure.
Favor focus over features.
It's not fully shipped until it's fast.
It's not fully shipped until it's fast.
Speak like a human.
Speak like a human.
Speak like a human.
Favor focus over features.
Encourage flow.
Speak like a human.
Mind your words, they are important.
Responsive is better than fast.
Practicality beats purity.
Mind your words, they are important.
Non-blocking is better than blocking.
It's not fully shipped until it's fast.
Mind your words, they are important.
Avoid administrative distraction.
Half measures are as bad as nothing at all.
Mind your words, they are important.
Anything added dilutes everything else.
Favor focus over features.
Responsive is better than fast.
Speak like a human.
Mind your words, they are important.
Favor focus over features.
Avoid administrative distraction.
Responsive is better than fast.
Non-blocking is better than blocking.
Design for failure.
Non-blocking is better than blocking.
Practicality beats purity.
Favor focus over features.
Design for failure.
Design for failure.
Favor focus over features.
Responsive is better than fast.
It's not fully shipped until it's fast.
Design for failure.
Half measures are as bad as nothing at all.
Avoid administrative distraction.
Non-blocking is better than blocking.
Favor focus over features.
Practicality beats purity.
Mind your words, they are important.
Anything added dilutes everything else.
Favor focus over features.
Encourage flow.
Speak like a human.
Favor focus over features.
Half measures are as bad as nothing at all.
Approachable is better than simple.
Approachable is better than simple.
Speak like a human.
Design for failure.
Speak like a human.
Half measures are as bad as nothing at all.
Non-blocking is better than blocking.
Design for failure.
Anything added dilutes everything else.
Favor focus over features.
Design for failure.
Speak like a human.
Half measures are as bad as nothing at all.
Non-blocking is better than blocking.
Half measures are as bad as nothing at all.
Half measures are as bad as nothing at all.
Non-blocking is better than blocking.
Responsive is better than fast.
Practicality beats purity.
Approachable is better than simple.
Mind your words, they are important.
Speak like a human.
Approachable is better than simple.
Speak like a human.
It's not fully shipped until it's fast.
Half measures are as bad as nothing at all.
Mind your words, they are important.
Responsive is better than fast.
Anything added dilutes everything else.
Mind your words, they are important.
Practicality beats purity.
Favor focus over features.
Design for failure.
Design for failure.
It's not fully shipped until it's fast.
Practicality beats purity.
Avoid administrative distraction.
Half measures are as bad as nothing at all.
Favor focus over features.
Approachable is better than simple.
Anything added dilutes everything else.
Keep it logically awesome.
Design for failure.
Speak like a human.
Keep it logically awesome.
Mind your words, they are important.
Design for failure.
Approachable is better than simple.
Avoid administrative distraction.
It's not fully shipped until it's fast.
Keep it logically awesome.
Practicality beats purity.
Mind your words, they are important.
Encourage flow.
Favor focus over features.
Responsive is better than fast.
Encourage flow.
Practicality beats purity.
Encourage flow.
Avoid administrative distraction.
Approachable is better than simple.
Mind your words, they are important.
Design for failure.
Anything added dilutes everything else.
Keep it logically awesome.
Practicality beats purity.
Speak like a human.
Mind your words, they are important.
Favor focus over features.
Avoid administrative distraction.
Non-blocking is better than blocking.
It's not fully shipped until it's fast.
Encourage flow.
Favor focus over features.
Non-blocking is better than blocking.
Practicality beats purity.
Practicality beats purity.
Encourage flow.
Non-blocking is better than blocking.
Avoid administrative distraction.
Responsive is better than fast.
Anything added dilutes everything else.
Responsive is better than fast.
Keep it logically awesome.
Speak like a human.
Mind your words, they are important.
Responsive is better than fast.
Non-blocking is better than blocking.
Keep it logically awesome.
Anything added dilutes everything else.
Anything added dilutes everything else.
Anything added dilutes everything else.
Design for failure.
Speak like a human.
Responsive is better than fast.
It's not fully shipped until it's fast.
Speak like a human.
Encourage flow.
Keep it logically awesome.
Keep it logically awesome.
Practicality beats purity.
Anything added dilutes everything else.
Mind your words, they are important.
Practicality beats purity.
Anything added dilutes everything else.
Keep it logically awesome.
Non-blocking is better than blocking.
Keep it logically awesome.
Mind your words, they are important.
It's not fully shipped until it's fast.
Approachable is better than simple.
Favor focus over features.
Keep it logically awesome.
Approachable is better than simple.
Favor focus over features.
Practicality beats purity.
Favor focus over features.
Approachable is better than simple.
Responsive is better than fast.
Anything added dilutes everything else.
Anything added dilutes everything else.
It's not fully shipped until it's fast.
Non-blocking is better than blocking.
It's not fully shipped until it's fast.
Encourage flow.
Avoid administrative distraction.
Responsive is better than fast.
Half measures are as bad as nothing at all.
Mind your words, they are important.
Design for failure.
Non-blocking is better than blocking.
Anything added dilutes everything else.
Speak like a human.
Design for failure.
Non-blocking is better than blocking.
Non-blocking is better than blocking.
Mind your words, they are important.
Keep it logically awesome.
Non-blocking is better than blocking.
Design for failure.
Practicality beats purity.
Practicality beats purity.
Encourage flow.
Responsive is better than fast.
Design for failure.
It's not fully shipped until it's fast.
Avoid administrative distraction.
Responsive is better than fast.
Half measures are as bad as nothing at all.
Avoid administrative distraction.
Non-blocking is better than blocking.
It's not fully shipped until it's fast.
Non-blocking is better than blocking.
Anything added dilutes everything else.
Avoid administrative distraction.
Design for failure.
Half measures are as bad as nothing at all.
Mind your words, they are important.
Responsive is better than fast.
Responsive is better than fast.
Approachable is better than simple.
Keep it logically awesome.
Non-blocking is better than blocking.
Keep it logically awesome.
Responsive is better than fast.
Non-blocking is better than blocking.
Approachable is better than simple.
Design for failure.
Design for failure.
Responsive is better than fast.
Design for failure.
Avoid administrative distraction.
Anything added dilutes everything else.
Half measures are as bad as nothing at all.
Speak like a human.
Encourage flow.
Avoid administrative distraction.
Approachable is better than simple.
Speak like a human.
Half measures are as bad as nothing at all.
Mind your words, they are important.
Design for failure.
Design for failure.
Speak like a human.
Approachable is better than simple.
Half measures are as bad as nothing at all.
Keep it logically awesome.
Approachable is better than simple.
Practicality beats purity.
Avoid administrative distraction.
It's not fully shipped until it's fast.
Encourage flow.
Half measures are as bad as nothing at all.
Approachable is better than simple.
Non-blocking is better than blocking.
Responsive is better than fast.
Mind your words, they are important.
Encourage flow.
Practicality beats purity.
Speak like a human.
Keep it logically awesome.
Practicality beats purity.
Encourage flow.
Design for failure.
Practicality beats purity.
Responsive is better than fast.
Speak like a human.
Design for failure.
Keep it logically awesome.
It's not fully shipped until it's fast.
Practicality beats purity.
Mind your words, they are important.
It's not fully shipped until it's fast.
Responsive is better than fast.
It's not fully shipped until it's fast.
Half measures are as bad as nothing at all.
Half measures are as bad as nothing at all.
Encourage flow.
Approachable is better than simple.
Half measures are as bad as nothing at all.
Speak like a human.
Half measures are as bad as nothing at all.
Encourage flow.
Avoid administrative distraction.
Mind your words, they are important.
Practicality beats purity.
Favor focus over features.
Speak like a human.
Speak like a human.
Non-blocking is better than blocking.
Responsive is better than fast.
Mind your words, they are important.
Practicality beats purity.
Design for failure.
Avoid administrative distraction.
Speak like a human.
Speak like a human.
Half measures are as bad as nothing at all.
Half measures are as bad as nothing at all.
Anything added dilutes everything else.
Keep it logically awesome.
Encourage flow.
Approachable is better than simple.
Design for failure.
Favor focus over features.
Design for failure.
Anything added dilutes everything else.
Anything added dilutes everything else.
Keep it logically awesome.
It's not fully shipped until it's fast.
Approachable is better than simple.
Practicality beats purity.
Favor focus over features.
Approachable is better than simple.
Responsive is better than fast.
Half measures are as bad as nothing at all.
Favor focus over features.
Approachable is better than simple.
Avoid administrative distraction.
Design for failure.
Speak like a human.
Design for failure.
Responsive is better than fast.
Speak like a human.
Half measures are as bad as nothing at all.
Half measures are as bad as nothing at all.
Non-blocking is better than blocking.
Half measures are as bad as nothing at all.
Avoid administrative distraction.
It's not fully shipped until it's fast.
Encourage flow.
Responsive is better than fast.
Mind your words, they are important.
Speak like a human.
Keep it logically awesome.
Responsive is better than fast.
Approachable is better than simple.
Encourage flow.
Design for failure.
Half measures are as bad as nothing at all.
Keep it logically awesome.
Practicality beats purity.
Encourage flow.
It's not fully shipped until it's fast.
Responsive is better than fast.
Design for failure.
Speak like a human.
Responsive is better than fast.
Speak like a human.
Responsive is better than fast.
Practicality beats purity.
Avoid administrative distraction.
Favor focus over features.
Responsive is better than fast.
Mind your words, they are important.
Mind your words, they are important.
Approachable is better than simple.
Encourage flow.
Favor focus over features.
Avoid administrative distraction.
Mind your words, they are important.
Mind your words, they are important.
Half measures are as bad as nothing at all.
Responsive is better than fast.
Keep it logically awesome.
Non-blocking is better than blocking.
It's not fully shipped until it's fast.
Anything added dilutes everything else.
Mind your words, they are important.
It's not fully shipped until it's fast.
Non-blocking is better than blocking.
Avoid administrative distraction.
Approachable is better than simple.
Mind your words, they are important.
Favor focus over features.
Encourage flow.
Practicality beats purity.
It's not fully shipped until it's fast.
Practicality beats purity.
Design for failure.
Speak like a human.
Practicality beats purity.
Responsive is better than fast.
Anything added dilutes everything else.
Practicality beats purity.
It's not fully shipped until it's fast.
Practicality beats purity.
Speak like a human.
Encourage flow.
Favor focus over features.
Half measures are as bad as nothing at all.
Design for failure.
Mind your words, they are important.
Responsive is better than fast.
Avoid administrative distraction.
Responsive is better than fast.
Half measures are as bad as nothing at all.
Non-blocking is better than blocking.
Design for failure.
Favor focus over features.
Encourage flow.
Practicality beats purity.
Design for failure.
Responsive is better than fast.
Mind your words, they are important.
Design for failure.
Half measures are as bad as nothing at all.
Encourage flow.
Mind your words, they are important.
Design for failure.
Favor focus over features.
Favor focus over features.
Mind your words, they are important.
Half measures are as bad as nothing at all.
Non-blocking is better than blocking.
Favor focus over features.
Design for failure.
Mind your words, they are important.
Anything added dilutes everything else.
Speak like a human.
Favor focus over features.
Speak like a human.
Half measures are as bad as nothing at all.
It's not fully shipped until it's fast.
Mind your words, they are important.
Encourage flow.
Practicality beats purity.
Anything added dilutes everything else.
Responsive is better than fast.
Approachable is better than simple.
Non-blocking is better than blocking.
Design for failure.
Design for failure.
Encourage flow.
Responsive is better than fast.
Avoid administrative distraction.
Design for failure.
It's not fully shipped until it's fast.
Practicality beats purity.
Design for failure.
Responsive is better than fast.
Speak like a human.
Speak like a human.
Keep it logically awesome.
Keep it logically awesome.
Non-blocking is better than blocking.
Non-blocking is better than blocking.
Avoid administrative distraction.
Anything added dilutes everything else.
Approachable is better than simple.
Speak like a human.
Half measures are as bad as nothing at all.
Anything added dilutes everything else.
Approachable is better than simple.
Speak like a human.
Encourage flow.
Approachable is better than simple.
Favor focus over features.
Approachable is better than simple.
Speak like a human.
Mind your words, they are important.
Favor focus over features.
Responsive is better than fast.
Mind your words, they are important.
Speak like a human.
Responsive is better than fast.
Keep it logically awesome.
Speak like a human.
Favor focus over features.
Encourage flow.
Approachable is better than simple.
Practicality beats purity.
Mind your words, they are important.
Anything added dilutes everything else.
Half measures are as bad as nothing at all.
Design for failure.
Mind your words, they are important.
Design for failure.
Favor focus over features.
Non-blocking is better than blocking.
It's not fully shipped until it's fast.
Non-blocking is better than blocking.
Keep it logically awesome.
Non-blocking is better than blocking.
Responsive is better than fast.
Practicality beats purity.
Mind your words, they are important.
Design for failure.
Speak like a human.
Mind your words, they are important.
Responsive is better than fast.
Approachable is better than simple.
Responsive is better than fast.
Practicality beats purity.
Non-blocking is better than blocking.
Practicality beats purity.
Keep it logically awesome.
It's not fully shipped until it's fast.
Approachable is better than simple.
Design for failure.
Non-blocking is better than blocking.
Responsive is better than fast.
Encourage flow.
Favor focus over features.
Responsive is better than fast.
Non-blocking is better than blocking.
Design for failure.
Mind your words, they are important.
It's not fully shipped until it's fast.
Anything added dilutes everything else.
Avoid administrative distraction.
Mind your words, they are important.
Anything added dilutes everything else.
It's not fully shipped until it's fast.
Practicality beats purity.
Approachable is better than simple.
Half measures are as bad as nothing at all.
Favor focus over features.
Keep it logically awesome.
Practicality beats purity.
Anything added dilutes everything else.
Practicality beats purity.
Favor focus over features.
Encourage flow.
Anything added dilutes everything else.
Design for failure.
Avoid administrative distraction.
Encourage flow.
Responsive is better than fast.
Speak like a human.
Design for failure.
Favor focus over features.
Mind your words, they are important.
Responsive is better than fast.
Keep it logically awesome.
Favor focus over features.
Anything added dilutes everything else.
Design for failure.
Responsive is better than fast.
Practicality beats purity.
Half measures are as bad as nothing at all.
Design for failure.
Encourage flow.
Practicality beats purity.
Approachable is better than simple.
Responsive is better than fast.
Speak like a human.
Avoid administrative distraction.
Encourage flow.
Anything added dilutes everything else.
It's not fully shipped until it's fast.
Favor focus over features.
It's not fully shipped until it's fast.
Responsive is better than fast.
Practicality beats purity.
Design for failure.
Practicality beats purity.
Encourage flow.
Approachable is better than simple.
Encourage flow.
Half measures are as bad as nothing at all.
Avoid administrative distraction.
Practicality beats purity.
Approachable is better than simple.
Anything added dilutes everything else.
Anything added dilutes everything else.
Speak like a human.
It's not fully shipped until it's fast.
Anything added dilutes everything else.
Practicality beats purity.
Responsive is better than fast.
Avoid administrative distraction.
Anything added dilutes everything else.
Responsive is better than fast.
Non-blocking is better than blocking.
It's not fully shipped until it's fast.
Half measures are as bad as nothing at all.
Encourage flow.
Non-blocking is better than blocking.
Speak like a human.
Anything added dilutes everything else.
Avoid administrative distraction.
Anything added dilutes everything else.
Non-blocking is better than blocking.
Practicality beats purity.
Approachable is better than simple.
Half measures are as bad as nothing at all.
Practicality beats purity.
Responsive is better than fast.
Mind your words, they are important.
Design for failure.
Non-blocking is better than blocking.
Encourage flow.
Practicality beats purity.
Anything added dilutes everything else.
Encourage flow.
Non-blocking is better than blocking.
Keep it logically awesome.
Non-blocking is better than blocking.
Keep it logically awesome.
Responsive is better than fast.
Avoid administrative distraction.
Anything added dilutes everything else.
Approachable is better than simple.
Keep it logically awesome.
Half measures are as bad as nothing at all.
Avoid administrative distraction.
Design for failure.
Half measures are as bad as nothing at all.
It's not fully shipped until it's fast.
It's not fully shipped until it's fast.
Non-blocking is better than blocking.
Approachable is better than simple.
Avoid administrative distraction.
Encourage flow.
Practicality beats purity.
Half measures are as bad as nothing at all.
Anything added dilutes everything else.
Encourage flow.
Half measures are as bad as nothing at all.
Responsive is better than fast.
Non-blocking is better than blocking.
Responsive is better than fast.
Non-blocking is better than blocking.
Mind your words, they are important.
Favor focus over features.
Responsive is better than fast.
Speak like a human.
Keep it logically awesome.
Speak like a human.
Design for failure.
Non-blocking is better than blocking.
Approachable is better than simple.
Practicality beats purity.
Design for failure.
Avoid administrative distraction.
Avoid administrative distraction.
Approachable is better than simple.
It's not fully shipped until it's fast.
Encourage flow.
Responsive is better than fast.
Non-blocking is better than blocking.
Favor focus over features.
Favor focus over features.
Approachable is better than simple.
Anything added dilutes everything else.
Practicality beats purity.
Approachable is better than simple.
Responsive is better than fast.
Responsive is better than fast.
Practicality beats purity.
Favor focus over features.
Encourage flow.
Avoid administrative distraction.
Approachable is better than simple.
Practicality beats purity.
It's not fully shipped until it's fast.
Favor focus over features.
Keep it logically awesome.
Practicality beats purity.
Speak like a human.
Encourage flow.
Approachable is better than simple.
Approachable is better than simple.
Responsive is better than fast.
Responsive is better than fast.
Responsive is better than fast.
Non-blocking is better than blocking.
Design for failure.
Speak like a human.
Avoid administrative distraction.
Practicality beats purity.
Keep it logically awesome.
Responsive is better than fast.
Avoid administrative distraction.
Keep it logically awesome.
Avoid administrative distraction.
Mind your words, they are important.
Encourage flow.
Design for failure.
Favor focus over features.
Speak like a human.
Mind your words, they are important.
Speak like a human.
Encourage flow.
Favor focus over features.
Responsive is better than fast.
Responsive is better than fast.
Half measures are as bad as nothing at all.
Responsive is better than fast.
Anything added dilutes everything else.
Non-blocking is better than blocking.
Keep it logically awesome.
Non-blocking is better than blocking.
Design for failure.
Anything added dilutes everything else.
Half measures are as bad as nothing at all.
Practicality beats purity.
Approachable is better than simple.
Responsive is better than fast.
Design for failure.
Non-blocking is better than blocking.
It's not fully shipped until it's fast.
Half measures are as bad as nothing at all.
Responsive is better than fast.
Encourage flow.
Speak like a human.
Design for failure.
Keep it logically awesome.
Approachable is better than simple.
Favor focus over features.
It's not fully shipped until it's fast.
Mind your words, they are important.
Responsive is better than fast.
It's not fully shipped until it's fast.
Practicality beats purity.
Mind your words, they are important.
Encourage flow.
Keep it logically awesome.
Practicality beats purity.
Speak like a human.
Encourage flow.
Encourage flow.
Responsive is better than fast.
Encourage flow.
Mind your words, they are important.
It's not fully shipped until it's fast.
Half measures are as bad as nothing at all.
Responsive is better than fast.
Approachable is better than simple.
It's not fully shipped until it's fast.
Mind your words, they are important.
Keep it logically awesome.
Design for failure.
Approachable is better than simple.
Keep it logically awesome.
Approachable is better than simple.
Half measures are as bad as nothing at all.
Keep it logically awesome.
Mind your words, they are important.
Design for failure.
Practicality beats purity.
Responsive is better than fast.
Practicality beats purity.
Practicality beats purity.
Half measures are as bad as nothing at all.
It's not fully shipped until it's fast.
Practicality beats purity.
It's not fully shipped until it's fast.
Design for failure.
Approachable is better than simple.
Approachable is better than simple.
Design for failure.
Keep it logically awesome.
Keep it logically awesome.
Speak like a human.
Keep it logically awesome.
Keep it logically awesome.
Approachable is better than simple.
Keep it logically awesome.
Design for failure.
Avoid administrative distraction.
Encourage flow.
Mind your words, they are important.
It's not fully shipped until it's fast.
Half measures are as bad as nothing at all.
Mind your words, they are important.
Keep it logically awesome.
Encourage flow.
Practicality beats purity.
Avoid administrative distraction.
Design for failure.
Practicality beats purity.
Speak like a human.
It's not fully shipped until it's fast.
Favor focus over features.
Half measures are as bad as nothing at all.
Favor focus over features.
Practicality beats purity.
Anything added dilutes everything else.
Design for failure.
Responsive is better than fast.
Anything added dilutes everything else.
Speak like a human.
Avoid administrative distraction.
Keep it logically awesome.
Design for failure.
Non-blocking is better than blocking.
Non-blocking is better than blocking.
Mind your words, they are important.
It's not fully shipped until it's fast.
Favor focus over features.
Practicality beats purity.
Design for failure.
Responsive is better than fast.
Encourage flow.
Keep it logically awesome.
Design for failure.
Anything added dilutes everything else.
Practicality beats purity.
Speak like a human.
Avoid administrative distraction.
Approachable is better than simple.
Favor focus over features.
Approachable is better than simple.
Keep it logically awesome.
Favor focus over features.
Keep it logically awesome.
Design for failure.
Mind your words, they are important.
Avoid administrative distraction.
Anything added dilutes everything else.
Design for failure.
Avoid administrative distraction.
Encourage flow.
Speak like a human.
Mind your words, they are important.
Anything added dilutes everything else.
Practicality beats purity.
Design for failure.
Speak like a human.
Practicality beats purity.
Encourage flow.
Approachable is better than simple.
Design for failure.
Encourage flow.
Responsive is better than fast.
Speak like a human.
Non-blocking is better than blocking.
Half measures are as bad as nothing at all.
It's not fully shipped until it's fast.
Avoid administrative distraction.
Anything added dilutes everything else.
It's not fully shipped until it's fast.
Encourage flow.
It's not fully shipped until it's fast.
Favor focus over features.
Avoid administrative distraction.
Practicality beats purity.
Approachable is better than simple.
Half measures are as bad as nothing at all.
Practicality beats purity.
Responsive is better than fast.
Approachable is better than simple.
Approachable is better than simple.
Non-blocking is better than blocking.
Mind your words, they are important.
It's not fully shipped until it's fast.
Responsive is better than fast.
Encourage flow.
Approachable is better than simple.
Non-blocking is better than blocking.
Practicality beats purity.
It's not fully shipped until it's fast.
Half measures are as bad as nothing at all.
Favor focus over features.
Speak like a human.
Keep it logically awesome.
Encourage flow.
Design for failure.
Half measures are as bad as nothing at all.
Speak like a human.
Keep it logically awesome.
Encourage flow.
Half measures are as bad as nothing at all.
Keep it logically awesome.
Half measures are as bad as nothing at all.
Approachable is better than simple.
Design for failure.
Approachable is better than simple.
Design for failure.
Encourage flow.
Encourage flow.
Speak like a human.
Keep it logically awesome.
Non-blocking is better than blocking.
Encourage flow.
Anything added dilutes everything else.
Favor focus over features.
Practicality beats purity.
Mind your words, they are important.
Non-blocking is better than blocking.
Responsive is better than fast.
Encourage flow.
Responsive is better than fast.
Responsive is better than fast.
Anything added dilutes everything else.
Keep it logically awesome.
Half measures are as bad as nothing at all.
Mind your words, they are important.
Keep it logically awesome.
Avoid administrative distraction.
Favor focus over features.
Half measures are as bad as nothing at all.
Mind your words, they are important.
Mind your words, they are important.
Anything added dilutes everything else.
Non-blocking is better than blocking.
Practicality beats purity.
Anything added dilutes everything else.
Half measures are as bad as nothing at all.
It's not fully shipped until it's fast.
Encourage flow.
Anything added dilutes everything else.
Anything added dilutes everything else.
Favor focus over features.
Speak like a human.
Favor focus over features.
Encourage flow.
Keep it logically awesome.
Speak like a human.
Anything added dilutes everything else.
Approachable is better than simple.
Keep it logically awesome.
Mind your words, they are important.
Anything added dilutes everything else.
Mind your words, they are important.
Responsive is better than fast.
Practicality beats purity.
Half measures are as bad as nothing at all.
Encourage flow.
Keep it logically awesome.
Half measures are as bad as nothing at all.
Mind your words, they are important.
Favor focus over features.
Practicality beats purity.
Favor focus over features.
Responsive is better than fast.
Favor focus over features.
Approachable is better than simple.
Encourage flow.
Design for failure.
It's not fully shipped until it's fast.
Encourage flow.
Keep it logically awesome.
It's not fully shipped until it's fast.
Responsive is better than fast.
Speak like a human.
Avoid administrative distraction.
Practicality beats purity.
Non-blocking is better than blocking.
It's not fully shipped until it's fast.
Responsive is better than fast.
Speak like a human.
Approachable is better than simple.
Encourage flow.
Practicality beats purity.
Avoid administrative distraction.
Encourage flow.
Approachable is better than simple.
Keep it logically awesome.
Favor focus over features.
Keep it logically awesome.
Anything added dilutes everything else.
Anything added dilutes everything else.
Anything added dilutes everything else.
Encourage flow.
Responsive is better than fast.
Keep it logically awesome.
Keep it logically awesome.
Approachable is better than simple.
Practicality beats purity.
Half measures are as bad as nothing at all.
Mind your words, they are important.
Favor focus over features.
Keep it logically awesome.
Encourage flow.
Approachable is better than simple.
Anything added dilutes everything else.
Non-blocking is better than blocking.
Non-blocking is better than blocking.
Favor focus over features.
Keep it logically awesome.
Responsive is better than fast.
Avoid administrative distraction.
Avoid administrative distraction.
Avoid administrative distraction.
Avoid administrative distraction.
Practicality beats purity.
Favor focus over features.
It's not fully shipped until it's fast.
It's not fully shipped until it's fast.
Keep it logically awesome.
Mind your words, they are important.
Design for failure.
Design for failure.
Encourage flow.
Encourage flow.
Half measures are as bad as nothing at all.
Speak like a human.
Keep it logically awesome.
Non-blocking is better than blocking.
Encourage flow.
Approachable is better than simple.
Anything added dilutes everything else.
Keep it logically awesome.
Encourage flow.
Speak like a human.
Anything added dilutes everything else.
Favor focus over features.
Keep it logically awesome.
Mind your words, they are important.
Half measures are as bad as nothing at all.
Design for failure.
Avoid administrative distraction.
It's not fully shipped until it's fast.
Speak like a human.
Approachable is better than simple.
Speak like a human.
Encourage flow.
Non-blocking is better than blocking.
Approachable is better than simple.
Practicality beats purity.
Favor focus over features.
It's not fully shipped until it's fast.
Anything added dilutes everything else.
Avoid administrative distraction.
Keep it logically awesome.
Approachable is better than simple.
Mind your words, they are important.
Avoid administrative distraction.
Keep it logically awesome.
Approachable is better than simple.
Responsive is better than fast.
Avoid administrative distraction.
Practicality beats purity.
Mind your words, they are important.
Favor focus over features.
Keep it logically awesome.
Approachable is better than simple.
Keep it logically awesome.
Non-blocking is better than blocking.
Practicality beats purity.
Keep it logically awesome.
Half measures are as bad as nothing at all.
Favor focus over features.
Avoid administrative distraction.
Design for failure.
Responsive is better than fast.
Practicality beats purity.
Speak like a human.
Anything added dilutes everything else.
Mind your words, they are important.
It's not fully shipped until it's fast.
Responsive is better than fast.
Non-blocking is better than blocking.
Favor focus over features.
Avoid administrative distraction.
Encourage flow.
Design for failure.
Half measures are as bad as nothing at all.
Half measures are as bad as nothing at all.
Speak like a human.
Favor focus over features.
Design for failure.
Non-blocking is better than blocking.
Non-blocking is better than blocking.
Practicality beats purity.
Design for failure.
Avoid administrative distraction.
Design for failure.
Anything added dilutes everything else.
Speak like a human.
Encourage flow.
Avoid administrative distraction.
Keep it logically awesome.
Keep it logically awesome.
Anything added dilutes everything else.
Avoid administrative distraction.
Half measures are as bad as nothing at all.
Design for failure.
Anything added dilutes everything else.
It's not fully shipped until it's fast.
Speak like a human.
Anything added dilutes everything else.
It's not fully shipped until it's fast.
Favor focus over features.
Non-blocking is better than blocking.
Favor focus over features.
Approachable is better than simple.
Encourage flow.
Design for failure.
Anything added dilutes everything else.
Avoid administrative distraction.
Favor focus over features.
Anything added dilutes everything else.
Non-blocking is better than blocking.
It's not fully shipped until it's fast.
It's not fully shipped until it's fast.
Anything added dilutes everything else.
Favor focus over features.
Keep it logically awesome.
Keep it logically awesome.
Anything added dilutes everything else.
Keep it logically awesome.
Half measures are as bad as nothing at all.
Encourage flow.
Keep it logically awesome.
Non-blocking is better than blocking.
Avoid administrative distraction.
Keep it logically awesome.
Mind your words, they are important.
Non-blocking is better than blocking.
Favor focus over features.
Keep it logically awesome.
Non-blocking is better than blocking.
Avoid administrative distraction.
Avoid administrative distraction.
Speak like a human.
Avoid administrative distraction.
Speak like a human.
Encourage flow.
Avoid administrative distraction.
Responsive is better than fast.
Avoid administrative distraction.
Approachable is better than simple.
Practicality beats purity.
Half measures are as bad as nothing at all.
Favor focus over features.
Non-blocking is better than blocking.
Mind your words, they are important.
Speak like a human.
Favor focus over features.
Encourage flow.
Favor focus over features.
Avoid administrative distraction.
Design for failure.
Anything added dilutes everything else.
Non-blocking is better than blocking.
It's not fully shipped until it's fast.
Speak like a human.
Encourage flow.
Encourage flow.
It's not fully shipped until it's fast.
Mind your words, they are important.
Non-blocking is better than blocking.
Non-blocking is better than blocking.
Anything added dilutes everything else.
Approachable is better than simple.
Avoid administrative distraction.
It's not fully shipped until it's fast.
Approachable is better than simple.
Anything added dilutes everything else.
Favor focus over features.
Non-blocking is better than blocking.
Keep it logically awesome.
Favor focus over features.
Design for failure.
Design for failure.
Speak like a human.
Encourage flow.
Practicality beats purity.
Half measures are as bad as nothing at all.
Keep it logically awesome.
Keep it logically awesome.
Anything added dilutes everything else.
Mind your words, they are important.
Mind your words, they are important.
Favor focus over features.
Responsive is better than fast.
Non-blocking is better than blocking.
Anything added dilutes everything else.
Encourage flow.
Encourage flow.
Encourage flow.
Keep it logically awesome.
Approachable is better than simple.
Approachable is better than simple.
Speak like a human.
Approachable is better than simple.
Responsive is better than fast.
Approachable is better than simple.
Encourage flow.
Practicality beats purity.
Design for failure.
Approachable is better than simple.
Encourage flow.
Encourage flow.
Approachable is better than simple.
Approachable is better than simple.
It's not fully shipped until it's fast.
Keep it logically awesome.
Practicality beats purity.
Practicality beats purity.
Responsive is better than fast.
Non-blocking is better than blocking.
Practicality beats purity.
Speak like a human.
It's not fully shipped until it's fast.
Speak like a human.
Design for failure.
Practicality beats purity.
Half measures are as bad as nothing at all.
Anything added dilutes everything else.
Half measures are as bad as nothing at all.
It's not fully shipped until it's fast.
Anything added dilutes everything else.
Mind your words, they are important.
Anything added dilutes everything else.
Responsive is better than fast.
Anything added dilutes everything else.
Encourage flow.
Avoid administrative distraction.
Keep it logically awesome.
Keep it logically awesome.
Responsive is better than fast.
Encourage flow.
Favor focus over features.
Non-blocking is better than blocking.
Favor focus over features.
It's not fully shipped until it's fast.
It's not fully shipped until it's fast.
Encourage flow.
Encourage flow.
Responsive is better than fast.
Responsive is better than fast.
Speak like a human.
Avoid administrative distraction.
Favor focus over features.
Design for failure.
Encourage flow.
Keep it logically awesome.
Practicality beats purity.
Approachable is better than simple.
It's not fully shipped until it's fast.
Half measures are as bad as nothing at all.
Half measures are as bad as nothing at all.
Encourage flow.
Practicality beats purity.
Favor focus over features.
Favor focus over features.
Practicality beats purity.
Practicality beats purity.
Design for failure.
It's not fully shipped until it's fast.
Keep it logically awesome.
Half measures are as bad as nothing at all.
Anything added dilutes everything else.
Favor focus over features.
Anything added dilutes everything else.
Mind your words, they are important.
Favor focus over features.
Anything added dilutes everything else.
Practicality beats purity.
It's not fully shipped until it's fast.
Design for failure.
Non-blocking is better than blocking.
Avoid administrative distraction.
Favor focus over features.
Avoid administrative distraction.
Avoid administrative distraction.
Approachable is better than simple.
Keep it logically awesome.
Avoid administrative distraction.
Practicality beats purity.
It's not fully shipped until it's fast.
Mind your words, they are important.
Design for failure.
Keep it logically awesome.
Non-blocking is better than blocking.
Half measures are as bad as nothing at all.
Design for failure.
Encourage flow.
Avoid administrative distraction.
Speak like a human.
Favor focus over features.
It's not fully shipped until it's fast.
Keep it logically awesome.
Encourage flow.
It's not fully shipped until it's fast.
Responsive is better than fast.
Speak like a human.
Mind your words, they are important.
Avoid administrative distraction.
It's not fully shipped until it's fast.
Favor focus over features.
Practicality beats purity.
Speak like a human.
Mind your words, they are important.
Avoid administrative distraction.
Half measures are as bad as nothing at all.
Approachable is better than simple.
Avoid administrative distraction.
Avoid administrative distraction.
Speak like a human.
It's not fully shipped until it's fast.
Anything added dilutes everything else.
Responsive is better than fast.
Half measures are as bad as nothing at all.
Half measures are as bad as nothing at all.
Mind your words, they are important.
Mind your words, they are important.
Practicality beats purity.
Approachable is better than simple.
Practicality beats purity.
Avoid administrative distraction.
Speak like a human.
Mind your words, they are important.
Favor focus over features.
Non-blocking is better than blocking.
Non-blocking is better than blocking.
Responsive is better than fast.
Design for failure.
Half measures are as bad as nothing at all.
Mind your words, they are important.
Favor focus over features.
Favor focus over features.
Speak like a human.
Speak like a human.
It's not fully shipped until it's fast.
Design for failure.
Speak like a human.
Favor focus over features.
Approachable is better than simple.
Avoid administrative distraction.
Favor focus over features.
Non-blocking is better than blocking.
Keep it logically awesome.
Favor focus over features.
Encourage flow.
Keep it logically awesome.
Encourage flow.
Encourage flow.
Practicality beats purity.
Half measures are as bad as nothing at all.
Keep it logically awesome.
It's not fully shipped until it's fast.
Responsive is better than fast.
Mind your words, they are important.
Keep it logically awesome.
Avoid administrative distraction.
Responsive is better than fast.
Non-blocking is better than blocking.
Encourage flow.
Approachable is better than simple.
Anything added dilutes everything else.
Encourage flow.
Mind your words, they are important.
Non-blocking is better than blocking.
Encourage flow.
Keep it logically awesome.
Non-blocking is better than blocking.
It's not fully shipped until it's fast.
Mind your words, they are important.
Favor focus over features.
Keep it logically awesome.
Mind your words, they are important.
It's not fully shipped until it's fast.
It's not fully shipped until it's fast.
Speak like a human.
Avoid administrative distraction.
Design for failure.
Responsive is better than fast.
Avoid administrative distraction.
Approachable is better than simple.
Practicality beats purity.
Approachable is better than simple.
Encourage flow.
It's not fully shipped until it's fast.
Responsive is better than fast.
Practicality beats purity.
Responsive is better than fast.
Practicality beats purity.
Design for failure.
Favor focus over features.
Responsive is better than fast.
Non-blocking is better than blocking.
Mind your words, they are important.
Responsive is better than fast.
Keep it logically awesome.
Practicality beats purity.
Design for failure.
Half measures are as bad as nothing at all.
Keep it logically awesome.
Approachable is better than simple.
Design for failure.
Responsive is better than fast.
Design for failure.
Design for failure.
Anything added dilutes everything else.
Favor focus over features.
Avoid administrative distraction.
Practicality beats purity.
Responsive is better than fast.
Encourage flow.
Encourage flow.
Anything added dilutes everything else.
Practicality beats purity.
Design for failure.
Approachable is better than simple.
Practicality beats purity.
Half measures are as bad as nothing at all.
Design for failure.
Mind your words, they are important.
Anything added dilutes everything else.
Keep it logically awesome.
Non-blocking is better than blocking.
Keep it logically awesome.
Avoid administrative distraction.
Avoid administrative distraction.
Keep it logically awesome.
Approachable is better than simple.
Mind your words, they are important.
Avoid administrative distraction.
Non-blocking is better than blocking.
Speak like a human.
It's not fully shipped until it's fast.
Anything added dilutes everything else.
Favor focus over features.
Keep it logically awesome.
Non-blocking is better than blocking.
Avoid administrative distraction.
Keep it logically awesome.
Anything added dilutes everything else.
Keep it logically awesome.
It's not fully shipped until it's fast.
Favor focus over features.
Half measures are as bad as nothing at all.
Encourage flow.
Avoid administrative distraction.
Approachable is better than simple.
Design for failure.
Approachable is better than simple.
Favor focus over features.
Mind your words, they are important.
Practicality beats purity.
Half measures are as bad as nothing at all.
Favor focus over features.
Mind your words, they are important.
Design for failure.
Avoid administrative distraction.
Non-blocking is better than blocking.
Practicality beats purity.
Design for failure.
Favor focus over features.
Responsive is better than fast.
Non-blocking is better than blocking.
Favor focus over features.
Half measures are as bad as nothing at all.
Half measures are as bad as nothing at all.
Encourage flow.
Practicality beats purity.
Avoid administrative distraction.
Encourage flow.
Responsive is better than fast.
Practicality beats purity.
Encourage flow.
Non-blocking is better than blocking.
Approachable is better than simple.
Encourage flow.
Encourage flow.
Speak like a human.
Half measures are as bad as nothing at all.
Encourage flow.
Approachable is better than simple.
Encourage flow.
Non-blocking is better than blocking.
Keep it logically awesome.
Responsive is better than fast.
Speak like a human.
Approachable is better than simple.
Half measures are as bad as nothing at all.
Mind your words, they are important.
Responsive is better than fast.
Mind your words, they are important.
Non-blocking is better than blocking.
Approachable is better than simple.
Practicality beats purity.
Design for failure.
Responsive is better than fast.
Mind your words, they are important.
Responsive is better than fast.
Design for failure.
Half measures are as bad as nothing at all.
Anything added dilutes everything else.
Keep it logically awesome.
Encourage flow.
Approachable is better than simple.
Speak like a human.
Practicality beats purity.
Design for failure.
Encourage flow.
Design for failure.
Keep it logically awesome.
Favor focus over features.
Practicality beats purity.
Favor focus over features.
Anything added dilutes everything else.
Favor focus over features.
Design for failure.
It's not fully shipped until it's fast.
Encourage flow.
Anything added dilutes everything else.
Anything added dilutes everything else.
Speak like a human.
Non-blocking is better than blocking.
Anything added dilutes everything else.
Responsive is better than fast.
Design for failure.
Speak like a human.
Anything added dilutes everything else.
It's not fully shipped until it's fast.
It's not fully shipped until it's fast.
Design for failure.
Responsive is better than fast.
Design for failure.
Responsive is better than fast.
Anything added dilutes everything else.
Avoid administrative distraction.
Mind your words, they are important.
Avoid administrative distraction.
Approachable is better than simple.
Keep it logically awesome.
Approachable is better than simple.
Design for failure.
Keep it logically awesome.
Non-blocking is better than blocking.
Responsive is better than fast.
Half measures are as bad as nothing at all.
Encourage flow.
Anything added dilutes everything else.
Mind your words, they are important.
Non-blocking is better than blocking.
Encourage flow.
Non-blocking is better than blocking.
Speak like a human.
Design for failure.
Non-blocking is better than blocking.
Half measures are as bad as nothing at all.
Practicality beats purity.
Design for failure.
Encourage flow.
Non-blocking is better than blocking.
Avoid administrative distraction.
Avoid administrative distraction.
Favor focus over features.
Mind your words, they are important.
Non-blocking is better than blocking.
Avoid administrative distraction.
Encourage flow.
Mind your words, they are important.
Practicality beats purity.
Non-blocking is better than blocking.
It's not fully shipped until it's fast.
It's not fully shipped until it's fast.
Favor focus over features.
Speak like a human.
It's not fully shipped until it's fast.
Design for failure.
Keep it logically awesome.
Non-blocking is better than blocking.
Responsive is better than fast.
Responsive is better than fast.
Non-blocking is better than blocking.
Avoid administrative distraction.
Favor focus over features.
Design for failure.
Encourage flow.
Encourage flow.
Favor focus over features.
Practicality beats purity.
Design for failure.
Mind your words, they are important.
Encourage flow.
Avoid administrative distraction.
It's not fully shipped until it's fast.
Encourage flow.
Half measures are as bad as nothing at all.
Keep it logically awesome.
Keep it logically awesome.
Design for failure.
Anything added dilutes everything else.
Responsive is better than fast.
Encourage flow.
Half measures are as bad as nothing at all.
Mind your words, they are important.
Encourage flow.
It's not fully shipped until it's fast.
Avoid administrative distraction.
Anything added dilutes everything else.
Practicality beats purity.
Keep it logically awesome.
Practicality beats purity.
Design for failure.
Responsive is better than fast.
It's not fully shipped until it's fast.
Favor focus over features.
Keep it logically awesome.
Speak like a human.
Anything added dilutes everything else.
Approachable is better than simple.
Responsive is better than fast.
Half measures are as bad as nothing at all.
Non-blocking is better than blocking.
Favor focus over features.
Keep it logically awesome.
Practicality beats purity.
Avoid administrative distraction.
Mind your words, they are important.
Design for failure.
Mind your words, they are important.
Encourage flow.
Non-blocking is better than blocking.
Favor focus over features.
Favor focus over features.
Mind your words, they are important.
Responsive is better than fast.
Keep it logically awesome.
Design for failure.
Responsive is better than fast.
Keep it logically awesome.
Encourage flow.
Speak like a human.
Mind your words, they are important.
Practicality beats purity.
Favor focus over features.
Design for failure.
Design for failure.
Approachable is better than simple.
Responsive is better than fast.
Speak like a human.
Favor focus over features.
Half measures are as bad as nothing at all.
Anything added dilutes everything else.
Design for failure.
Keep it logically awesome.
It's not fully shipped until it's fast.
It's not fully shipped until it's fast.
Anything added dilutes everything else.
Non-blocking is better than blocking.
Keep it logically awesome.
Speak like a human.
Practicality beats purity.
Favor focus over features.
Half measures are as bad as nothing at all.
Avoid administrative distraction.
Speak like a human.
It's not fully shipped until it's fast.
It's not fully shipped until it's fast.
Approachable is better than simple.
Design for failure.
Mind your words, they are important.
Anything added dilutes everything else.
Favor focus over features.
It's not fully shipped until it's fast.
Practicality beats purity.
Avoid administrative distraction.
Speak like a human.
Responsive is better than fast.
Encourage flow.
Responsive is better than fast.
It's not fully shipped until it's fast.
Design for failure.
Keep it logically awesome.
Favor focus over features.
Approachable is better than simple.
Design for failure.
Anything added dilutes everything else.
Approachable is better than simple.
Mind your words, they are important.
Speak like a human.
Non-blocking is better than blocking.
Non-blocking is better than blocking.
Encourage flow.
Responsive is better than fast.
Mind your words, they are important.
Practicality beats purity.
Favor focus over features.
Speak like a human.
Half measures are as bad as nothing at all.
Anything added dilutes everything else.
Encourage flow.
Anything added dilutes everything else.
Anything added dilutes everything else.
Non-blocking is better than blocking.
Avoid administrative distraction.
Speak like a human.
Practicality beats purity.
Encourage flow.
Practicality beats purity.
It's not fully shipped until it's fast.
Responsive is better than fast.
Design for failure.
Non-blocking is better than blocking.
Responsive is better than fast.
Responsive is better than fast.
Practicality beats purity.
Anything added dilutes everything else.
Non-blocking is better than blocking.
Responsive is better than fast.
Favor focus over features.
Mind your words, they are important.
Design for failure.
Mind your words, they are important.
Practicality beats purity.
Favor focus over features.
Favor focus over features.
Mind your words, they are important.
Responsive is better than fast.
Speak like a human.
Design for failure.
Non-blocking is better than blocking.
Responsive is better than fast.
Mind your words, they are important.
Avoid administrative distraction.
Design for failure.
Half measures are as bad as nothing at all.
Avoid administrative distraction.
Practicality beats purity.
Design for failure.
It's not fully shipped until it's fast.
Design for failure.
Anything added dilutes everything else.
Encourage flow.
Approachable is better than simple.
Favor focus over features.
Design for failure.
Mind your words, they are important.
Keep it logically awesome.
Practicality beats purity.
Approachable is better than simple.
Design for failure.
Design for failure.
Approachable is better than simple.
Encourage flow.
Favor focus over features.
Practicality beats purity.
Favor focus over features.
Responsive is better than fast.
Anything added dilutes everything else.
Approachable is better than simple.
Avoid administrative distraction.
Half measures are as bad as nothing at all.
Encourage flow.
It's not fully shipped until it's fast.
Favor focus over features.
Practicality beats purity.
Half measures are as bad as nothing at all.
Mind your words, they are important.
Mind your words, they are important.
Approachable is better than simple.
Half measures are as bad as nothing at all.
It's not fully shipped until it's fast.
Practicality beats purity.
Mind your words, they are important.
Favor focus over features.
Keep it logically awesome.
Speak like a human.
Keep it logically awesome.
Mind your words, they are important.
Anything added dilutes everything else.
Design for failure.
Non-blocking is better than blocking.
Half measures are as bad as nothing at all.
Anything added dilutes everything else.
Responsive is better than fast.
It's not fully shipped until it's fast.
Encourage flow.
Half measures are as bad as nothing at all.
Anything added dilutes everything else.
Approachable is better than simple.
Practicality beats purity.
Design for failure.
Anything added dilutes everything else.
Responsive is better than fast.
Non-blocking is better than blocking.
It's not fully shipped until it's fast.
Mind your words, they are important.
Non-blocking is better than blocking.
Avoid administrative distraction.
Anything added dilutes everything else.
Approachable is better than simple.
It's not fully shipped until it's fast.
It's not fully shipped until it's fast.
Favor focus over features.
Mind your words, they are important.
It's not fully shipped until it's fast.
Keep it logically awesome.
Mind your words, they are important.
Half measures are as bad as nothing at all.
Half measures are as bad as nothing at all.
Speak like a human.
Encourage flow.
Mind your words, they are important.
Favor focus over features.
Practicality beats purity.
Avoid administrative distraction.
Mind your words, they are important.
Non-blocking is better than blocking.
Encourage flow.
Keep it logically awesome.
Responsive is better than fast.
Anything added dilutes everything else.
Favor focus over features.
Encourage flow.
Design for failure.
Keep it logically awesome.
Encourage flow.
Non-blocking is better than blocking.
Keep it logically awesome.
Half measures are as bad as nothing at all.
Responsive is better than fast.
Practicality beats purity.
Anything added dilutes everything else.
Responsive is better than fast.
Approachable is better than simple.
Mind your words, they are important.
It's not fully shipped until it's fast.
Avoid administrative distraction.
Half measures are as bad as nothing at all.
Approachable is better than simple.
Favor focus over features.
Practicality beats purity.
Avoid administrative distraction.
Anything added dilutes everything else.
Avoid administrative distraction.
Half measures are as bad as nothing at all.
Speak like a human.
Encourage flow.
Non-blocking is better than blocking.
Encourage flow.
Favor focus over features.
Practicality beats purity.
Approachable is better than simple.
Approachable is better than simple.
Favor focus over features.
Non-blocking is better than blocking.
Anything added dilutes everything else.
Approachable is better than simple.
Anything added dilutes everything else.
It's not fully shipped until it's fast.
Design for failure.
Approachable is better than simple.
Design for failure.
Half measures are as bad as nothing at all.
Encourage flow.
Responsive is better than fast.
Responsive is better than fast.
Keep it logically awesome.
Avoid administrative distraction.
Approachable is better than simple.
Mind your words, they are important.
Speak like a human.
Responsive is better than fast.
Keep it logically awesome.
Keep it logically awesome.
Encourage flow.
Speak like a human.
Non-blocking is better than blocking.
Responsive is better than fast.
It's not fully shipped until it's fast.
Responsive is better than fast.
Favor focus over features.
Approachable is better than simple.
Speak like a human.
Responsive is better than fast.
Mind your words, they are important.
Mind your words, they are important.
It's not fully shipped until it's fast.
Design for failure.
Speak like a human.
Half measures are as bad as nothing at all.
Approachable is better than simple.
Mind your words, they are important.
Keep it logically awesome.
Keep it logically awesome.
Encourage flow.
Speak like a human.
Speak like a human.
Avoid administrative distraction.
Mind your words, they are important.
Non-blocking is better than blocking.
Practicality beats purity.
Favor focus over features.
Approachable is better than simple.
Favor focus over features.
Avoid administrative distraction.
Responsive is better than fast.
Design for failure.
It's not fully shipped until it's fast.
Keep it logically awesome.
Responsive is better than fast.
Keep it logically awesome.
Mind your words, they are important.
Responsive is better than fast.
Favor focus over features.
Mind your words, they are important.
Design for failure.
Responsive is better than fast.
Speak like a human.
Responsive is better than fast.
Speak like a human.
Anything added dilutes everything else.
Non-blocking is better than blocking.
Favor focus over features.
Practicality beats purity.
Speak like a human.
Avoid administrative distraction.
Favor focus over features.
Keep it logically awesome.
Keep it logically awesome.
Approachable is better than simple.
Encourage flow.
Avoid administrative distraction.
Approachable is better than simple.
Practicality beats purity.
Keep it logically awesome.
Keep it logically awesome.
Keep it logically awesome.
Speak like a human.
Mind your words, they are important.
Design for failure.
Non-blocking is better than blocking.
Responsive is better than fast.
Practicality beats purity.
Non-blocking is better than blocking.
Mind your words, they are important.
Non-blocking is better than blocking.
Mind your words, they are important.
Design for failure.
Encourage flow.
Avoid administrative distraction.
Approachable is better than simple.
Practicality beats purity.
Speak like a human.
Anything added dilutes everything else.
Half measures are as bad as nothing at all.
Approachable is better than simple.
Favor focus over features.
Speak like a human.
Responsive is better than fast.
Keep it logically awesome.
Half measures are as bad as nothing at all.
Mind your words, they are important.
Favor focus over features.
Encourage flow.
Approachable is better than simple.
Favor focus over features.
Practicality beats purity.
Speak like a human.
It's not fully shipped until it's fast.
Mind your words, they are important.
Practicality beats purity.
Approachable is better than simple.
Speak like a human.
Practicality beats purity.
Favor focus over features.
Responsive is better than fast.
Approachable is better than simple.
Speak like a human.
Non-blocking is better than blocking.
Half measures are as bad as nothing at all.
Design for failure.
Anything added dilutes everything else.
It's not fully shipped until it's fast.
Approachable is better than simple.
It's not fully shipped until it's fast.
Speak like a human.
Favor focus over features.
Anything added dilutes everything else.
Anything added dilutes everything else.
It's not fully shipped until it's fast.
Approachable is better than simple.
Anything added dilutes everything else.
Design for failure.
It's not fully shipped until it's fast.
Avoid administrative distraction.
Practicality beats purity.
Speak like a human.
Keep it logically awesome.
Encourage flow.
Avoid administrative distraction.
Mind your words, they are important.
Encourage flow.
Responsive is better than fast.
Encourage flow.
Anything added dilutes everything else.
Anything added dilutes everything else.
Half measures are as bad as nothing at all.
It's not fully shipped until it's fast.
Responsive is better than fast.
Favor focus over features.
Favor focus over features.
Practicality beats purity.
Practicality beats purity.
Speak like a human.
Design for failure.
It's not fully shipped until it's fast.
Design for failure.
Approachable is better than simple.
Keep it logically awesome.
It's not fully shipped until it's fast.
Mind your words, they are important.
Practicality beats purity.
Anything added dilutes everything else.
Design for failure.
Anything added dilutes everything else.
Half measures are as bad as nothing at all.
Avoid administrative distraction.
Design for failure.
Design for failure.
Encourage flow.
Half measures are as bad as nothing at all.
Keep it logically awesome.
Keep it logically awesome.
Favor focus over features.
Keep it logically awesome.
Design for failure.
Responsive is better than fast.
Anything added dilutes everything else.
Mind your words, they are important.
Favor focus over features.
Anything added dilutes everything else.
Non-blocking is better than blocking.
Mind your words, they are important.
Practicality beats purity.
Keep it logically awesome.
Encourage flow.
Encourage flow.
Non-blocking is better than blocking.
Speak like a human.
Design for failure.
Half measures are as bad as nothing at all.
Anything added dilutes everything else.
Speak like a human.
Favor focus over features.
Avoid administrative distraction.
Encourage flow.
Design for failure.
It's not fully shipped until it's fast.
Half measures are as bad as nothing at all.
Design for failure.
Anything added dilutes everything else.
Mind your words, they are important.
Speak like a human.
Half measures are as bad as nothing at all.
Practicality beats purity.
Responsive is better than fast.
Anything added dilutes everything else.
Half measures are as bad as nothing at all.
Practicality beats purity.
Approachable is better than simple.
Encourage flow.
Keep it logically awesome.
It's not fully shipped until it's fast.
Keep it logically awesome.
Speak like a human.
Mind your words, they are important.
Responsive is better than fast.
Approachable is better than simple.
Speak like a human.
Design for failure.
Anything added dilutes everything else.
Keep it logically awesome.
Non-blocking is better than blocking.
Avoid administrative distraction.
Encourage flow.
Design for failure.
Mind your words, they are important.
Design for failure.
Favor focus over features.
Practicality beats purity.
Approachable is better than simple.
Non-blocking is better than blocking.
Non-blocking is better than blocking.
Keep it logically awesome.
Encourage flow.
Keep it logically awesome.
Half measures are as bad as nothing at all.
Speak like a human.
Encourage flow.
It's not fully shipped until it's fast.
Speak like a human.
Half measures are as bad as nothing at all.
Encourage flow.
Design for failure.
Keep it logically awesome.
Keep it logically awesome.
Favor focus over features.
Practicality beats purity.
Half measures are as bad as nothing at all.
Favor focus over features.
Non-blocking is better than blocking.
Mind your words, they are important.
Approachable is better than simple.
Approachable is better than simple.
Half measures are as bad as nothing at all.
Approachable is better than simple.
Speak like a human.
Non-blocking is better than blocking.
It's not fully shipped until it's fast.
It's not fully shipped until it's fast.
It's not fully shipped until it's fast.
Keep it logically awesome.
Practicality beats purity.
It's not fully shipped until it's fast.
Favor focus over features.
Avoid administrative distraction.
Avoid administrative distraction.
Speak like a human.
Approachable is better than simple.
Encourage flow.
Anything added dilutes everything else.
Speak like a human.
Favor focus over features.
Practicality beats purity.
It's not fully shipped until it's fast.
Responsive is better than fast.
Practicality beats purity.
Approachable is better than simple.
Anything added dilutes everything else.
Anything added dilutes everything else.
Keep it logically awesome.
Anything added dilutes everything else.
Half measures are as bad as nothing at all.
Design for failure.
Practicality beats purity.
Half measures are as bad as nothing at all.
Design for failure.
Practicality beats purity.
Half measures are as bad as nothing at all.
Keep it logically awesome.
Half measures are as bad as nothing at all.
Speak like a human.
It's not fully shipped until it's fast.
It's not fully shipped until it's fast.
Half measures are as bad as nothing at all.
Non-blocking is better than blocking.
Mind your words, they are important.
Anything added dilutes everything else.
Responsive is better than fast.
Encourage flow.
Favor focus over features.
Keep it logically awesome.
Keep it logically awesome.
Favor focus over features.
Avoid administrative distraction.
Approachable is better than simple.
Practicality beats purity.
Speak like a human.
It's not fully shipped until it's fast.
Favor focus over features.
Anything added dilutes everything else.
Keep it logically awesome.
Half measures are as bad as nothing at all.
Non-blocking is better than blocking.
It's not fully shipped until it's fast.
Speak like a human.
Half measures are as bad as nothing at all.
It's not fully shipped until it's fast.
Design for failure.
Favor focus over features.
Encourage flow.
Encourage flow.
Encourage flow.
Non-blocking is better than blocking.
Avoid administrative distraction.
Mind your words, they are important.
It's not fully shipped until it's fast.
Non-blocking is better than blocking.
Non-blocking is better than blocking.
Half measures are as bad as nothing at all.
It's not fully shipped until it's fast.
Approachable is better than simple.
Approachable is better than simple.
Encourage flow.
Encourage flow.
Practicality beats purity.
Non-blocking is better than blocking.
Mind your words, they are important.
It's not fully shipped until it's fast.
Encourage flow.
Responsive is better than fast.
Responsive is better than fast.
Encourage flow.
Practicality beats purity.
Speak like a human.
Responsive is better than fast.
Keep it logically awesome.
Keep it logically awesome.
Avoid administrative distraction.
Avoid administrative distraction.
Design for failure.
Anything added dilutes everything else.
Avoid administrative distraction.
Mind your words, they are important.
Speak like a human.
Keep it logically awesome.
Approachable is better than simple.
It's not fully shipped until it's fast.
Responsive is better than fast.
Encourage flow.
Design for failure.
Approachable is better than simple.
Half measures are as bad as nothing at all.
Speak like a human.
Practicality beats purity.
Design for failure.
Approachable is better than simple.
Half measures are as bad as nothing at all.
Anything added dilutes everything else.
Approachable is better than simple.
Favor focus over features.
Practicality beats purity.
Anything added dilutes everything else.
Speak like a human.
Mind your words, they are important.
Avoid administrative distraction.
It's not fully shipped until it's fast.
Approachable is better than simple.
Practicality beats purity.
It's not fully shipped until it's fast.
Non-blocking is better than blocking.
Half measures are as bad as nothing at all.
Keep it logically awesome.
Half measures are as bad as nothing at all.
Mind your words, they are important.
Half measures are as bad as nothing at all.
Responsive is better than fast.
Non-blocking is better than blocking.
Anything added dilutes everything else.
Design for failure.
Encourage flow.
Favor focus over features.
Encourage flow.
Encourage flow.
Approachable is better than simple.
Avoid administrative distraction.
Design for failure.
Favor focus over features.
Half measures are as bad as nothing at all.
Non-blocking is better than blocking.
Practicality beats purity.
Encourage flow.
Practicality beats purity.
Anything added dilutes everything else.
Non-blocking is better than blocking.
Keep it logically awesome.
Keep it logically awesome.
Design for failure.
Favor focus over features.
Encourage flow.
Half measures are as bad as nothing at all.
Half measures are as bad as nothing at all.
Favor focus over features.
Half measures are as bad as nothing at all.
Mind your words, they are important.
Keep it logically awesome.
Anything added dilutes everything else.
Keep it logically awesome.
Encourage flow.
Encourage flow.
Avoid administrative distraction.
Practicality beats purity.
Keep it logically awesome.
Non-blocking is better than blocking.
Half measures are as bad as nothing at all.
Speak like a human.
Keep it logically awesome.
Anything added dilutes everything else.
Speak like a human.
Keep it logically awesome.
Encourage flow.
Avoid administrative distraction.
Approachable is better than simple.
Non-blocking is better than blocking.
Practicality beats purity.
Favor focus over features.
Keep it logically awesome.
Keep it logically awesome.
Design for failure.
Mind your words, they are important.
Responsive is better than fast.
Responsive is better than fast.
Favor focus over features.
Speak like a human.
Mind your words, they are important.
It's not fully shipped until it's fast.
Design for failure.
Approachable is better than simple.
Approachable is better than simple.
Non-blocking is better than blocking.
Design for failure.
Practicality beats purity.
Anything added dilutes everything else.
Favor focus over features.
Encourage flow.
It's not fully shipped until it's fast.
Practicality beats purity.
Approachable is better than simple.
Mind your words, they are important.
Favor focus over features.
Encourage flow.
Avoid administrative distraction.
Keep it logically awesome.
Mind your words, they are important.
Responsive is better than fast.
Half measures are as bad as nothing at all.
Encourage flow.
Favor focus over features.
Favor focus over features.
Mind your words, they are important.
Anything added dilutes everything else.
Avoid administrative distraction.
Encourage flow.
Non-blocking is better than blocking.
It's not fully shipped until it's fast.
Speak like a human.
Speak like a human.
Encourage flow.
Anything added dilutes everything else.
It's not fully shipped until it's fast.
Design for failure.
Responsive is better than fast.
Half measures are as bad as nothing at all.
Non-blocking is better than blocking.
Practicality beats purity.
Responsive is better than fast.
Anything added dilutes everything else.
Keep it logically awesome.
Encourage flow.
Practicality beats purity.
Responsive is better than fast.
Practicality beats purity.
Design for failure.
Favor focus over features.
Practicality beats purity.
Approachable is better than simple.
Encourage flow.
Avoid administrative distraction.
Responsive is better than fast.
Practicality beats purity.
It's not fully shipped until it's fast.
Non-blocking is better than blocking.
Approachable is better than simple.
Non-blocking is better than blocking.
Favor focus over features.
Approachable is better than simple.
Avoid administrative distraction.
Half measures are as bad as nothing at all.
Mind your words, they are important.
Encourage flow.
Mind your words, they are important.
Non-blocking is better than blocking.
Approachable is better than simple.
It's not fully shipped until it's fast.
Anything added dilutes everything else.
Avoid administrative distraction.
Half measures are as bad as nothing at all.
Practicality beats purity.
Keep it logically awesome.
Mind your words, they are important.
It's not fully shipped until it's fast.
Approachable is better than simple.
Speak like a human.
Mind your words, they are important.
Favor focus over features.
Favor focus over features.
Non-blocking is better than blocking.
Approachable is better than simple.
Design for failure.
Approachable is better than simple.
Mind your words, they are important.
Keep it logically awesome.
Keep it logically awesome.
Practicality beats purity.
Practicality beats purity.
Approachable is better than simple.
Mind your words, they are important.
Speak like a human.
Mind your words, they are important.
It's not fully shipped until it's fast.
Design for failure.
Anything added dilutes everything else.
Mind your words, they are important.
Anything added dilutes everything else.
It's not fully shipped until it's fast.
Mind your words, they are important.
Anything added dilutes everything else.
Encourage flow.
Approachable is better than simple.
Encourage flow.
Mind your words, they are important.
Favor focus over features.
Design for failure.
Half measures are as bad as nothing at all.
Encourage flow.
Approachable is better than simple.
It's not fully shipped until it's fast.
Practicality beats purity.
Mind your words, they are important.
Mind your words, they are important.
Favor focus over features.
Speak like a human.
Favor focus over features.
Design for failure.
Design for failure.
Speak like a human.
Speak like a human.
Design for failure.
Speak like a human.
Anything added dilutes everything else.
Avoid administrative distraction.
Avoid administrative distraction.
Half measures are as bad as nothing at all.
Non-blocking is better than blocking.
Non-blocking is better than blocking.
Design for failure.
It's not fully shipped until it's fast.
It's not fully shipped until it's fast.
Speak like a human.
Responsive is better than fast.
Encourage flow.
Approachable is better than simple.
Encourage flow.
Favor focus over features.
Design for failure.
It's not fully shipped until it's fast.
Non-blocking is better than blocking.
Non-blocking is better than blocking.
Encourage flow.
Keep it logically awesome.
Favor focus over features.
Half measures are as bad as nothing at all.
Speak like a human.
Encourage flow.
Anything added dilutes everything else.
Speak like a human.
Practicality beats purity.
Encourage flow.
Responsive is better than fast.
Design for failure.
It's not fully shipped until it's fast.
Approachable is better than simple.
Keep it logically awesome.
It's not fully shipped until it's fast.
Favor focus over features.
Anything added dilutes everything else.
Speak like a human.
Practicality beats purity.
Design for failure.
Half measures are as bad as nothing at all.
Anything added dilutes everything else.
Anything added dilutes everything else.
Speak like a human.
Half measures are as bad as nothing at all.
Avoid administrative distraction.
Speak like a human.
Non-blocking is better than blocking.
Speak like a human.
Avoid administrative distraction.
Non-blocking is better than blocking.
Approachable is better than simple.
Anything added dilutes everything else.
Favor focus over features.
It's not fully shipped until it's fast.
Favor focus over features.
Half measures are as bad as nothing at all.
Keep it logically awesome.
Practicality beats purity.
Practicality beats purity.
Design for failure.
Design for failure.
Speak like a human.
Approachable is better than simple.
Responsive is better than fast.
It's not fully shipped until it's fast.
Speak like a human.
Encourage flow.
Half measures are as bad as nothing at all.
Speak like a human.
Encourage flow.
Approachable is better than simple.
Favor focus over features.
Anything added dilutes everything else.
Avoid administrative distraction.
It's not fully shipped until it's fast.
Anything added dilutes everything else.
Anything added dilutes everything else.
Design for failure.
Half measures are as bad as nothing at all.
Responsive is better than fast.
Design for failure.
Encourage flow.
Half measures are as bad as nothing at all.
Half measures are as bad as nothing at all.
Approachable is better than simple.
Half measures are as bad as nothing at all.
Approachable is better than simple.
Avoid administrative distraction.
Avoid administrative distraction.
It's not fully shipped until it's fast.
Speak like a human.
Design for failure.
Keep it logically awesome.
Keep it logically awesome.
Responsive is better than fast.
Speak like a human.
Design for failure.
Mind your words, they are important.
Mind your words, they are important.
Half measures are as bad as nothing at all.
Speak like a human.
Approachable is better than simple.
Speak like a human.
Half measures are as bad as nothing at all.
Avoid administrative distraction.
Practicality beats purity.
It's not fully shipped until it's fast.
Approachable is better than simple.
Anything added dilutes everything else.
Speak like a human.
Mind your words, they are important.
Encourage flow.
Half measures are as bad as nothing at all.
Non-blocking is better than blocking.
Half measures are as bad as nothing at all.
Mind your words, they are important.
Practicality beats purity.
Design for failure.
Speak like a human.
Mind your words, they are important.
Speak like a human.
Favor focus over features.
Non-blocking is better than blocking.
Keep it logically awesome.
Anything added dilutes everything else.
Anything added dilutes everything else.
Approachable is better than simple.
Anything added dilutes everything else.
Encourage flow.
Keep it logically awesome.
Keep it logically awesome.
Anything added dilutes everything else.
Keep it logically awesome.
Speak like a human.
Anything added dilutes everything else.
Design for failure.
Practicality beats purity.
Mind your words, they are important.
Speak like a human.
Keep it logically awesome.
Half measures are as bad as nothing at all.
Keep it logically awesome.
Keep it logically awesome.
Non-blocking is better than blocking.
Responsive is better than fast.
Responsive is better than fast.
Keep it logically awesome.
Non-blocking is better than blocking.
Anything added dilutes everything else.
Mind your words, they are important.
Half measures are as bad as nothing at all.
Design for failure.
Approachable is better than simple.
Design for failure.
Mind your words, they are important.
Practicality beats purity.
Half measures are as bad as nothing at all.
Half measures are as bad as nothing at all.
Design for failure.
Anything added dilutes everything else.
Favor focus over features.
Non-blocking is better than blocking.
Encourage flow.
Keep it logically awesome.
Keep it logically awesome.
Encourage flow.
Non-blocking is better than blocking.
Speak like a human.
Approachable is better than simple.
Avoid administrative distraction.
Mind your words, they are important.
Non-blocking is better than blocking.
Half measures are as bad as nothing at all.
Favor focus over features.
Half measures are as bad as nothing at all.
It's not fully shipped until it's fast.
It's not fully shipped until it's fast.
It's not fully shipped until it's fast.
Avoid administrative distraction.
Mind your words, they are important.
Design for failure.
Half measures are as bad as nothing at all.
Encourage flow.
Avoid administrative distraction.
Approachable is better than simple.
Anything added dilutes everything else.
Practicality beats purity.
Mind your words, they are important.
Speak like a human.
Keep it logically awesome.
Design for failure.
Encourage flow.
Encourage flow.
Anything added dilutes everything else.
Half measures are as bad as nothing at all.
It's not fully shipped until it's fast.
It's not fully shipped until it's fast.
Keep it logically awesome.
Favor focus over features.
Half measures are as bad as nothing at all.
Speak like a human.
Keep it logically awesome.
Practicality beats purity.
Avoid administrative distraction.
Approachable is better than simple.
Mind your words, they are important.
Keep it logically awesome.
Keep it logically awesome.
It's not fully shipped until it's fast.
Keep it logically awesome.
Avoid administrative distraction.
Anything added dilutes everything else.
Approachable is better than simple.
Speak like a human.
Practicality beats purity.
Half measures are as bad as nothing at all.
Keep it logically awesome.
Avoid administrative distraction.
Responsive is better than fast.
Responsive is better than fast.
Half measures are as bad as nothing at all.
Non-blocking is better than blocking.
Responsive is better than fast.
Speak like a human.
Keep it logically awesome.
Speak like a human.
Responsive is better than fast.
Non-blocking is better than blocking.
Speak like a human.
Half measures are as bad as nothing at all.
Encourage flow.
Avoid administrative distraction.
Practicality beats purity.
Non-blocking is better than blocking.
Approachable is better than simple.
Responsive is better than fast.
Speak like a human.
Keep it logically awesome.
Mind your words, they are important.
Non-blocking is better than blocking.
Design for failure.
Anything added dilutes everything else.
Speak like a human.
Encourage flow.
Non-blocking is better than blocking.
Encourage flow.
Mind your words, they are important.
It's not fully shipped until it's fast.
Approachable is better than simple.
Responsive is better than fast.
Speak like a human.
Half measures are as bad as nothing at all.
Half measures are as bad as nothing at all.
It's not fully shipped until it's fast.
Responsive is better than fast.
Avoid administrative distraction.
Practicality beats purity.
Anything added dilutes everything else.
Non-blocking is better than blocking.
Non-blocking is better than blocking.
Approachable is better than simple.
Approachable is better than simple.
Mind your words, they are important.
Practicality beats purity.
Half measures are as bad as nothing at all.
Keep it logically awesome.
Avoid administrative distraction.
Practicality beats purity.
Non-blocking is better than blocking.
Non-blocking is better than blocking.
Practicality beats purity.
Avoid administrative distraction.
Responsive is better than fast.
It's not fully shipped until it's fast.
Mind your words, they are important.
Anything added dilutes everything else.
Mind your words, they are important.
Mind your words, they are important.
It's not fully shipped until it's fast.
Non-blocking is better than blocking.
Design for failure.
Design for failure.
Half measures are as bad as nothing at all.
Speak like a human.
Approachable is better than simple.
Approachable is better than simple.
Practicality beats purity.
It's not fully shipped until it's fast.
Half measures are as bad as nothing at all.
Avoid administrative distraction.
Avoid administrative distraction.
Speak like a human.
Keep it logically awesome.
Favor focus over features.
Anything added dilutes everything else.
Anything added dilutes everything else.
Encourage flow.
Approachable is better than simple.
Approachable is better than simple.
Responsive is better than fast.
Practicality beats purity.
Encourage flow.
Encourage flow.
It's not fully shipped until it's fast.
Practicality beats purity.
Mind your words, they are important.
Practicality beats purity.
Speak like a human.
Favor focus over features.
Half measures are as bad as nothing at all.
Practicality beats purity.
Practicality beats purity.
Design for failure.
Approachable is better than simple.
Practicality beats purity.
Anything added dilutes everything else.
Anything added dilutes everything else.
It's not fully shipped until it's fast.
Speak like a human.
Mind your words, they are important.
Encourage flow.
Avoid administrative distraction.
Favor focus over features.
It's not fully shipped until it's fast.
Favor focus over features.
Responsive is better than fast.
Approachable is better than simple.
Encourage flow.
Speak like a human.
Mind your words, they are important.
Non-blocking is better than blocking.
Responsive is better than fast.
Design for failure.
Responsive is better than fast.
Practicality beats purity.
Keep it logically awesome.
Mind your words, they are important.
Avoid administrative distraction.
Anything added dilutes everything else.
Anything added dilutes everything else.
Anything added dilutes everything else.
Favor focus over features.
Responsive is better than fast.
Non-blocking is better than blocking.
Favor focus over features.
Approachable is better than simple.
Non-blocking is better than blocking.
Non-blocking is better than blocking.
Non-blocking is better than blocking.
Responsive is better than fast.
Approachable is better than simple.
Half measures are as bad as nothing at all.
It's not fully shipped until it's fast.
Keep it logically awesome.
Design for failure.
Half measures are as bad as nothing at all.
It's not fully shipped until it's fast.
Non-blocking is better than blocking.
Approachable is better than simple.
Speak like a human.
Encourage flow.
It's not fully shipped until it's fast.
Anything added dilutes everything else.
It's not fully shipped until it's fast.
Practicality beats purity.
Half measures are as bad as nothing at all.
Design for failure.
Half measures are as bad as nothing at all.
Encourage flow.
Speak like a human.
Keep it logically awesome.
Responsive is better than fast.
It's not fully shipped until it's fast.
Design for failure.
Approachable is better than simple.
It's not fully shipped until it's fast.
Half measures are as bad as nothing at all.
Practicality beats purity.
Practicality beats purity.
Speak like a human.
Approachable is better than simple.
Mind your words, they are important.
Encourage flow.
Design for failure.
Speak like a human.
Avoid administrative distraction.
Approachable is better than simple.
Non-blocking is better than blocking.
Speak like a human.
Anything added dilutes everything else.
It's not fully shipped until it's fast.
Speak like a human.
Responsive is better than fast.
Avoid administrative distraction.
Practicality beats purity.
Mind your words, they are important.
Encourage flow.
Avoid administrative distraction.
Keep it logically awesome.
Favor focus over features.
Practicality beats purity.
Speak like a human.
Keep it logically awesome.
Avoid administrative distraction.
Speak like a human.
It's not fully shipped until it's fast.
Practicality beats purity.
Avoid administrative distraction.
Mind your words, they are important.
It's not fully shipped until it's fast.
Favor focus over features.
Half measures are as bad as nothing at all.
Half measures are as bad as nothing at all.
Encourage flow.
Encourage flow.
Speak like a human.
Avoid administrative distraction.
Practicality beats purity.
Approachable is better than simple.
Anything added dilutes everything else.
Favor focus over features.
Mind your words, they are important.
Avoid administrative distraction.
Mind your words, they are important.
Practicality beats purity.
Design for failure.
Responsive is better than fast.
Anything added dilutes everything else.
Approachable is better than simple.
Speak like a human.
Approachable is better than simple.
Keep it logically awesome.
Anything added dilutes everything else.
Anything added dilutes everything else.
Approachable is better than simple.
Favor focus over features.
Encourage flow.
Mind your words, they are important.
Responsive is better than fast.
Design for failure.
Non-blocking is better than blocking.
Favor focus over features.
Speak like a human.
Keep it logically awesome.
Practicality beats purity.
Mind your words, they are important.
Responsive is better than fast.
Half measures are as bad as nothing at all.
Keep it logically awesome.
Mind your words, they are important.
It's not fully shipped until it's fast.
Half measures are as bad as nothing at all.
Keep it logically awesome.
Avoid administrative distraction.
Favor focus over features.
Keep it logically awesome.
Half measures are as bad as nothing at all.
Speak like a human.
Keep it logically awesome.
It's not fully shipped until it's fast.
Speak like a human.
Keep it logically awesome.
Practicality beats purity.
It's not fully shipped until it's fast.
Practicality beats purity.
Keep it logically awesome.
Approachable is better than simple.
It's not fully shipped until it's fast.
Mind your words, they are important.
Avoid administrative distraction.
Responsive is better than fast.
It's not fully shipped until it's fast.
Anything added dilutes everything else.
Avoid administrative distraction.
Half measures are as bad as nothing at all.
Design for failure.
Half measures are as bad as nothing at all.
Non-blocking is better than blocking.
Anything added dilutes everything else.
Avoid administrative distraction.
Avoid administrative distraction.
Speak like a human.
Responsive is better than fast.
It's not fully shipped until it's fast.
Half measures are as bad as nothing at all.
Keep it logically awesome.
Anything added dilutes everything else.
Speak like a human.
Encourage flow.
Responsive is better than fast.
Keep it logically awesome.
It's not fully shipped until it's fast.
Non-blocking is better than blocking.
Keep it logically awesome.
It's not fully shipped until it's fast.
Keep it logically awesome.
Anything added dilutes everything else.
Anything added dilutes everything else.
Favor focus over features.
Approachable is better than simple.
Avoid administrative distraction.
Practicality beats purity.
Mind your words, they are important.
Mind your words, they are important.
It's not fully shipped until it's fast.
Encourage flow.
Design for failure.
It's not fully shipped until it's fast.
Practicality beats purity.
Avoid administrative distraction.
Approachable is better than simple.
Practicality beats purity.
Avoid administrative distraction.
Approachable is better than simple.
It's not fully shipped until it's fast.
Encourage flow.
Speak like a human.
It's not fully shipped until it's fast.
Half measures are as bad as nothing at all.
Non-blocking is better than blocking.
Speak like a human.
Anything added dilutes everything else.
Half measures are as bad as nothing at all.
Non-blocking is better than blocking.
Avoid administrative distraction.
Responsive is better than fast.
Non-blocking is better than blocking.
Design for failure.
Favor focus over features.
Design for failure.
Avoid administrative distraction.
Anything added dilutes everything else.
Favor focus over features.
It's not fully shipped until it's fast.
Mind your words, they are important.
Encourage flow.
Responsive is better than fast.
Speak like a human.
Anything added dilutes everything else.
Speak like a human.
Mind your words, they are important.
It's not fully shipped until it's fast.
Non-blocking is better than blocking.
Approachable is better than simple.
Speak like a human.
Keep it logically awesome.
Responsive is better than fast.
It's not fully shipped until it's fast.
Design for failure.
Mind your words, they are important.
Speak like a human.
Anything added dilutes everything else.
Half measures are as bad as nothing at all.
Keep it logically awesome.
Half measures are as bad as nothing at all.
Responsive is better than fast.
Avoid administrative distraction.
Half measures are as bad as nothing at all.
It's not fully shipped until it's fast.
It's not fully shipped until it's fast.
Design for failure.
Non-blocking is better than blocking.
Half measures are as bad as nothing at all.
Practicality beats purity.
Favor focus over features.
Non-blocking is better than blocking.
Approachable is better than simple.
Practicality beats purity.
Design for failure.
Design for failure.
Design for failure.
Anything added dilutes everything else.
It's not fully shipped until it's fast.
Mind your words, they are important.
It's not fully shipped until it's fast.
Practicality beats purity.
Non-blocking is better than blocking.
Favor focus over features.
Encourage flow.
Favor focus over features.
Keep it logically awesome.
Avoid administrative distraction.
Speak like a human.
Encourage flow.
Design for failure.
Half measures are as bad as nothing at all.
Non-blocking is better than blocking.
Keep it logically awesome.
Favor focus over features.
Non-blocking is better than blocking.
Anything added dilutes everything else.
Responsive is better than fast.
Anything added dilutes everything else.
Anything added dilutes everything else.
Favor focus over features.
Approachable is better than simple.
It's not fully shipped until it's fast.
Encourage flow.
Practicality beats purity.
Responsive is better than fast.
Practicality beats purity.
Speak like a human.
Half measures are as bad as nothing at all.
Anything added dilutes everything else.
Keep it logically awesome.
Half measures are as bad as nothing at all.
Speak like a human.
Anything added dilutes everything else.
Keep it logically awesome.
Encourage flow.
Speak like a human.
Approachable is better than simple.
Encourage flow.
Half measures are as bad as nothing at all.
Design for failure.
Half measures are as bad as nothing at all.
Favor focus over features.
Favor focus over features.
Responsive is better than fast.
Half measures are as bad as nothing at all.
Speak like a human.
Keep it logically awesome.
Design for failure.
Practicality beats purity.
Speak like a human.
Avoid administrative distraction.
Speak like a human.
Encourage flow.
Anything added dilutes everything else.
Mind your words, they are important.
Half measures are as bad as nothing at all.
It's not fully shipped until it's fast.
Design for failure.
It's not fully shipped until it's fast.
Practicality beats purity.
Approachable is better than simple.
Half measures are as bad as nothing at all.
Practicality beats purity.
Practicality beats purity.
Speak like a human.
Non-blocking is better than blocking.
Favor focus over features.
Mind your words, they are important.
Mind your words, they are important.
Encourage flow.
Mind your words, they are important.
Favor focus over features.
Anything added dilutes everything else.
Approachable is better than simple.
Encourage flow.
Practicality beats purity.
Anything added dilutes everything else.
Practicality beats purity.
Favor focus over features.
Anything added dilutes everything else.
Avoid administrative distraction.
Encourage flow.
It's not fully shipped until it's fast.
Responsive is better than fast.
Approachable is better than simple.
Keep it logically awesome.
Mind your words, they are important.
It's not fully shipped until it's fast.
Speak like a human.
Keep it logically awesome.
Design for failure.
Design for failure.
Speak like a human.
Approachable is better than simple.
Non-blocking is better than blocking.
Responsive is better than fast.
Non-blocking is better than blocking.
Encourage flow.
Avoid administrative distraction.
Mind your words, they are important.
Avoid administrative distraction.
Responsive is better than fast.
Half measures are as bad as nothing at all.
Anything added dilutes everything else.
It's not fully shipped until it's fast.
Mind your words, they are important.
Keep it logically awesome.
Speak like a human.
Keep it logically awesome.
Design for failure.
Practicality beats purity.
Speak like a human.
Responsive is better than fast.
Design for failure.
Speak like a human.
Half measures are as bad as nothing at all.
Encourage flow.
Avoid administrative distraction.
Encourage flow.
Favor focus over features.
Half measures are as bad as nothing at all.
Half measures are as bad as nothing at all.
Speak like a human.
Speak like a human.
Responsive is better than fast.
Keep it logically awesome.
Avoid administrative distraction.
Non-blocking is better than blocking.
Favor focus over features.
Speak like a human.
Approachable is better than simple.
Encourage flow.
Approachable is better than simple.
Anything added dilutes everything else.
Favor focus over features.
Anything added dilutes everything else.
Non-blocking is better than blocking.
Mind your words, they are important.
Favor focus over features.
Approachable is better than simple.
Practicality beats purity.
Half measures are as bad as nothing at all.
Practicality beats purity.
Favor focus over features.
Anything added dilutes everything else.
Practicality beats purity.
Encourage flow.
Speak like a human.
Half measures are as bad as nothing at all.
Half measures are as bad as nothing at all.
Practicality beats purity.
It's not fully shipped until it's fast.
Non-blocking is better than blocking.
Keep it logically awesome.
Avoid administrative distraction.
Encourage flow.
Half measures are as bad as nothing at all.
Practicality beats purity.
Design for failure.
Avoid administrative distraction.
Favor focus over features.
Favor focus over features.
Practicality beats purity.
Practicality beats purity.
Non-blocking is better than blocking.
Approachable is better than simple.
Responsive is better than fast.
Favor focus over features.
Approachable is better than simple.
Favor focus over features.
It's not fully shipped until it's fast.
Keep it logically awesome.
Design for failure.
Favor focus over features.
Avoid administrative distraction.
Speak like a human.
Mind your words, they are important.
Half measures are as bad as nothing at all.
Keep it logically awesome.
Design for failure.
Avoid administrative distraction.
Half measures are as bad as nothing at all.
Favor focus over features.
Non-blocking is better than blocking.
Practicality beats purity.
Encourage flow.
Responsive is better than fast.
Half measures are as bad as nothing at all.
Responsive is better than fast.
It's not fully shipped until it's fast.
Favor focus over features.
Favor focus over features.
Non-blocking is better than blocking.
Keep it logically awesome.
It's not fully shipped until it's fast.
Anything added dilutes everything else.
Practicality beats purity.
Non-blocking is better than blocking.
Practicality beats purity.
Anything added dilutes everything else.
It's not fully shipped until it's fast.
Favor focus over features.
Anything added dilutes everything else.
It's not fully shipped until it's fast.
Non-blocking is better than blocking.
Mind your words, they are important.
Keep it logically awesome.
Responsive is better than fast.
Anything added dilutes everything else.
Encourage flow.
Half measures are as bad as nothing at all.
Anything added dilutes everything else.
Approachable is better than simple.
Responsive is better than fast.
Half measures are as bad as nothing at all.
Favor focus over features.
Approachable is better than simple.
It's not fully shipped until it's fast.
Design for failure.
Speak like a human.
Practicality beats purity.
Speak like a human.
Practicality beats purity.
Approachable is better than simple.
It's not fully shipped until it's fast.
Half measures are as bad as nothing at all.
Approachable is better than simple.
Speak like a human.
Mind your words, they are important.
Favor focus over features.
Avoid administrative distraction.
Encourage flow.
Keep it logically awesome.
Half measures are as bad as nothing at all.
Favor focus over features.
Half measures are as bad as nothing at all.
Mind your words, they are important.
Avoid administrative distraction.
Design for failure.
Non-blocking is better than blocking.
Half measures are as bad as nothing at all.
Practicality beats purity.
It's not fully shipped until it's fast.
Encourage flow.
Mind your words, they are important.
Non-blocking is better than blocking.
Favor focus over features.
Encourage flow.
Favor focus over features.
Practicality beats purity.
Non-blocking is better than blocking.
Non-blocking is better than blocking.
Anything added dilutes everything else.
Anything added dilutes everything else.
Favor focus over features.
Responsive is better than fast.
Encourage flow.
Approachable is better than simple.
Design for failure.
Encourage flow.
Design for failure.
Practicality beats purity.
Responsive is better than fast.
Encourage flow.
Avoid administrative distraction.
Practicality beats purity.
Mind your words, they are important.
Speak like a human.
Practicality beats purity.
Half measures are as bad as nothing at all.
Avoid administrative distraction.
Anything added dilutes everything else.
Encourage flow.
It's not fully shipped until it's fast.
Half measures are as bad as nothing at all.
Approachable is better than simple.
Favor focus over features.
It's not fully shipped until it's fast.
Avoid administrative distraction.
Approachable is better than simple.
Mind your words, they are important.
Mind your words, they are important.
Responsive is better than fast.
Avoid administrative distraction.
Approachable is better than simple.
Avoid administrative distraction.
It's not fully shipped until it's fast.
Approachable is better than simple.
Approachable is better than simple.
Speak like a human.
Avoid administrative distraction.
Encourage flow.
Approachable is better than simple.
Speak like a human.
Encourage flow.
Speak like a human.
Half measures are as bad as nothing at all.
Responsive is better than fast.
Anything added dilutes everything else.
It's not fully shipped until it's fast.
Keep it logically awesome.
Mind your words, they are important.
Half measures are as bad as nothing at all.
Keep it logically awesome.
Speak like a human.
Half measures are as bad as nothing at all.
Non-blocking is better than blocking.
Responsive is better than fast.
Anything added dilutes everything else.
Practicality beats purity.
Encourage flow.
Anything added dilutes everything else.
Encourage flow.
Mind your words, they are important.
Responsive is better than fast.
It's not fully shipped until it's fast.
It's not fully shipped until it's fast.
Non-blocking is better than blocking.
Speak like a human.
Non-blocking is better than blocking.
Anything added dilutes everything else.
Avoid administrative distraction.
It's not fully shipped until it's fast.
Keep it logically awesome.
Mind your words, they are important.
Approachable is better than simple.
It's not fully shipped until it's fast.
Anything added dilutes everything else.
Keep it logically awesome.
Responsive is better than fast.
Favor focus over features.
Practicality beats purity.
Design for failure.
Favor focus over features.
Practicality beats purity.
Favor focus over features.
Design for failure.
Anything added dilutes everything else.
Approachable is better than simple.
Speak like a human.
Approachable is better than simple.
Non-blocking is better than blocking.
Responsive is better than fast.
Practicality beats purity.
Practicality beats purity.
Avoid administrative distraction.
Encourage flow.
Practicality beats purity.
Keep it logically awesome.
Approachable is better than simple.
Approachable is better than simple.
Non-blocking is better than blocking.
Non-blocking is better than blocking.
Mind your words, they are important.
Responsive is better than fast.
It's not fully shipped until it's fast.
Practicality beats purity.
Keep it logically awesome.
Half measures are as bad as nothing at all.
Mind your words, they are important.
Mind your words, they are important.
Practicality beats purity.
Approachable is better than simple.
It's not fully shipped until it's fast.
Practicality beats purity.
Mind your words, they are important.
Avoid administrative distraction.
Favor focus over features.
Design for failure.
Responsive is better than fast.
Responsive is better than fast.
Favor focus over features.
Keep it logically awesome.
Speak like a human.
Keep it logically awesome.
Speak like a human.
Half measures are as bad as nothing at all.
Design for failure.
Anything added dilutes everything else.
Non-blocking is better than blocking.
Half measures are as bad as nothing at all.
Non-blocking is better than blocking.
Half measures are as bad as nothing at all.
Favor focus over features.
Speak like a human.
Speak like a human.
Anything added dilutes everything else.
Encourage flow.
Encourage flow.
Encourage flow.
Anything added dilutes everything else.
Anything added dilutes everything else.
Avoid administrative distraction.
Non-blocking is better than blocking.
Avoid administrative distraction.
Mind your words, they are important.
Avoid administrative distraction.
Approachable is better than simple.
Keep it logically awesome.
Design for failure.
Anything added dilutes everything else.
Mind your words, they are important.
Design for failure.
Mind your words, they are important.
Speak like a human.
Responsive is better than fast.
Mind your words, they are important.
Half measures are as bad as nothing at all.
Avoid administrative distraction.
Non-blocking is better than blocking.
Anything added dilutes everything else.
Speak like a human.
Avoid administrative distraction.
Favor focus over features.
Practicality beats purity.
Anything added dilutes everything else.
Speak like a human.
Favor focus over features.
Encourage flow.
Mind your words, they are important.
Half measures are as bad as nothing at all.
Practicality beats purity.
Speak like a human.
Speak like a human.
Anything added dilutes everything else.
Avoid administrative distraction.
Half measures are as bad as nothing at all.
Favor focus over features.
Approachable is better than simple.
Approachable is better than simple.
Responsive is better than fast.
Non-blocking is better than blocking.
Favor focus over features.
Encourage flow.
Mind your words, they are important.
It's not fully shipped until it's fast.
Speak like a human.
It's not fully shipped until it's fast.
Speak like a human.
Design for failure.
Design for failure.
Responsive is better than fast.
Responsive is better than fast.
Speak like a human.
Anything added dilutes everything else.
Anything added dilutes everything else.
Encourage flow.
Design for failure.
Keep it logically awesome.
Avoid administrative distraction.
Speak like a human.
Favor focus over features.
Responsive is better than fast.
Responsive is better than fast.
Approachable is better than simple.
Mind your words, they are important.
Avoid administrative distraction.
Non-blocking is better than blocking.
Anything added dilutes everything else.
Avoid administrative distraction.
Anything added dilutes everything else.
Favor focus over features.
Encourage flow.
Avoid administrative distraction.
Encourage flow.
Favor focus over features.
Non-blocking is better than blocking.
Anything added dilutes everything else.
Half measures are as bad as nothing at all.
Avoid administrative distraction.
Half measures are as bad as nothing at all.
Anything added dilutes everything else.
Keep it logically awesome.
Anything added dilutes everything else.
Half measures are as bad as nothing at all.
Design for failure.
Favor focus over features.
Practicality beats purity.
Avoid administrative distraction.
Speak like a human.
Approachable is better than simple.
Avoid administrative distraction.
Non-blocking is better than blocking.
It's not fully shipped until it's fast.
Half measures are as bad as nothing at all.
Approachable is better than simple.
Design for failure.
Speak like a human.
Favor focus over features.
Responsive is better than fast.
Design for failure.
Responsive is better than fast.
Keep it logically awesome.
Favor focus over features.
Non-blocking is better than blocking.
Responsive is better than fast.
Approachable is better than simple.
Responsive is better than fast.
Responsive is better than fast.
Avoid administrative distraction.
Non-blocking is better than blocking.
Favor focus over features.
Responsive is better than fast.
Keep it logically awesome.
Keep it logically awesome.
Keep it logically awesome.
It's not fully shipped until it's fast.
Mind your words, they are important.
Encourage flow.
Avoid administrative distraction.
Keep it logically awesome.
Mind your words, they are important.
Design for failure.
Responsive is better than fast.
Keep it logically awesome.
Encourage flow.
It's not fully shipped until it's fast.
Responsive is better than fast.
Mind your words, they are important.
Responsive is better than fast.
Avoid administrative distraction.
It's not fully shipped until it's fast.
Non-blocking is better than blocking.
Mind your words, they are important.
Speak like a human.
Responsive is better than fast.
Responsive is better than fast.
Design for failure.
Design for failure.
Avoid administrative distraction.
Design for failure.
Non-blocking is better than blocking.
Keep it logically awesome.
Encourage flow.
Design for failure.
Keep it logically awesome.
Favor focus over features.
Design for failure.
Keep it logically awesome.
Responsive is better than fast.
Responsive is better than fast.
Favor focus over features.
Design for failure.
Keep it logically awesome.
Encourage flow.
Speak like a human.
Approachable is better than simple.
Keep it logically awesome.
Non-blocking is better than blocking.
Approachable is better than simple.
It's not fully shipped until it's fast.
Practicality beats purity.
Keep it logically awesome.
Encourage flow.
Keep it logically awesome.
Avoid administrative distraction.
It's not fully shipped until it's fast.
Keep it logically awesome.
Anything added dilutes everything else.
Anything added dilutes everything else.
Avoid administrative distraction.
Half measures are as bad as nothing at all.
Avoid administrative distraction.
Keep it logically awesome.
Favor focus over features.
Responsive is better than fast.
Speak like a human.
Practicality beats purity.
Avoid administrative distraction.
Mind your words, they are important.
Anything added dilutes everything else.
Half measures are as bad as nothing at all.
Encourage flow.
Anything added dilutes everything else.
Encourage flow.
Keep it logically awesome.
Avoid administrative distraction.
Approachable is better than simple.
Practicality beats purity.
Favor focus over features.
Mind your words, they are important.
Half measures are as bad as nothing at all.
Favor focus over features.
Anything added dilutes everything else.
Anything added dilutes everything else.
Speak like a human.
Encourage flow.
Speak like a human.
Approachable is better than simple.
Anything added dilutes everything else.
Half measures are as bad as nothing at all.
Anything added dilutes everything else.
Speak like a human.
Avoid administrative distraction.
It's not fully shipped until it's fast.
Speak like a human.
Approachable is better than simple.
Non-blocking is better than blocking.
Approachable is better than simple.
It's not fully shipped until it's fast.
It's not fully shipped until it's fast.
Approachable is better than simple.
It's not fully shipped until it's fast.
Practicality beats purity.
It's not fully shipped until it's fast.
Keep it logically awesome.
Keep it logically awesome.
Avoid administrative distraction.
Anything added dilutes everything else.
Half measures are as bad as nothing at all.
Speak like a human.
Half measures are as bad as nothing at all.
Keep it logically awesome.
Anything added dilutes everything else.
Avoid administrative distraction.
Keep it logically awesome.
Encourage flow.
Encourage flow.
Keep it logically awesome.
Responsive is better than fast.
It's not fully shipped until it's fast.
Mind your words, they are important.
Practicality beats purity.
Favor focus over features.
Mind your words, they are important.
Anything added dilutes everything else.
Half measures are as bad as nothing at all.
Mind your words, they are important.
Half measures are as bad as nothing at all.
Approachable is better than simple.
Practicality beats purity.
Speak like a human.
Non-blocking is better than blocking.
Approachable is better than simple.
It's not fully shipped until it's fast.
Anything added dilutes everything else.
Design for failure.
Mind your words, they are important.
Design for failure.
Approachable is better than simple.
Practicality beats purity.
Practicality beats purity.
Speak like a human.
Non-blocking is better than blocking.
Design for failure.
Speak like a human.
It's not fully shipped until it's fast.
Approachable is better than simple.
Mind your words, they are important.
Approachable is better than simple.
Avoid administrative distraction.
Anything added dilutes everything else.
It's not fully shipped until it's fast.
Approachable is better than simple.
Responsive is better than fast.
Responsive is better than fast.
Approachable is better than simple.
Anything added dilutes everything else.
Non-blocking is better than blocking.
Favor focus over features.
Non-blocking is better than blocking.
Keep it logically awesome.
Approachable is better than simple.
Mind your words, they are important.
Half measures are as bad as nothing at all.
Non-blocking is better than blocking.
Mind your words, they are important.
Avoid administrative distraction.
Half measures are as bad as nothing at all.
Half measures are as bad as nothing at all.
Design for failure.
Responsive is better than fast.
Practicality beats purity.
Mind your words, they are important.
Design for failure.
Practicality beats purity.
Design for failure.
Approachable is better than simple.
Keep it logically awesome.
Encourage flow.
Approachable is better than simple.
Speak like a human.
Anything added dilutes everything else.
Design for failure.
Mind your words, they are important.
Practicality beats purity.
Speak like a human.
Approachable is better than simple.
Approachable is better than simple.
Approachable is better than simple.
Avoid administrative distraction.
Design for failure.
Avoid administrative distraction.
Mind your words, they are important.
Responsive is better than fast.
Design for failure.
Keep it logically awesome.
Design for failure.
Keep it logically awesome.
Encourage flow.
Non-blocking is better than blocking.
Keep it logically awesome.
It's not fully shipped until it's fast.
Avoid administrative distraction.
Responsive is better than fast.
Anything added dilutes everything else.
Half measures are as bad as nothing at all.
Encourage flow.
Avoid administrative distraction.
Favor focus over features.
Speak like a human.
Avoid administrative distraction.
Avoid administrative distraction.
Approachable is better than simple.
Avoid administrative distraction.
Encourage flow.
Favor focus over features.
Avoid administrative distraction.
Favor focus over features.
Anything added dilutes everything else.
It's not fully shipped until it's fast.
Approachable is better than simple.
Speak like a human.
Responsive is better than fast.
Avoid administrative distraction.
Favor focus over features.
Favor focus over features.
Favor focus over features.
Encourage flow.
Half measures are as bad as nothing at all.
Design for failure.
Mind your words, they are important.
It's not fully shipped until it's fast.
Encourage flow.
Non-blocking is better than blocking.
Keep it logically awesome.
Anything added dilutes everything else.
Design for failure.
Anything added dilutes everything else.
Anything added dilutes everything else.
Mind your words, they are important.
Half measures are as bad as nothing at all.
Encourage flow.
It's not fully shipped until it's fast.
Speak like a human.
Keep it logically awesome.
Design for failure.
Anything added dilutes everything else.
Practicality beats purity.
Mind your words, they are important.
Approachable is better than simple.
Approachable is better than simple.
Mind your words, they are important.
Avoid administrative distraction.
Keep it logically awesome.
Anything added dilutes everything else.
Responsive is better than fast.
Responsive is better than fast.
Design for failure.
Mind your words, they are important.
Half measures are as bad as nothing at all.
Speak like a human.
Non-blocking is better than blocking.
Mind your words, they are important.
Anything added dilutes everything else.
Anything added dilutes everything else.
Practicality beats purity.
Responsive is better than fast.
It's not fully shipped until it's fast.
Design for failure.
Favor focus over features.
Responsive is better than fast.
Mind your words, they are important.
Practicality beats purity.
Responsive is better than fast.
Keep it logically awesome.
Half measures are as bad as nothing at all.
Approachable is better than simple.
Responsive is better than fast.
Speak like a human.
Avoid administrative distraction.
Mind your words, they are important.
Design for failure.
Practicality beats purity.
Anything added dilutes everything else.
Anything added dilutes everything else.
Mind your words, they are important.
Half measures are as bad as nothing at all.
It's not fully shipped until it's fast.
Non-blocking is better than blocking.
Half measures are as bad as nothing at all.
Half measures are as bad as nothing at all.
Anything added dilutes everything else.
Responsive is better than fast.
Half measures are as bad as nothing at all.
Mind your words, they are important.
Approachable is better than simple.
Avoid administrative distraction.
Design for failure.
Practicality beats purity.
Practicality beats purity.
Keep it logically awesome.
Keep it logically awesome.
Responsive is better than fast.
Design for failure.
Anything added dilutes everything else.
It's not fully shipped until it's fast.
Practicality beats purity.
Design for failure.
Speak like a human.
Half measures are as bad as nothing at all.
It's not fully shipped until it's fast.
Design for failure.
It's not fully shipped until it's fast.
Practicality beats purity.
It's not fully shipped until it's fast.
Practicality beats purity.
Favor focus over features.
Speak like a human.
It's not fully shipped until it's fast.
It's not fully shipped until it's fast.
Anything added dilutes everything else.
Practicality beats purity.
Approachable is better than simple.
Anything added dilutes everything else.
Mind your words, they are important.
Keep it logically awesome.
Approachable is better than simple.
Avoid administrative distraction.
Encourage flow.
Anything added dilutes everything else.
Responsive is better than fast.
Responsive is better than fast.
Design for failure.
It's not fully shipped until it's fast.
Encourage flow.
Speak like a human.
Keep it logically awesome.
Keep it logically awesome.
Mind your words, they are important.
Mind your words, they are important.
Design for failure.
Design for failure.
Encourage flow.
Design for failure.
Avoid administrative distraction.
Non-blocking is better than blocking.
Encourage flow.
Non-blocking is better than blocking.
Approachable is better than simple.
It's not fully shipped until it's fast.
Keep it logically awesome.
Practicality beats purity.
Keep it logically awesome.
Design for failure.
Avoid administrative distraction.
Non-blocking is better than blocking.
Half measures are as bad as nothing at all.
Design for failure.
Avoid administrative distraction.
Encourage flow.
Speak like a human.
Design for failure.
Anything added dilutes everything else.
Responsive is better than fast.
Half measures are as bad as nothing at all.
Avoid administrative distraction.
Favor focus over features.
Avoid administrative distraction.
Mind your words, they are important.
Responsive is better than fast.
Speak like a human.
Design for failure.
Avoid administrative distraction.
Mind your words, they are important.
Mind your words, they are important.
Responsive is better than fast.
Half measures are as bad as nothing at all.
Approachable is better than simple.
Avoid administrative distraction.
Avoid administrative distraction.
Anything added dilutes everything else.
It's not fully shipped until it's fast.
Anything added dilutes everything else.
Speak like a human.
Design for failure.
Design for failure.
Encourage flow.
Keep it logically awesome.
It's not fully shipped until it's fast.
Keep it logically awesome.
Speak like a human.
Non-blocking is better than blocking.
Non-blocking is better than blocking.
Avoid administrative distraction.
Encourage flow.
Non-blocking is better than blocking.
It's not fully shipped until it's fast.
Favor focus over features.
Favor focus over features.
It's not fully shipped until it's fast.
Design for failure.
Keep it logically awesome.
Non-blocking is better than blocking.
Avoid administrative distraction.
Encourage flow.
Speak like a human.
Encourage flow.
Approachable is better than simple.
Encourage flow.
Design for failure.
Non-blocking is better than blocking.
Non-blocking is better than blocking.
Mind your words, they are important.
Design for failure.
Approachable is better than simple.
Avoid administrative distraction.
Favor focus over features.
Keep it logically awesome.
Approachable is better than simple.
Non-blocking is better than blocking.
Half measures are as bad as nothing at all.
Responsive is better than fast.
Speak like a human.
Mind your words, they are important.
Favor focus over features.
Practicality beats purity.
Approachable is better than simple.
It's not fully shipped until it's fast.
Favor focus over features.
Non-blocking is better than blocking.
Favor focus over features.
Practicality beats purity.
Approachable is better than simple.
Practicality beats purity.
Half measures are as bad as nothing at all.
Speak like a human.
Half measures are as bad as nothing at all.
Avoid administrative distraction.
Keep it logically awesome.
Keep it logically awesome.
Mind your words, they are important.
Non-blocking is better than blocking.
It's not fully shipped until it's fast.
Practicality beats purity.
Responsive is better than fast.
Keep it logically awesome.
It's not fully shipped until it's fast.
Keep it logically awesome.
Non-blocking is better than blocking.
Keep it logically awesome.
Practicality beats purity.
Practicality beats purity.
Encourage flow.
Keep it logically awesome.
Non-blocking is better than blocking.
Practicality beats purity.
Avoid administrative distraction.
Speak like a human.
Favor focus over features.
Anything added dilutes everything else.
Design for failure.
It's not fully shipped until it's fast.
Mind your words, they are important.
Encourage flow.
Anything added dilutes everything else.
Non-blocking is better than blocking.
Avoid administrative distraction.
Approachable is better than simple.
Anything added dilutes everything else.
Keep it logically awesome.
Keep it logically awesome.
Speak like a human.
Half measures are as bad as nothing at all.
Favor focus over features.
Encourage flow.
Non-blocking is better than blocking.
Encourage flow.
Keep it logically awesome.
Approachable is better than simple.
Half measures are as bad as nothing at all.
Design for failure.
It's not fully shipped until it's fast.
Mind your words, they are important.
Speak like a human.
Speak like a human.
Avoid administrative distraction.
Approachable is better than simple.
Speak like a human.
Mind your words, they are important.
Speak like a human.
Encourage flow.
It's not fully shipped until it's fast.
Keep it logically awesome.
Half measures are as bad as nothing at all.
Half measures are as bad as nothing at all.
Anything added dilutes everything else.
It's not fully shipped until it's fast.
Responsive is better than fast.
Favor focus over features.
Encourage flow.
Responsive is better than fast.
Favor focus over features.
Favor focus over features.
Practicality beats purity.
Encourage flow.
Mind your words, they are important.
Keep it logically awesome.
Avoid administrative distraction.
Mind your words, they are important.
Design for failure.
Approachable is better than simple.
Encourage flow.
Practicality beats purity.
Favor focus over features.
Avoid administrative distraction.
Keep it logically awesome.
Design for failure.
Half measures are as bad as nothing at all.
Avoid administrative distraction.
Practicality beats purity.
Half measures are as bad as nothing at all.
Non-blocking is better than blocking.
Approachable is better than simple.
Favor focus over features.
Design for failure.
Keep it logically awesome.
Anything added dilutes everything else.
Practicality beats purity.
Non-blocking is better than blocking.
Favor focus over features.
Half measures are as bad as nothing at all.
Avoid administrative distraction.
Encourage flow.
Half measures are as bad as nothing at all.
Favor focus over features.
Favor focus over features.
Favor focus over features.
Encourage flow.
Speak like a human.
Design for failure.
It's not fully shipped until it's fast.
Favor focus over features.
Mind your words, they are important.
Half measures are as bad as nothing at all.
Keep it logically awesome.
Responsive is better than fast.
Approachable is better than simple.
Responsive is better than fast.
Responsive is better than fast.
Approachable is better than simple.
Design for failure.
Half measures are as bad as nothing at all.
Speak like a human.
Speak like a human.
Encourage flow.
Responsive is better than fast.
Mind your words, they are important.
Non-blocking is better than blocking.
Keep it logically awesome.
Keep it logically awesome.
Mind your words, they are important.
Half measures are as bad as nothing at all.
Mind your words, they are important.
Favor focus over features.
Design for failure.
Speak like a human.
Practicality beats purity.
Favor focus over features.
Responsive is better than fast.
Speak like a human.
Keep it logically awesome.
Design for failure.
Half measures are as bad as nothing at all.
Speak like a human.
Encourage flow.
Design for failure.
Responsive is better than fast.
Mind your words, they are important.
Avoid administrative distraction.
Half measures are as bad as nothing at all.
Non-blocking is better than blocking.
Design for failure.
Encourage flow.
Encourage flow.
Practicality beats purity.
Favor focus over features.
Favor focus over features.
It's not fully shipped until it's fast.
Speak like a human.
Favor focus over features.
Keep it logically awesome.
Non-blocking is better than blocking.
Anything added dilutes everything else.
It's not fully shipped until it's fast.
Keep it logically awesome.
Approachable is better than simple.
Responsive is better than fast.
Practicality beats purity.
It's not fully shipped until it's fast.
Practicality beats purity.
Practicality beats purity.
Mind your words, they are important.
It's not fully shipped until it's fast.
Responsive is better than fast.
Favor focus over features.
Encourage flow.
Keep it logically awesome.
Design for failure.
Practicality beats purity.
Approachable is better than simple.
Avoid administrative distraction.
Practicality beats purity.
Non-blocking is better than blocking.
Mind your words, they are important.
Mind your words, they are important.
Mind your words, they are important.
Responsive is better than fast.
Favor focus over features.
It's not fully shipped until it's fast.
Approachable is better than simple.
Keep it logically awesome.
It's not fully shipped until it's fast.
Mind your words, they are important.
Approachable is better than simple.
Half measures are as bad as nothing at all.
Anything added dilutes everything else.
Favor focus over features.
Mind your words, they are important.
Avoid administrative distraction.
It's not fully shipped until it's fast.
Encourage flow.
It's not fully shipped until it's fast.
Favor focus over features.
Encourage flow.
Keep it logically awesome.
Avoid administrative distraction.
It's not fully shipped until it's fast.
Favor focus over features.
Mind your words, they are important.
It's not fully shipped until it's fast.
Approachable is better than simple.
Keep it logically awesome.
Approachable is better than simple.
Half measures are as bad as nothing at all.
Practicality beats purity.
Encourage flow.
Anything added dilutes everything else.
Speak like a human.
Keep it logically awesome.
Practicality beats purity.
Favor focus over features.
Anything added dilutes everything else.
Practicality beats purity.
Responsive is better than fast.
Design for failure.
Speak like a human.
Practicality beats purity.
It's not fully shipped until it's fast.
Design for failure.
Design for failure.
Practicality beats purity.
Speak like a human.
Mind your words, they are important.
Anything added dilutes everything else.
Speak like a human.
Encourage flow.
It's not fully shipped until it's fast.
Keep it logically awesome.
Half measures are as bad as nothing at all.
Anything added dilutes everything else.
Design for failure.
Practicality beats purity.
Favor focus over features.
Favor focus over features.
Responsive is better than fast.
Approachable is better than simple.
Half measures are as bad as nothing at all.
Encourage flow.
Encourage flow.
Practicality beats purity.
Half measures are as bad as nothing at all.
Half measures are as bad as nothing at all.
Encourage flow.
Practicality beats purity.
Speak like a human.
Speak like a human.
Non-blocking is better than blocking.
Speak like a human.
It's not fully shipped until it's fast.
Responsive is better than fast.
Design for failure.
Avoid administrative distraction.
Anything added dilutes everything else.
Favor focus over features.
Design for failure.
Approachable is better than simple.
Approachable is better than simple.
Mind your words, they are important.
It's not fully shipped until it's fast.
Encourage flow.
Design for failure.
Design for failure.
Speak like a human.
Approachable is better than simple.
Keep it logically awesome.
Mind your words, they are important.
Anything added dilutes everything else.
Responsive is better than fast.
Responsive is better than fast.
Avoid administrative distraction.
Practicality beats purity.
Responsive is better than fast.
Approachable is better than simple.
Non-blocking is better than blocking.
Avoid administrative distraction.
Encourage flow.
Non-blocking is better than blocking.
Speak like a human.
Speak like a human.
Avoid administrative distraction.
Anything added dilutes everything else.
Non-blocking is better than blocking.
Keep it logically awesome.
Keep it logically awesome.
Encourage flow.
It's not fully shipped until it's fast.
Favor focus over features.
Responsive is better than fast.
Favor focus over features.
Mind your words, they are important.
It's not fully shipped until it's fast.
Mind your words, they are important.
Speak like a human.
Anything added dilutes everything else.
Responsive is better than fast.
Avoid administrative distraction.
Non-blocking is better than blocking.
Responsive is better than fast.
It's not fully shipped until it's fast.
Half measures are as bad as nothing at all.
Non-blocking is better than blocking.
",
+ "encoding": "base64"
+}
diff --git a/tests/fixtures/blob.txt b/tests/fixtures/blob.txt
new file mode 100644
index 0000000..2c187bb
--- /dev/null
+++ b/tests/fixtures/blob.txt
@@ -0,0 +1,4998 @@
+Keep it logically awesome.
+Mind your words, they are important.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Responsive is better than fast.
+Favor focus over features.
+Keep it logically awesome.
+Approachable is better than simple.
+Responsive is better than fast.
+Keep it logically awesome.
+Approachable is better than simple.
+Encourage flow.
+Speak like a human.
+Anything added dilutes everything else.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+Anything added dilutes everything else.
+Approachable is better than simple.
+Avoid administrative distraction.
+Approachable is better than simple.
+Encourage flow.
+Practicality beats purity.
+Approachable is better than simple.
+Avoid administrative distraction.
+Non-blocking is better than blocking.
+Favor focus over features.
+Half measures are as bad as nothing at all.
+Responsive is better than fast.
+Design for failure.
+Responsive is better than fast.
+Keep it logically awesome.
+Design for failure.
+Non-blocking is better than blocking.
+Responsive is better than fast.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Anything added dilutes everything else.
+Encourage flow.
+Avoid administrative distraction.
+Keep it logically awesome.
+Responsive is better than fast.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+Encourage flow.
+Anything added dilutes everything else.
+Speak like a human.
+Non-blocking is better than blocking.
+Practicality beats purity.
+Favor focus over features.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Encourage flow.
+It's not fully shipped until it's fast.
+Speak like a human.
+Keep it logically awesome.
+Design for failure.
+Responsive is better than fast.
+Non-blocking is better than blocking.
+Mind your words, they are important.
+Design for failure.
+Avoid administrative distraction.
+Design for failure.
+It's not fully shipped until it's fast.
+Avoid administrative distraction.
+Avoid administrative distraction.
+Anything added dilutes everything else.
+Encourage flow.
+Avoid administrative distraction.
+Encourage flow.
+Approachable is better than simple.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Responsive is better than fast.
+Design for failure.
+Speak like a human.
+Practicality beats purity.
+Avoid administrative distraction.
+Responsive is better than fast.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Approachable is better than simple.
+It's not fully shipped until it's fast.
+Keep it logically awesome.
+Encourage flow.
+Keep it logically awesome.
+Responsive is better than fast.
+Responsive is better than fast.
+Half measures are as bad as nothing at all.
+Avoid administrative distraction.
+Mind your words, they are important.
+Practicality beats purity.
+Mind your words, they are important.
+Favor focus over features.
+Keep it logically awesome.
+Anything added dilutes everything else.
+Speak like a human.
+It's not fully shipped until it's fast.
+Mind your words, they are important.
+Keep it logically awesome.
+Speak like a human.
+Encourage flow.
+Favor focus over features.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+Speak like a human.
+It's not fully shipped until it's fast.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Non-blocking is better than blocking.
+Mind your words, they are important.
+Responsive is better than fast.
+Speak like a human.
+Favor focus over features.
+Approachable is better than simple.
+Keep it logically awesome.
+Favor focus over features.
+Half measures are as bad as nothing at all.
+Avoid administrative distraction.
+Anything added dilutes everything else.
+Keep it logically awesome.
+Mind your words, they are important.
+Responsive is better than fast.
+Design for failure.
+Keep it logically awesome.
+Mind your words, they are important.
+Non-blocking is better than blocking.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+Practicality beats purity.
+Favor focus over features.
+Keep it logically awesome.
+Favor focus over features.
+Keep it logically awesome.
+Anything added dilutes everything else.
+Practicality beats purity.
+Mind your words, they are important.
+Anything added dilutes everything else.
+Speak like a human.
+It's not fully shipped until it's fast.
+Half measures are as bad as nothing at all.
+It's not fully shipped until it's fast.
+Design for failure.
+Non-blocking is better than blocking.
+Encourage flow.
+Practicality beats purity.
+Favor focus over features.
+Approachable is better than simple.
+Favor focus over features.
+Approachable is better than simple.
+Anything added dilutes everything else.
+Practicality beats purity.
+Responsive is better than fast.
+Avoid administrative distraction.
+It's not fully shipped until it's fast.
+It's not fully shipped until it's fast.
+Speak like a human.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Speak like a human.
+Practicality beats purity.
+Design for failure.
+Approachable is better than simple.
+Design for failure.
+Speak like a human.
+Approachable is better than simple.
+Design for failure.
+Encourage flow.
+Half measures are as bad as nothing at all.
+Mind your words, they are important.
+Responsive is better than fast.
+Responsive is better than fast.
+Mind your words, they are important.
+Favor focus over features.
+Practicality beats purity.
+Approachable is better than simple.
+Favor focus over features.
+Keep it logically awesome.
+Avoid administrative distraction.
+Avoid administrative distraction.
+Responsive is better than fast.
+Half measures are as bad as nothing at all.
+Design for failure.
+Design for failure.
+Encourage flow.
+Half measures are as bad as nothing at all.
+Speak like a human.
+Encourage flow.
+Speak like a human.
+Non-blocking is better than blocking.
+Half measures are as bad as nothing at all.
+Non-blocking is better than blocking.
+Mind your words, they are important.
+Half measures are as bad as nothing at all.
+Design for failure.
+Favor focus over features.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+It's not fully shipped until it's fast.
+Design for failure.
+Keep it logically awesome.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+Practicality beats purity.
+Approachable is better than simple.
+Approachable is better than simple.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+Keep it logically awesome.
+Responsive is better than fast.
+Non-blocking is better than blocking.
+Encourage flow.
+Mind your words, they are important.
+Speak like a human.
+Practicality beats purity.
+Approachable is better than simple.
+Keep it logically awesome.
+Practicality beats purity.
+Practicality beats purity.
+Mind your words, they are important.
+Design for failure.
+Responsive is better than fast.
+Approachable is better than simple.
+Design for failure.
+Encourage flow.
+Practicality beats purity.
+It's not fully shipped until it's fast.
+Anything added dilutes everything else.
+Half measures are as bad as nothing at all.
+Responsive is better than fast.
+Half measures are as bad as nothing at all.
+Keep it logically awesome.
+Half measures are as bad as nothing at all.
+Approachable is better than simple.
+Speak like a human.
+Avoid administrative distraction.
+Encourage flow.
+Non-blocking is better than blocking.
+Speak like a human.
+Encourage flow.
+Anything added dilutes everything else.
+Speak like a human.
+Practicality beats purity.
+Speak like a human.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+Keep it logically awesome.
+Responsive is better than fast.
+Design for failure.
+Approachable is better than simple.
+Non-blocking is better than blocking.
+Half measures are as bad as nothing at all.
+Speak like a human.
+Approachable is better than simple.
+Responsive is better than fast.
+Design for failure.
+Design for failure.
+Favor focus over features.
+Non-blocking is better than blocking.
+Speak like a human.
+Mind your words, they are important.
+Design for failure.
+Half measures are as bad as nothing at all.
+Practicality beats purity.
+Practicality beats purity.
+Keep it logically awesome.
+Encourage flow.
+Anything added dilutes everything else.
+Half measures are as bad as nothing at all.
+Encourage flow.
+Mind your words, they are important.
+Keep it logically awesome.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+Responsive is better than fast.
+Favor focus over features.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Responsive is better than fast.
+Half measures are as bad as nothing at all.
+Design for failure.
+Non-blocking is better than blocking.
+Mind your words, they are important.
+Practicality beats purity.
+Non-blocking is better than blocking.
+Encourage flow.
+Keep it logically awesome.
+Approachable is better than simple.
+Design for failure.
+Speak like a human.
+Half measures are as bad as nothing at all.
+Practicality beats purity.
+Encourage flow.
+Half measures are as bad as nothing at all.
+Favor focus over features.
+Mind your words, they are important.
+Speak like a human.
+Practicality beats purity.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+Keep it logically awesome.
+Responsive is better than fast.
+It's not fully shipped until it's fast.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Non-blocking is better than blocking.
+Mind your words, they are important.
+Approachable is better than simple.
+Non-blocking is better than blocking.
+Anything added dilutes everything else.
+Encourage flow.
+Mind your words, they are important.
+Approachable is better than simple.
+Avoid administrative distraction.
+Avoid administrative distraction.
+Speak like a human.
+Responsive is better than fast.
+Approachable is better than simple.
+Anything added dilutes everything else.
+Encourage flow.
+Anything added dilutes everything else.
+Half measures are as bad as nothing at all.
+Favor focus over features.
+Design for failure.
+Avoid administrative distraction.
+Design for failure.
+It's not fully shipped until it's fast.
+Half measures are as bad as nothing at all.
+Practicality beats purity.
+Encourage flow.
+Favor focus over features.
+It's not fully shipped until it's fast.
+Half measures are as bad as nothing at all.
+Practicality beats purity.
+Anything added dilutes everything else.
+Design for failure.
+Non-blocking is better than blocking.
+Keep it logically awesome.
+Favor focus over features.
+Responsive is better than fast.
+Mind your words, they are important.
+Encourage flow.
+Avoid administrative distraction.
+Keep it logically awesome.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+Approachable is better than simple.
+It's not fully shipped until it's fast.
+Responsive is better than fast.
+Keep it logically awesome.
+Mind your words, they are important.
+Responsive is better than fast.
+Keep it logically awesome.
+Approachable is better than simple.
+Non-blocking is better than blocking.
+Design for failure.
+Half measures are as bad as nothing at all.
+Responsive is better than fast.
+Practicality beats purity.
+Keep it logically awesome.
+Approachable is better than simple.
+Half measures are as bad as nothing at all.
+Favor focus over features.
+Practicality beats purity.
+Encourage flow.
+Avoid administrative distraction.
+Approachable is better than simple.
+Anything added dilutes everything else.
+Mind your words, they are important.
+Keep it logically awesome.
+Avoid administrative distraction.
+Speak like a human.
+Approachable is better than simple.
+Non-blocking is better than blocking.
+Speak like a human.
+Mind your words, they are important.
+Design for failure.
+Anything added dilutes everything else.
+Practicality beats purity.
+It's not fully shipped until it's fast.
+Speak like a human.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+Non-blocking is better than blocking.
+Avoid administrative distraction.
+Non-blocking is better than blocking.
+Avoid administrative distraction.
+Practicality beats purity.
+Speak like a human.
+Half measures are as bad as nothing at all.
+Anything added dilutes everything else.
+Speak like a human.
+Non-blocking is better than blocking.
+Speak like a human.
+Keep it logically awesome.
+Mind your words, they are important.
+Non-blocking is better than blocking.
+Mind your words, they are important.
+Avoid administrative distraction.
+Half measures are as bad as nothing at all.
+Design for failure.
+Design for failure.
+Favor focus over features.
+It's not fully shipped until it's fast.
+Avoid administrative distraction.
+Half measures are as bad as nothing at all.
+Favor focus over features.
+It's not fully shipped until it's fast.
+Speak like a human.
+Half measures are as bad as nothing at all.
+Encourage flow.
+Non-blocking is better than blocking.
+Favor focus over features.
+Anything added dilutes everything else.
+Keep it logically awesome.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Half measures are as bad as nothing at all.
+Approachable is better than simple.
+Responsive is better than fast.
+Design for failure.
+Design for failure.
+Encourage flow.
+Avoid administrative distraction.
+Approachable is better than simple.
+Design for failure.
+Design for failure.
+Encourage flow.
+It's not fully shipped until it's fast.
+Half measures are as bad as nothing at all.
+Design for failure.
+Anything added dilutes everything else.
+Half measures are as bad as nothing at all.
+Half measures are as bad as nothing at all.
+Practicality beats purity.
+Non-blocking is better than blocking.
+Practicality beats purity.
+It's not fully shipped until it's fast.
+Mind your words, they are important.
+Non-blocking is better than blocking.
+It's not fully shipped until it's fast.
+Design for failure.
+Encourage flow.
+Non-blocking is better than blocking.
+Design for failure.
+Non-blocking is better than blocking.
+Non-blocking is better than blocking.
+Half measures are as bad as nothing at all.
+Practicality beats purity.
+Speak like a human.
+Practicality beats purity.
+Responsive is better than fast.
+Speak like a human.
+Non-blocking is better than blocking.
+Half measures are as bad as nothing at all.
+Anything added dilutes everything else.
+Design for failure.
+Half measures are as bad as nothing at all.
+Non-blocking is better than blocking.
+Favor focus over features.
+Non-blocking is better than blocking.
+Speak like a human.
+Encourage flow.
+Anything added dilutes everything else.
+Favor focus over features.
+It's not fully shipped until it's fast.
+Responsive is better than fast.
+Responsive is better than fast.
+Keep it logically awesome.
+Practicality beats purity.
+Practicality beats purity.
+Design for failure.
+Design for failure.
+Mind your words, they are important.
+Keep it logically awesome.
+Anything added dilutes everything else.
+Half measures are as bad as nothing at all.
+Approachable is better than simple.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+It's not fully shipped until it's fast.
+Mind your words, they are important.
+Responsive is better than fast.
+Mind your words, they are important.
+Speak like a human.
+Practicality beats purity.
+Approachable is better than simple.
+Practicality beats purity.
+Keep it logically awesome.
+Responsive is better than fast.
+Anything added dilutes everything else.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Favor focus over features.
+Anything added dilutes everything else.
+Non-blocking is better than blocking.
+Practicality beats purity.
+Practicality beats purity.
+Non-blocking is better than blocking.
+Design for failure.
+Speak like a human.
+Avoid administrative distraction.
+Design for failure.
+Avoid administrative distraction.
+Favor focus over features.
+Half measures are as bad as nothing at all.
+Design for failure.
+Half measures are as bad as nothing at all.
+Responsive is better than fast.
+Half measures are as bad as nothing at all.
+Design for failure.
+Responsive is better than fast.
+Keep it logically awesome.
+Half measures are as bad as nothing at all.
+Design for failure.
+Mind your words, they are important.
+Mind your words, they are important.
+Non-blocking is better than blocking.
+Speak like a human.
+Favor focus over features.
+Non-blocking is better than blocking.
+Design for failure.
+Non-blocking is better than blocking.
+Non-blocking is better than blocking.
+Design for failure.
+Non-blocking is better than blocking.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+Responsive is better than fast.
+Half measures are as bad as nothing at all.
+It's not fully shipped until it's fast.
+Encourage flow.
+Favor focus over features.
+Half measures are as bad as nothing at all.
+Approachable is better than simple.
+Anything added dilutes everything else.
+It's not fully shipped until it's fast.
+Mind your words, they are important.
+Responsive is better than fast.
+Avoid administrative distraction.
+Speak like a human.
+Keep it logically awesome.
+Responsive is better than fast.
+Encourage flow.
+It's not fully shipped until it's fast.
+Design for failure.
+It's not fully shipped until it's fast.
+Practicality beats purity.
+Keep it logically awesome.
+Mind your words, they are important.
+Speak like a human.
+Favor focus over features.
+Design for failure.
+Encourage flow.
+It's not fully shipped until it's fast.
+Half measures are as bad as nothing at all.
+It's not fully shipped until it's fast.
+Encourage flow.
+Responsive is better than fast.
+Design for failure.
+Favor focus over features.
+Practicality beats purity.
+Anything added dilutes everything else.
+Mind your words, they are important.
+Design for failure.
+Responsive is better than fast.
+Avoid administrative distraction.
+Practicality beats purity.
+Responsive is better than fast.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Practicality beats purity.
+It's not fully shipped until it's fast.
+Half measures are as bad as nothing at all.
+Half measures are as bad as nothing at all.
+Responsive is better than fast.
+Half measures are as bad as nothing at all.
+Half measures are as bad as nothing at all.
+Practicality beats purity.
+Avoid administrative distraction.
+Mind your words, they are important.
+Favor focus over features.
+Half measures are as bad as nothing at all.
+It's not fully shipped until it's fast.
+Design for failure.
+Avoid administrative distraction.
+Half measures are as bad as nothing at all.
+Speak like a human.
+Non-blocking is better than blocking.
+Design for failure.
+Anything added dilutes everything else.
+Encourage flow.
+Keep it logically awesome.
+Speak like a human.
+It's not fully shipped until it's fast.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Anything added dilutes everything else.
+Practicality beats purity.
+Anything added dilutes everything else.
+Mind your words, they are important.
+Half measures are as bad as nothing at all.
+Mind your words, they are important.
+Avoid administrative distraction.
+Mind your words, they are important.
+Speak like a human.
+Non-blocking is better than blocking.
+Half measures are as bad as nothing at all.
+Favor focus over features.
+Responsive is better than fast.
+Responsive is better than fast.
+Mind your words, they are important.
+Avoid administrative distraction.
+Design for failure.
+Speak like a human.
+Favor focus over features.
+Encourage flow.
+Encourage flow.
+Avoid administrative distraction.
+Non-blocking is better than blocking.
+Mind your words, they are important.
+Encourage flow.
+Half measures are as bad as nothing at all.
+Approachable is better than simple.
+Practicality beats purity.
+Keep it logically awesome.
+Responsive is better than fast.
+Favor focus over features.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Speak like a human.
+Non-blocking is better than blocking.
+Anything added dilutes everything else.
+Non-blocking is better than blocking.
+Approachable is better than simple.
+Avoid administrative distraction.
+Avoid administrative distraction.
+Responsive is better than fast.
+Encourage flow.
+Keep it logically awesome.
+Responsive is better than fast.
+Responsive is better than fast.
+Responsive is better than fast.
+Mind your words, they are important.
+Approachable is better than simple.
+Practicality beats purity.
+Anything added dilutes everything else.
+Keep it logically awesome.
+Practicality beats purity.
+Responsive is better than fast.
+Approachable is better than simple.
+Anything added dilutes everything else.
+Keep it logically awesome.
+Encourage flow.
+Practicality beats purity.
+Anything added dilutes everything else.
+It's not fully shipped until it's fast.
+Speak like a human.
+It's not fully shipped until it's fast.
+Anything added dilutes everything else.
+It's not fully shipped until it's fast.
+Approachable is better than simple.
+Mind your words, they are important.
+Half measures are as bad as nothing at all.
+Non-blocking is better than blocking.
+Speak like a human.
+Non-blocking is better than blocking.
+Practicality beats purity.
+Favor focus over features.
+Favor focus over features.
+Anything added dilutes everything else.
+Half measures are as bad as nothing at all.
+Favor focus over features.
+It's not fully shipped until it's fast.
+Avoid administrative distraction.
+It's not fully shipped until it's fast.
+Half measures are as bad as nothing at all.
+Keep it logically awesome.
+Responsive is better than fast.
+Practicality beats purity.
+Favor focus over features.
+Half measures are as bad as nothing at all.
+Responsive is better than fast.
+Approachable is better than simple.
+Avoid administrative distraction.
+It's not fully shipped until it's fast.
+Anything added dilutes everything else.
+Favor focus over features.
+Design for failure.
+Mind your words, they are important.
+Favor focus over features.
+Half measures are as bad as nothing at all.
+It's not fully shipped until it's fast.
+Speak like a human.
+Favor focus over features.
+It's not fully shipped until it's fast.
+Non-blocking is better than blocking.
+Half measures are as bad as nothing at all.
+Half measures are as bad as nothing at all.
+Avoid administrative distraction.
+Anything added dilutes everything else.
+Keep it logically awesome.
+Practicality beats purity.
+Favor focus over features.
+Avoid administrative distraction.
+Non-blocking is better than blocking.
+Anything added dilutes everything else.
+Responsive is better than fast.
+Anything added dilutes everything else.
+Practicality beats purity.
+Non-blocking is better than blocking.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Responsive is better than fast.
+Design for failure.
+Mind your words, they are important.
+Approachable is better than simple.
+Encourage flow.
+Non-blocking is better than blocking.
+Non-blocking is better than blocking.
+It's not fully shipped until it's fast.
+Mind your words, they are important.
+Encourage flow.
+It's not fully shipped until it's fast.
+Responsive is better than fast.
+Non-blocking is better than blocking.
+Encourage flow.
+Mind your words, they are important.
+Practicality beats purity.
+Anything added dilutes everything else.
+Non-blocking is better than blocking.
+Favor focus over features.
+Mind your words, they are important.
+Half measures are as bad as nothing at all.
+Non-blocking is better than blocking.
+Avoid administrative distraction.
+Practicality beats purity.
+Speak like a human.
+Keep it logically awesome.
+It's not fully shipped until it's fast.
+Non-blocking is better than blocking.
+Anything added dilutes everything else.
+Favor focus over features.
+Approachable is better than simple.
+Non-blocking is better than blocking.
+Encourage flow.
+Avoid administrative distraction.
+Half measures are as bad as nothing at all.
+It's not fully shipped until it's fast.
+Mind your words, they are important.
+Keep it logically awesome.
+Favor focus over features.
+Avoid administrative distraction.
+Half measures are as bad as nothing at all.
+It's not fully shipped until it's fast.
+Responsive is better than fast.
+Keep it logically awesome.
+Encourage flow.
+Encourage flow.
+Avoid administrative distraction.
+Half measures are as bad as nothing at all.
+Responsive is better than fast.
+Responsive is better than fast.
+Avoid administrative distraction.
+Responsive is better than fast.
+Practicality beats purity.
+Keep it logically awesome.
+Approachable is better than simple.
+Keep it logically awesome.
+It's not fully shipped until it's fast.
+Keep it logically awesome.
+Approachable is better than simple.
+Responsive is better than fast.
+Keep it logically awesome.
+Keep it logically awesome.
+Encourage flow.
+Approachable is better than simple.
+Encourage flow.
+Non-blocking is better than blocking.
+Practicality beats purity.
+Encourage flow.
+Mind your words, they are important.
+Responsive is better than fast.
+It's not fully shipped until it's fast.
+Half measures are as bad as nothing at all.
+Non-blocking is better than blocking.
+Encourage flow.
+Design for failure.
+Favor focus over features.
+It's not fully shipped until it's fast.
+It's not fully shipped until it's fast.
+Speak like a human.
+Speak like a human.
+Speak like a human.
+Favor focus over features.
+Encourage flow.
+Speak like a human.
+Mind your words, they are important.
+Responsive is better than fast.
+Practicality beats purity.
+Mind your words, they are important.
+Non-blocking is better than blocking.
+It's not fully shipped until it's fast.
+Mind your words, they are important.
+Avoid administrative distraction.
+Half measures are as bad as nothing at all.
+Mind your words, they are important.
+Anything added dilutes everything else.
+Favor focus over features.
+Responsive is better than fast.
+Speak like a human.
+Mind your words, they are important.
+Favor focus over features.
+Avoid administrative distraction.
+Responsive is better than fast.
+Non-blocking is better than blocking.
+Design for failure.
+Non-blocking is better than blocking.
+Practicality beats purity.
+Favor focus over features.
+Design for failure.
+Design for failure.
+Favor focus over features.
+Responsive is better than fast.
+It's not fully shipped until it's fast.
+Design for failure.
+Half measures are as bad as nothing at all.
+Avoid administrative distraction.
+Non-blocking is better than blocking.
+Favor focus over features.
+Practicality beats purity.
+Mind your words, they are important.
+Anything added dilutes everything else.
+Favor focus over features.
+Encourage flow.
+Speak like a human.
+Favor focus over features.
+Half measures are as bad as nothing at all.
+Approachable is better than simple.
+Approachable is better than simple.
+Speak like a human.
+Design for failure.
+Speak like a human.
+Half measures are as bad as nothing at all.
+Non-blocking is better than blocking.
+Design for failure.
+Anything added dilutes everything else.
+Favor focus over features.
+Design for failure.
+Speak like a human.
+Half measures are as bad as nothing at all.
+Non-blocking is better than blocking.
+Half measures are as bad as nothing at all.
+Half measures are as bad as nothing at all.
+Non-blocking is better than blocking.
+Responsive is better than fast.
+Practicality beats purity.
+Approachable is better than simple.
+Mind your words, they are important.
+Speak like a human.
+Approachable is better than simple.
+Speak like a human.
+It's not fully shipped until it's fast.
+Half measures are as bad as nothing at all.
+Mind your words, they are important.
+Responsive is better than fast.
+Anything added dilutes everything else.
+Mind your words, they are important.
+Practicality beats purity.
+Favor focus over features.
+Design for failure.
+Design for failure.
+It's not fully shipped until it's fast.
+Practicality beats purity.
+Avoid administrative distraction.
+Half measures are as bad as nothing at all.
+Favor focus over features.
+Approachable is better than simple.
+Anything added dilutes everything else.
+Keep it logically awesome.
+Design for failure.
+Speak like a human.
+Keep it logically awesome.
+Mind your words, they are important.
+Design for failure.
+Approachable is better than simple.
+Avoid administrative distraction.
+It's not fully shipped until it's fast.
+Keep it logically awesome.
+Practicality beats purity.
+Mind your words, they are important.
+Encourage flow.
+Favor focus over features.
+Responsive is better than fast.
+Encourage flow.
+Practicality beats purity.
+Encourage flow.
+Avoid administrative distraction.
+Approachable is better than simple.
+Mind your words, they are important.
+Design for failure.
+Anything added dilutes everything else.
+Keep it logically awesome.
+Practicality beats purity.
+Speak like a human.
+Mind your words, they are important.
+Favor focus over features.
+Avoid administrative distraction.
+Non-blocking is better than blocking.
+It's not fully shipped until it's fast.
+Encourage flow.
+Favor focus over features.
+Non-blocking is better than blocking.
+Practicality beats purity.
+Practicality beats purity.
+Encourage flow.
+Non-blocking is better than blocking.
+Avoid administrative distraction.
+Responsive is better than fast.
+Anything added dilutes everything else.
+Responsive is better than fast.
+Keep it logically awesome.
+Speak like a human.
+Mind your words, they are important.
+Responsive is better than fast.
+Non-blocking is better than blocking.
+Keep it logically awesome.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Design for failure.
+Speak like a human.
+Responsive is better than fast.
+It's not fully shipped until it's fast.
+Speak like a human.
+Encourage flow.
+Keep it logically awesome.
+Keep it logically awesome.
+Practicality beats purity.
+Anything added dilutes everything else.
+Mind your words, they are important.
+Practicality beats purity.
+Anything added dilutes everything else.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Keep it logically awesome.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Approachable is better than simple.
+Favor focus over features.
+Keep it logically awesome.
+Approachable is better than simple.
+Favor focus over features.
+Practicality beats purity.
+Favor focus over features.
+Approachable is better than simple.
+Responsive is better than fast.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+It's not fully shipped until it's fast.
+Non-blocking is better than blocking.
+It's not fully shipped until it's fast.
+Encourage flow.
+Avoid administrative distraction.
+Responsive is better than fast.
+Half measures are as bad as nothing at all.
+Mind your words, they are important.
+Design for failure.
+Non-blocking is better than blocking.
+Anything added dilutes everything else.
+Speak like a human.
+Design for failure.
+Non-blocking is better than blocking.
+Non-blocking is better than blocking.
+Mind your words, they are important.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Design for failure.
+Practicality beats purity.
+Practicality beats purity.
+Encourage flow.
+Responsive is better than fast.
+Design for failure.
+It's not fully shipped until it's fast.
+Avoid administrative distraction.
+Responsive is better than fast.
+Half measures are as bad as nothing at all.
+Avoid administrative distraction.
+Non-blocking is better than blocking.
+It's not fully shipped until it's fast.
+Non-blocking is better than blocking.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+Design for failure.
+Half measures are as bad as nothing at all.
+Mind your words, they are important.
+Responsive is better than fast.
+Responsive is better than fast.
+Approachable is better than simple.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Keep it logically awesome.
+Responsive is better than fast.
+Non-blocking is better than blocking.
+Approachable is better than simple.
+Design for failure.
+Design for failure.
+Responsive is better than fast.
+Design for failure.
+Avoid administrative distraction.
+Anything added dilutes everything else.
+Half measures are as bad as nothing at all.
+Speak like a human.
+Encourage flow.
+Avoid administrative distraction.
+Approachable is better than simple.
+Speak like a human.
+Half measures are as bad as nothing at all.
+Mind your words, they are important.
+Design for failure.
+Design for failure.
+Speak like a human.
+Approachable is better than simple.
+Half measures are as bad as nothing at all.
+Keep it logically awesome.
+Approachable is better than simple.
+Practicality beats purity.
+Avoid administrative distraction.
+It's not fully shipped until it's fast.
+Encourage flow.
+Half measures are as bad as nothing at all.
+Approachable is better than simple.
+Non-blocking is better than blocking.
+Responsive is better than fast.
+Mind your words, they are important.
+Encourage flow.
+Practicality beats purity.
+Speak like a human.
+Keep it logically awesome.
+Practicality beats purity.
+Encourage flow.
+Design for failure.
+Practicality beats purity.
+Responsive is better than fast.
+Speak like a human.
+Design for failure.
+Keep it logically awesome.
+It's not fully shipped until it's fast.
+Practicality beats purity.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Responsive is better than fast.
+It's not fully shipped until it's fast.
+Half measures are as bad as nothing at all.
+Half measures are as bad as nothing at all.
+Encourage flow.
+Approachable is better than simple.
+Half measures are as bad as nothing at all.
+Speak like a human.
+Half measures are as bad as nothing at all.
+Encourage flow.
+Avoid administrative distraction.
+Mind your words, they are important.
+Practicality beats purity.
+Favor focus over features.
+Speak like a human.
+Speak like a human.
+Non-blocking is better than blocking.
+Responsive is better than fast.
+Mind your words, they are important.
+Practicality beats purity.
+Design for failure.
+Avoid administrative distraction.
+Speak like a human.
+Speak like a human.
+Half measures are as bad as nothing at all.
+Half measures are as bad as nothing at all.
+Anything added dilutes everything else.
+Keep it logically awesome.
+Encourage flow.
+Approachable is better than simple.
+Design for failure.
+Favor focus over features.
+Design for failure.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Keep it logically awesome.
+It's not fully shipped until it's fast.
+Approachable is better than simple.
+Practicality beats purity.
+Favor focus over features.
+Approachable is better than simple.
+Responsive is better than fast.
+Half measures are as bad as nothing at all.
+Favor focus over features.
+Approachable is better than simple.
+Avoid administrative distraction.
+Design for failure.
+Speak like a human.
+Design for failure.
+Responsive is better than fast.
+Speak like a human.
+Half measures are as bad as nothing at all.
+Half measures are as bad as nothing at all.
+Non-blocking is better than blocking.
+Half measures are as bad as nothing at all.
+Avoid administrative distraction.
+It's not fully shipped until it's fast.
+Encourage flow.
+Responsive is better than fast.
+Mind your words, they are important.
+Speak like a human.
+Keep it logically awesome.
+Responsive is better than fast.
+Approachable is better than simple.
+Encourage flow.
+Design for failure.
+Half measures are as bad as nothing at all.
+Keep it logically awesome.
+Practicality beats purity.
+Encourage flow.
+It's not fully shipped until it's fast.
+Responsive is better than fast.
+Design for failure.
+Speak like a human.
+Responsive is better than fast.
+Speak like a human.
+Responsive is better than fast.
+Practicality beats purity.
+Avoid administrative distraction.
+Favor focus over features.
+Responsive is better than fast.
+Mind your words, they are important.
+Mind your words, they are important.
+Approachable is better than simple.
+Encourage flow.
+Favor focus over features.
+Avoid administrative distraction.
+Mind your words, they are important.
+Mind your words, they are important.
+Half measures are as bad as nothing at all.
+Responsive is better than fast.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+It's not fully shipped until it's fast.
+Anything added dilutes everything else.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Non-blocking is better than blocking.
+Avoid administrative distraction.
+Approachable is better than simple.
+Mind your words, they are important.
+Favor focus over features.
+Encourage flow.
+Practicality beats purity.
+It's not fully shipped until it's fast.
+Practicality beats purity.
+Design for failure.
+Speak like a human.
+Practicality beats purity.
+Responsive is better than fast.
+Anything added dilutes everything else.
+Practicality beats purity.
+It's not fully shipped until it's fast.
+Practicality beats purity.
+Speak like a human.
+Encourage flow.
+Favor focus over features.
+Half measures are as bad as nothing at all.
+Design for failure.
+Mind your words, they are important.
+Responsive is better than fast.
+Avoid administrative distraction.
+Responsive is better than fast.
+Half measures are as bad as nothing at all.
+Non-blocking is better than blocking.
+Design for failure.
+Favor focus over features.
+Encourage flow.
+Practicality beats purity.
+Design for failure.
+Responsive is better than fast.
+Mind your words, they are important.
+Design for failure.
+Half measures are as bad as nothing at all.
+Encourage flow.
+Mind your words, they are important.
+Design for failure.
+Favor focus over features.
+Favor focus over features.
+Mind your words, they are important.
+Half measures are as bad as nothing at all.
+Non-blocking is better than blocking.
+Favor focus over features.
+Design for failure.
+Mind your words, they are important.
+Anything added dilutes everything else.
+Speak like a human.
+Favor focus over features.
+Speak like a human.
+Half measures are as bad as nothing at all.
+It's not fully shipped until it's fast.
+Mind your words, they are important.
+Encourage flow.
+Practicality beats purity.
+Anything added dilutes everything else.
+Responsive is better than fast.
+Approachable is better than simple.
+Non-blocking is better than blocking.
+Design for failure.
+Design for failure.
+Encourage flow.
+Responsive is better than fast.
+Avoid administrative distraction.
+Design for failure.
+It's not fully shipped until it's fast.
+Practicality beats purity.
+Design for failure.
+Responsive is better than fast.
+Speak like a human.
+Speak like a human.
+Keep it logically awesome.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Non-blocking is better than blocking.
+Avoid administrative distraction.
+Anything added dilutes everything else.
+Approachable is better than simple.
+Speak like a human.
+Half measures are as bad as nothing at all.
+Anything added dilutes everything else.
+Approachable is better than simple.
+Speak like a human.
+Encourage flow.
+Approachable is better than simple.
+Favor focus over features.
+Approachable is better than simple.
+Speak like a human.
+Mind your words, they are important.
+Favor focus over features.
+Responsive is better than fast.
+Mind your words, they are important.
+Speak like a human.
+Responsive is better than fast.
+Keep it logically awesome.
+Speak like a human.
+Favor focus over features.
+Encourage flow.
+Approachable is better than simple.
+Practicality beats purity.
+Mind your words, they are important.
+Anything added dilutes everything else.
+Half measures are as bad as nothing at all.
+Design for failure.
+Mind your words, they are important.
+Design for failure.
+Favor focus over features.
+Non-blocking is better than blocking.
+It's not fully shipped until it's fast.
+Non-blocking is better than blocking.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Responsive is better than fast.
+Practicality beats purity.
+Mind your words, they are important.
+Design for failure.
+Speak like a human.
+Mind your words, they are important.
+Responsive is better than fast.
+Approachable is better than simple.
+Responsive is better than fast.
+Practicality beats purity.
+Non-blocking is better than blocking.
+Practicality beats purity.
+Keep it logically awesome.
+It's not fully shipped until it's fast.
+Approachable is better than simple.
+Design for failure.
+Non-blocking is better than blocking.
+Responsive is better than fast.
+Encourage flow.
+Favor focus over features.
+Responsive is better than fast.
+Non-blocking is better than blocking.
+Design for failure.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+Mind your words, they are important.
+Anything added dilutes everything else.
+It's not fully shipped until it's fast.
+Practicality beats purity.
+Approachable is better than simple.
+Half measures are as bad as nothing at all.
+Favor focus over features.
+Keep it logically awesome.
+Practicality beats purity.
+Anything added dilutes everything else.
+Practicality beats purity.
+Favor focus over features.
+Encourage flow.
+Anything added dilutes everything else.
+Design for failure.
+Avoid administrative distraction.
+Encourage flow.
+Responsive is better than fast.
+Speak like a human.
+Design for failure.
+Favor focus over features.
+Mind your words, they are important.
+Responsive is better than fast.
+Keep it logically awesome.
+Favor focus over features.
+Anything added dilutes everything else.
+Design for failure.
+Responsive is better than fast.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+Design for failure.
+Encourage flow.
+Practicality beats purity.
+Approachable is better than simple.
+Responsive is better than fast.
+Speak like a human.
+Avoid administrative distraction.
+Encourage flow.
+Anything added dilutes everything else.
+It's not fully shipped until it's fast.
+Favor focus over features.
+It's not fully shipped until it's fast.
+Responsive is better than fast.
+Practicality beats purity.
+Design for failure.
+Practicality beats purity.
+Encourage flow.
+Approachable is better than simple.
+Encourage flow.
+Half measures are as bad as nothing at all.
+Avoid administrative distraction.
+Practicality beats purity.
+Approachable is better than simple.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Speak like a human.
+It's not fully shipped until it's fast.
+Anything added dilutes everything else.
+Practicality beats purity.
+Responsive is better than fast.
+Avoid administrative distraction.
+Anything added dilutes everything else.
+Responsive is better than fast.
+Non-blocking is better than blocking.
+It's not fully shipped until it's fast.
+Half measures are as bad as nothing at all.
+Encourage flow.
+Non-blocking is better than blocking.
+Speak like a human.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+Anything added dilutes everything else.
+Non-blocking is better than blocking.
+Practicality beats purity.
+Approachable is better than simple.
+Half measures are as bad as nothing at all.
+Practicality beats purity.
+Responsive is better than fast.
+Mind your words, they are important.
+Design for failure.
+Non-blocking is better than blocking.
+Encourage flow.
+Practicality beats purity.
+Anything added dilutes everything else.
+Encourage flow.
+Non-blocking is better than blocking.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Keep it logically awesome.
+Responsive is better than fast.
+Avoid administrative distraction.
+Anything added dilutes everything else.
+Approachable is better than simple.
+Keep it logically awesome.
+Half measures are as bad as nothing at all.
+Avoid administrative distraction.
+Design for failure.
+Half measures are as bad as nothing at all.
+It's not fully shipped until it's fast.
+It's not fully shipped until it's fast.
+Non-blocking is better than blocking.
+Approachable is better than simple.
+Avoid administrative distraction.
+Encourage flow.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+Anything added dilutes everything else.
+Encourage flow.
+Half measures are as bad as nothing at all.
+Responsive is better than fast.
+Non-blocking is better than blocking.
+Responsive is better than fast.
+Non-blocking is better than blocking.
+Mind your words, they are important.
+Favor focus over features.
+Responsive is better than fast.
+Speak like a human.
+Keep it logically awesome.
+Speak like a human.
+Design for failure.
+Non-blocking is better than blocking.
+Approachable is better than simple.
+Practicality beats purity.
+Design for failure.
+Avoid administrative distraction.
+Avoid administrative distraction.
+Approachable is better than simple.
+It's not fully shipped until it's fast.
+Encourage flow.
+Responsive is better than fast.
+Non-blocking is better than blocking.
+Favor focus over features.
+Favor focus over features.
+Approachable is better than simple.
+Anything added dilutes everything else.
+Practicality beats purity.
+Approachable is better than simple.
+Responsive is better than fast.
+Responsive is better than fast.
+Practicality beats purity.
+Favor focus over features.
+Encourage flow.
+Avoid administrative distraction.
+Approachable is better than simple.
+Practicality beats purity.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Keep it logically awesome.
+Practicality beats purity.
+Speak like a human.
+Encourage flow.
+Approachable is better than simple.
+Approachable is better than simple.
+Responsive is better than fast.
+Responsive is better than fast.
+Responsive is better than fast.
+Non-blocking is better than blocking.
+Design for failure.
+Speak like a human.
+Avoid administrative distraction.
+Practicality beats purity.
+Keep it logically awesome.
+Responsive is better than fast.
+Avoid administrative distraction.
+Keep it logically awesome.
+Avoid administrative distraction.
+Mind your words, they are important.
+Encourage flow.
+Design for failure.
+Favor focus over features.
+Speak like a human.
+Mind your words, they are important.
+Speak like a human.
+Encourage flow.
+Favor focus over features.
+Responsive is better than fast.
+Responsive is better than fast.
+Half measures are as bad as nothing at all.
+Responsive is better than fast.
+Anything added dilutes everything else.
+Non-blocking is better than blocking.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Design for failure.
+Anything added dilutes everything else.
+Half measures are as bad as nothing at all.
+Practicality beats purity.
+Approachable is better than simple.
+Responsive is better than fast.
+Design for failure.
+Non-blocking is better than blocking.
+It's not fully shipped until it's fast.
+Half measures are as bad as nothing at all.
+Responsive is better than fast.
+Encourage flow.
+Speak like a human.
+Design for failure.
+Keep it logically awesome.
+Approachable is better than simple.
+Favor focus over features.
+It's not fully shipped until it's fast.
+Mind your words, they are important.
+Responsive is better than fast.
+It's not fully shipped until it's fast.
+Practicality beats purity.
+Mind your words, they are important.
+Encourage flow.
+Keep it logically awesome.
+Practicality beats purity.
+Speak like a human.
+Encourage flow.
+Encourage flow.
+Responsive is better than fast.
+Encourage flow.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Half measures are as bad as nothing at all.
+Responsive is better than fast.
+Approachable is better than simple.
+It's not fully shipped until it's fast.
+Mind your words, they are important.
+Keep it logically awesome.
+Design for failure.
+Approachable is better than simple.
+Keep it logically awesome.
+Approachable is better than simple.
+Half measures are as bad as nothing at all.
+Keep it logically awesome.
+Mind your words, they are important.
+Design for failure.
+Practicality beats purity.
+Responsive is better than fast.
+Practicality beats purity.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+It's not fully shipped until it's fast.
+Practicality beats purity.
+It's not fully shipped until it's fast.
+Design for failure.
+Approachable is better than simple.
+Approachable is better than simple.
+Design for failure.
+Keep it logically awesome.
+Keep it logically awesome.
+Speak like a human.
+Keep it logically awesome.
+Keep it logically awesome.
+Approachable is better than simple.
+Keep it logically awesome.
+Design for failure.
+Avoid administrative distraction.
+Encourage flow.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Half measures are as bad as nothing at all.
+Mind your words, they are important.
+Keep it logically awesome.
+Encourage flow.
+Practicality beats purity.
+Avoid administrative distraction.
+Design for failure.
+Practicality beats purity.
+Speak like a human.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Half measures are as bad as nothing at all.
+Favor focus over features.
+Practicality beats purity.
+Anything added dilutes everything else.
+Design for failure.
+Responsive is better than fast.
+Anything added dilutes everything else.
+Speak like a human.
+Avoid administrative distraction.
+Keep it logically awesome.
+Design for failure.
+Non-blocking is better than blocking.
+Non-blocking is better than blocking.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Practicality beats purity.
+Design for failure.
+Responsive is better than fast.
+Encourage flow.
+Keep it logically awesome.
+Design for failure.
+Anything added dilutes everything else.
+Practicality beats purity.
+Speak like a human.
+Avoid administrative distraction.
+Approachable is better than simple.
+Favor focus over features.
+Approachable is better than simple.
+Keep it logically awesome.
+Favor focus over features.
+Keep it logically awesome.
+Design for failure.
+Mind your words, they are important.
+Avoid administrative distraction.
+Anything added dilutes everything else.
+Design for failure.
+Avoid administrative distraction.
+Encourage flow.
+Speak like a human.
+Mind your words, they are important.
+Anything added dilutes everything else.
+Practicality beats purity.
+Design for failure.
+Speak like a human.
+Practicality beats purity.
+Encourage flow.
+Approachable is better than simple.
+Design for failure.
+Encourage flow.
+Responsive is better than fast.
+Speak like a human.
+Non-blocking is better than blocking.
+Half measures are as bad as nothing at all.
+It's not fully shipped until it's fast.
+Avoid administrative distraction.
+Anything added dilutes everything else.
+It's not fully shipped until it's fast.
+Encourage flow.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Avoid administrative distraction.
+Practicality beats purity.
+Approachable is better than simple.
+Half measures are as bad as nothing at all.
+Practicality beats purity.
+Responsive is better than fast.
+Approachable is better than simple.
+Approachable is better than simple.
+Non-blocking is better than blocking.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Responsive is better than fast.
+Encourage flow.
+Approachable is better than simple.
+Non-blocking is better than blocking.
+Practicality beats purity.
+It's not fully shipped until it's fast.
+Half measures are as bad as nothing at all.
+Favor focus over features.
+Speak like a human.
+Keep it logically awesome.
+Encourage flow.
+Design for failure.
+Half measures are as bad as nothing at all.
+Speak like a human.
+Keep it logically awesome.
+Encourage flow.
+Half measures are as bad as nothing at all.
+Keep it logically awesome.
+Half measures are as bad as nothing at all.
+Approachable is better than simple.
+Design for failure.
+Approachable is better than simple.
+Design for failure.
+Encourage flow.
+Encourage flow.
+Speak like a human.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Encourage flow.
+Anything added dilutes everything else.
+Favor focus over features.
+Practicality beats purity.
+Mind your words, they are important.
+Non-blocking is better than blocking.
+Responsive is better than fast.
+Encourage flow.
+Responsive is better than fast.
+Responsive is better than fast.
+Anything added dilutes everything else.
+Keep it logically awesome.
+Half measures are as bad as nothing at all.
+Mind your words, they are important.
+Keep it logically awesome.
+Avoid administrative distraction.
+Favor focus over features.
+Half measures are as bad as nothing at all.
+Mind your words, they are important.
+Mind your words, they are important.
+Anything added dilutes everything else.
+Non-blocking is better than blocking.
+Practicality beats purity.
+Anything added dilutes everything else.
+Half measures are as bad as nothing at all.
+It's not fully shipped until it's fast.
+Encourage flow.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Favor focus over features.
+Speak like a human.
+Favor focus over features.
+Encourage flow.
+Keep it logically awesome.
+Speak like a human.
+Anything added dilutes everything else.
+Approachable is better than simple.
+Keep it logically awesome.
+Mind your words, they are important.
+Anything added dilutes everything else.
+Mind your words, they are important.
+Responsive is better than fast.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+Encourage flow.
+Keep it logically awesome.
+Half measures are as bad as nothing at all.
+Mind your words, they are important.
+Favor focus over features.
+Practicality beats purity.
+Favor focus over features.
+Responsive is better than fast.
+Favor focus over features.
+Approachable is better than simple.
+Encourage flow.
+Design for failure.
+It's not fully shipped until it's fast.
+Encourage flow.
+Keep it logically awesome.
+It's not fully shipped until it's fast.
+Responsive is better than fast.
+Speak like a human.
+Avoid administrative distraction.
+Practicality beats purity.
+Non-blocking is better than blocking.
+It's not fully shipped until it's fast.
+Responsive is better than fast.
+Speak like a human.
+Approachable is better than simple.
+Encourage flow.
+Practicality beats purity.
+Avoid administrative distraction.
+Encourage flow.
+Approachable is better than simple.
+Keep it logically awesome.
+Favor focus over features.
+Keep it logically awesome.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Encourage flow.
+Responsive is better than fast.
+Keep it logically awesome.
+Keep it logically awesome.
+Approachable is better than simple.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+Mind your words, they are important.
+Favor focus over features.
+Keep it logically awesome.
+Encourage flow.
+Approachable is better than simple.
+Anything added dilutes everything else.
+Non-blocking is better than blocking.
+Non-blocking is better than blocking.
+Favor focus over features.
+Keep it logically awesome.
+Responsive is better than fast.
+Avoid administrative distraction.
+Avoid administrative distraction.
+Avoid administrative distraction.
+Avoid administrative distraction.
+Practicality beats purity.
+Favor focus over features.
+It's not fully shipped until it's fast.
+It's not fully shipped until it's fast.
+Keep it logically awesome.
+Mind your words, they are important.
+Design for failure.
+Design for failure.
+Encourage flow.
+Encourage flow.
+Half measures are as bad as nothing at all.
+Speak like a human.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Encourage flow.
+Approachable is better than simple.
+Anything added dilutes everything else.
+Keep it logically awesome.
+Encourage flow.
+Speak like a human.
+Anything added dilutes everything else.
+Favor focus over features.
+Keep it logically awesome.
+Mind your words, they are important.
+Half measures are as bad as nothing at all.
+Design for failure.
+Avoid administrative distraction.
+It's not fully shipped until it's fast.
+Speak like a human.
+Approachable is better than simple.
+Speak like a human.
+Encourage flow.
+Non-blocking is better than blocking.
+Approachable is better than simple.
+Practicality beats purity.
+Favor focus over features.
+It's not fully shipped until it's fast.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+Keep it logically awesome.
+Approachable is better than simple.
+Mind your words, they are important.
+Avoid administrative distraction.
+Keep it logically awesome.
+Approachable is better than simple.
+Responsive is better than fast.
+Avoid administrative distraction.
+Practicality beats purity.
+Mind your words, they are important.
+Favor focus over features.
+Keep it logically awesome.
+Approachable is better than simple.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Practicality beats purity.
+Keep it logically awesome.
+Half measures are as bad as nothing at all.
+Favor focus over features.
+Avoid administrative distraction.
+Design for failure.
+Responsive is better than fast.
+Practicality beats purity.
+Speak like a human.
+Anything added dilutes everything else.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Responsive is better than fast.
+Non-blocking is better than blocking.
+Favor focus over features.
+Avoid administrative distraction.
+Encourage flow.
+Design for failure.
+Half measures are as bad as nothing at all.
+Half measures are as bad as nothing at all.
+Speak like a human.
+Favor focus over features.
+Design for failure.
+Non-blocking is better than blocking.
+Non-blocking is better than blocking.
+Practicality beats purity.
+Design for failure.
+Avoid administrative distraction.
+Design for failure.
+Anything added dilutes everything else.
+Speak like a human.
+Encourage flow.
+Avoid administrative distraction.
+Keep it logically awesome.
+Keep it logically awesome.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+Half measures are as bad as nothing at all.
+Design for failure.
+Anything added dilutes everything else.
+It's not fully shipped until it's fast.
+Speak like a human.
+Anything added dilutes everything else.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Non-blocking is better than blocking.
+Favor focus over features.
+Approachable is better than simple.
+Encourage flow.
+Design for failure.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+Favor focus over features.
+Anything added dilutes everything else.
+Non-blocking is better than blocking.
+It's not fully shipped until it's fast.
+It's not fully shipped until it's fast.
+Anything added dilutes everything else.
+Favor focus over features.
+Keep it logically awesome.
+Keep it logically awesome.
+Anything added dilutes everything else.
+Keep it logically awesome.
+Half measures are as bad as nothing at all.
+Encourage flow.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Avoid administrative distraction.
+Keep it logically awesome.
+Mind your words, they are important.
+Non-blocking is better than blocking.
+Favor focus over features.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Avoid administrative distraction.
+Avoid administrative distraction.
+Speak like a human.
+Avoid administrative distraction.
+Speak like a human.
+Encourage flow.
+Avoid administrative distraction.
+Responsive is better than fast.
+Avoid administrative distraction.
+Approachable is better than simple.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+Favor focus over features.
+Non-blocking is better than blocking.
+Mind your words, they are important.
+Speak like a human.
+Favor focus over features.
+Encourage flow.
+Favor focus over features.
+Avoid administrative distraction.
+Design for failure.
+Anything added dilutes everything else.
+Non-blocking is better than blocking.
+It's not fully shipped until it's fast.
+Speak like a human.
+Encourage flow.
+Encourage flow.
+It's not fully shipped until it's fast.
+Mind your words, they are important.
+Non-blocking is better than blocking.
+Non-blocking is better than blocking.
+Anything added dilutes everything else.
+Approachable is better than simple.
+Avoid administrative distraction.
+It's not fully shipped until it's fast.
+Approachable is better than simple.
+Anything added dilutes everything else.
+Favor focus over features.
+Non-blocking is better than blocking.
+Keep it logically awesome.
+Favor focus over features.
+Design for failure.
+Design for failure.
+Speak like a human.
+Encourage flow.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+Keep it logically awesome.
+Keep it logically awesome.
+Anything added dilutes everything else.
+Mind your words, they are important.
+Mind your words, they are important.
+Favor focus over features.
+Responsive is better than fast.
+Non-blocking is better than blocking.
+Anything added dilutes everything else.
+Encourage flow.
+Encourage flow.
+Encourage flow.
+Keep it logically awesome.
+Approachable is better than simple.
+Approachable is better than simple.
+Speak like a human.
+Approachable is better than simple.
+Responsive is better than fast.
+Approachable is better than simple.
+Encourage flow.
+Practicality beats purity.
+Design for failure.
+Approachable is better than simple.
+Encourage flow.
+Encourage flow.
+Approachable is better than simple.
+Approachable is better than simple.
+It's not fully shipped until it's fast.
+Keep it logically awesome.
+Practicality beats purity.
+Practicality beats purity.
+Responsive is better than fast.
+Non-blocking is better than blocking.
+Practicality beats purity.
+Speak like a human.
+It's not fully shipped until it's fast.
+Speak like a human.
+Design for failure.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+Anything added dilutes everything else.
+Half measures are as bad as nothing at all.
+It's not fully shipped until it's fast.
+Anything added dilutes everything else.
+Mind your words, they are important.
+Anything added dilutes everything else.
+Responsive is better than fast.
+Anything added dilutes everything else.
+Encourage flow.
+Avoid administrative distraction.
+Keep it logically awesome.
+Keep it logically awesome.
+Responsive is better than fast.
+Encourage flow.
+Favor focus over features.
+Non-blocking is better than blocking.
+Favor focus over features.
+It's not fully shipped until it's fast.
+It's not fully shipped until it's fast.
+Encourage flow.
+Encourage flow.
+Responsive is better than fast.
+Responsive is better than fast.
+Speak like a human.
+Avoid administrative distraction.
+Favor focus over features.
+Design for failure.
+Encourage flow.
+Keep it logically awesome.
+Practicality beats purity.
+Approachable is better than simple.
+It's not fully shipped until it's fast.
+Half measures are as bad as nothing at all.
+Half measures are as bad as nothing at all.
+Encourage flow.
+Practicality beats purity.
+Favor focus over features.
+Favor focus over features.
+Practicality beats purity.
+Practicality beats purity.
+Design for failure.
+It's not fully shipped until it's fast.
+Keep it logically awesome.
+Half measures are as bad as nothing at all.
+Anything added dilutes everything else.
+Favor focus over features.
+Anything added dilutes everything else.
+Mind your words, they are important.
+Favor focus over features.
+Anything added dilutes everything else.
+Practicality beats purity.
+It's not fully shipped until it's fast.
+Design for failure.
+Non-blocking is better than blocking.
+Avoid administrative distraction.
+Favor focus over features.
+Avoid administrative distraction.
+Avoid administrative distraction.
+Approachable is better than simple.
+Keep it logically awesome.
+Avoid administrative distraction.
+Practicality beats purity.
+It's not fully shipped until it's fast.
+Mind your words, they are important.
+Design for failure.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Half measures are as bad as nothing at all.
+Design for failure.
+Encourage flow.
+Avoid administrative distraction.
+Speak like a human.
+Favor focus over features.
+It's not fully shipped until it's fast.
+Keep it logically awesome.
+Encourage flow.
+It's not fully shipped until it's fast.
+Responsive is better than fast.
+Speak like a human.
+Mind your words, they are important.
+Avoid administrative distraction.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Practicality beats purity.
+Speak like a human.
+Mind your words, they are important.
+Avoid administrative distraction.
+Half measures are as bad as nothing at all.
+Approachable is better than simple.
+Avoid administrative distraction.
+Avoid administrative distraction.
+Speak like a human.
+It's not fully shipped until it's fast.
+Anything added dilutes everything else.
+Responsive is better than fast.
+Half measures are as bad as nothing at all.
+Half measures are as bad as nothing at all.
+Mind your words, they are important.
+Mind your words, they are important.
+Practicality beats purity.
+Approachable is better than simple.
+Practicality beats purity.
+Avoid administrative distraction.
+Speak like a human.
+Mind your words, they are important.
+Favor focus over features.
+Non-blocking is better than blocking.
+Non-blocking is better than blocking.
+Responsive is better than fast.
+Design for failure.
+Half measures are as bad as nothing at all.
+Mind your words, they are important.
+Favor focus over features.
+Favor focus over features.
+Speak like a human.
+Speak like a human.
+It's not fully shipped until it's fast.
+Design for failure.
+Speak like a human.
+Favor focus over features.
+Approachable is better than simple.
+Avoid administrative distraction.
+Favor focus over features.
+Non-blocking is better than blocking.
+Keep it logically awesome.
+Favor focus over features.
+Encourage flow.
+Keep it logically awesome.
+Encourage flow.
+Encourage flow.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+Keep it logically awesome.
+It's not fully shipped until it's fast.
+Responsive is better than fast.
+Mind your words, they are important.
+Keep it logically awesome.
+Avoid administrative distraction.
+Responsive is better than fast.
+Non-blocking is better than blocking.
+Encourage flow.
+Approachable is better than simple.
+Anything added dilutes everything else.
+Encourage flow.
+Mind your words, they are important.
+Non-blocking is better than blocking.
+Encourage flow.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+It's not fully shipped until it's fast.
+Mind your words, they are important.
+Favor focus over features.
+Keep it logically awesome.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+It's not fully shipped until it's fast.
+Speak like a human.
+Avoid administrative distraction.
+Design for failure.
+Responsive is better than fast.
+Avoid administrative distraction.
+Approachable is better than simple.
+Practicality beats purity.
+Approachable is better than simple.
+Encourage flow.
+It's not fully shipped until it's fast.
+Responsive is better than fast.
+Practicality beats purity.
+Responsive is better than fast.
+Practicality beats purity.
+Design for failure.
+Favor focus over features.
+Responsive is better than fast.
+Non-blocking is better than blocking.
+Mind your words, they are important.
+Responsive is better than fast.
+Keep it logically awesome.
+Practicality beats purity.
+Design for failure.
+Half measures are as bad as nothing at all.
+Keep it logically awesome.
+Approachable is better than simple.
+Design for failure.
+Responsive is better than fast.
+Design for failure.
+Design for failure.
+Anything added dilutes everything else.
+Favor focus over features.
+Avoid administrative distraction.
+Practicality beats purity.
+Responsive is better than fast.
+Encourage flow.
+Encourage flow.
+Anything added dilutes everything else.
+Practicality beats purity.
+Design for failure.
+Approachable is better than simple.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+Design for failure.
+Mind your words, they are important.
+Anything added dilutes everything else.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Keep it logically awesome.
+Avoid administrative distraction.
+Avoid administrative distraction.
+Keep it logically awesome.
+Approachable is better than simple.
+Mind your words, they are important.
+Avoid administrative distraction.
+Non-blocking is better than blocking.
+Speak like a human.
+It's not fully shipped until it's fast.
+Anything added dilutes everything else.
+Favor focus over features.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Avoid administrative distraction.
+Keep it logically awesome.
+Anything added dilutes everything else.
+Keep it logically awesome.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Half measures are as bad as nothing at all.
+Encourage flow.
+Avoid administrative distraction.
+Approachable is better than simple.
+Design for failure.
+Approachable is better than simple.
+Favor focus over features.
+Mind your words, they are important.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+Favor focus over features.
+Mind your words, they are important.
+Design for failure.
+Avoid administrative distraction.
+Non-blocking is better than blocking.
+Practicality beats purity.
+Design for failure.
+Favor focus over features.
+Responsive is better than fast.
+Non-blocking is better than blocking.
+Favor focus over features.
+Half measures are as bad as nothing at all.
+Half measures are as bad as nothing at all.
+Encourage flow.
+Practicality beats purity.
+Avoid administrative distraction.
+Encourage flow.
+Responsive is better than fast.
+Practicality beats purity.
+Encourage flow.
+Non-blocking is better than blocking.
+Approachable is better than simple.
+Encourage flow.
+Encourage flow.
+Speak like a human.
+Half measures are as bad as nothing at all.
+Encourage flow.
+Approachable is better than simple.
+Encourage flow.
+Non-blocking is better than blocking.
+Keep it logically awesome.
+Responsive is better than fast.
+Speak like a human.
+Approachable is better than simple.
+Half measures are as bad as nothing at all.
+Mind your words, they are important.
+Responsive is better than fast.
+Mind your words, they are important.
+Non-blocking is better than blocking.
+Approachable is better than simple.
+Practicality beats purity.
+Design for failure.
+Responsive is better than fast.
+Mind your words, they are important.
+Responsive is better than fast.
+Design for failure.
+Half measures are as bad as nothing at all.
+Anything added dilutes everything else.
+Keep it logically awesome.
+Encourage flow.
+Approachable is better than simple.
+Speak like a human.
+Practicality beats purity.
+Design for failure.
+Encourage flow.
+Design for failure.
+Keep it logically awesome.
+Favor focus over features.
+Practicality beats purity.
+Favor focus over features.
+Anything added dilutes everything else.
+Favor focus over features.
+Design for failure.
+It's not fully shipped until it's fast.
+Encourage flow.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Speak like a human.
+Non-blocking is better than blocking.
+Anything added dilutes everything else.
+Responsive is better than fast.
+Design for failure.
+Speak like a human.
+Anything added dilutes everything else.
+It's not fully shipped until it's fast.
+It's not fully shipped until it's fast.
+Design for failure.
+Responsive is better than fast.
+Design for failure.
+Responsive is better than fast.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+Mind your words, they are important.
+Avoid administrative distraction.
+Approachable is better than simple.
+Keep it logically awesome.
+Approachable is better than simple.
+Design for failure.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Responsive is better than fast.
+Half measures are as bad as nothing at all.
+Encourage flow.
+Anything added dilutes everything else.
+Mind your words, they are important.
+Non-blocking is better than blocking.
+Encourage flow.
+Non-blocking is better than blocking.
+Speak like a human.
+Design for failure.
+Non-blocking is better than blocking.
+Half measures are as bad as nothing at all.
+Practicality beats purity.
+Design for failure.
+Encourage flow.
+Non-blocking is better than blocking.
+Avoid administrative distraction.
+Avoid administrative distraction.
+Favor focus over features.
+Mind your words, they are important.
+Non-blocking is better than blocking.
+Avoid administrative distraction.
+Encourage flow.
+Mind your words, they are important.
+Practicality beats purity.
+Non-blocking is better than blocking.
+It's not fully shipped until it's fast.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Speak like a human.
+It's not fully shipped until it's fast.
+Design for failure.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Responsive is better than fast.
+Responsive is better than fast.
+Non-blocking is better than blocking.
+Avoid administrative distraction.
+Favor focus over features.
+Design for failure.
+Encourage flow.
+Encourage flow.
+Favor focus over features.
+Practicality beats purity.
+Design for failure.
+Mind your words, they are important.
+Encourage flow.
+Avoid administrative distraction.
+It's not fully shipped until it's fast.
+Encourage flow.
+Half measures are as bad as nothing at all.
+Keep it logically awesome.
+Keep it logically awesome.
+Design for failure.
+Anything added dilutes everything else.
+Responsive is better than fast.
+Encourage flow.
+Half measures are as bad as nothing at all.
+Mind your words, they are important.
+Encourage flow.
+It's not fully shipped until it's fast.
+Avoid administrative distraction.
+Anything added dilutes everything else.
+Practicality beats purity.
+Keep it logically awesome.
+Practicality beats purity.
+Design for failure.
+Responsive is better than fast.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Keep it logically awesome.
+Speak like a human.
+Anything added dilutes everything else.
+Approachable is better than simple.
+Responsive is better than fast.
+Half measures are as bad as nothing at all.
+Non-blocking is better than blocking.
+Favor focus over features.
+Keep it logically awesome.
+Practicality beats purity.
+Avoid administrative distraction.
+Mind your words, they are important.
+Design for failure.
+Mind your words, they are important.
+Encourage flow.
+Non-blocking is better than blocking.
+Favor focus over features.
+Favor focus over features.
+Mind your words, they are important.
+Responsive is better than fast.
+Keep it logically awesome.
+Design for failure.
+Responsive is better than fast.
+Keep it logically awesome.
+Encourage flow.
+Speak like a human.
+Mind your words, they are important.
+Practicality beats purity.
+Favor focus over features.
+Design for failure.
+Design for failure.
+Approachable is better than simple.
+Responsive is better than fast.
+Speak like a human.
+Favor focus over features.
+Half measures are as bad as nothing at all.
+Anything added dilutes everything else.
+Design for failure.
+Keep it logically awesome.
+It's not fully shipped until it's fast.
+It's not fully shipped until it's fast.
+Anything added dilutes everything else.
+Non-blocking is better than blocking.
+Keep it logically awesome.
+Speak like a human.
+Practicality beats purity.
+Favor focus over features.
+Half measures are as bad as nothing at all.
+Avoid administrative distraction.
+Speak like a human.
+It's not fully shipped until it's fast.
+It's not fully shipped until it's fast.
+Approachable is better than simple.
+Design for failure.
+Mind your words, they are important.
+Anything added dilutes everything else.
+Favor focus over features.
+It's not fully shipped until it's fast.
+Practicality beats purity.
+Avoid administrative distraction.
+Speak like a human.
+Responsive is better than fast.
+Encourage flow.
+Responsive is better than fast.
+It's not fully shipped until it's fast.
+Design for failure.
+Keep it logically awesome.
+Favor focus over features.
+Approachable is better than simple.
+Design for failure.
+Anything added dilutes everything else.
+Approachable is better than simple.
+Mind your words, they are important.
+Speak like a human.
+Non-blocking is better than blocking.
+Non-blocking is better than blocking.
+Encourage flow.
+Responsive is better than fast.
+Mind your words, they are important.
+Practicality beats purity.
+Favor focus over features.
+Speak like a human.
+Half measures are as bad as nothing at all.
+Anything added dilutes everything else.
+Encourage flow.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Non-blocking is better than blocking.
+Avoid administrative distraction.
+Speak like a human.
+Practicality beats purity.
+Encourage flow.
+Practicality beats purity.
+It's not fully shipped until it's fast.
+Responsive is better than fast.
+Design for failure.
+Non-blocking is better than blocking.
+Responsive is better than fast.
+Responsive is better than fast.
+Practicality beats purity.
+Anything added dilutes everything else.
+Non-blocking is better than blocking.
+Responsive is better than fast.
+Favor focus over features.
+Mind your words, they are important.
+Design for failure.
+Mind your words, they are important.
+Practicality beats purity.
+Favor focus over features.
+Favor focus over features.
+Mind your words, they are important.
+Responsive is better than fast.
+Speak like a human.
+Design for failure.
+Non-blocking is better than blocking.
+Responsive is better than fast.
+Mind your words, they are important.
+Avoid administrative distraction.
+Design for failure.
+Half measures are as bad as nothing at all.
+Avoid administrative distraction.
+Practicality beats purity.
+Design for failure.
+It's not fully shipped until it's fast.
+Design for failure.
+Anything added dilutes everything else.
+Encourage flow.
+Approachable is better than simple.
+Favor focus over features.
+Design for failure.
+Mind your words, they are important.
+Keep it logically awesome.
+Practicality beats purity.
+Approachable is better than simple.
+Design for failure.
+Design for failure.
+Approachable is better than simple.
+Encourage flow.
+Favor focus over features.
+Practicality beats purity.
+Favor focus over features.
+Responsive is better than fast.
+Anything added dilutes everything else.
+Approachable is better than simple.
+Avoid administrative distraction.
+Half measures are as bad as nothing at all.
+Encourage flow.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+Mind your words, they are important.
+Mind your words, they are important.
+Approachable is better than simple.
+Half measures are as bad as nothing at all.
+It's not fully shipped until it's fast.
+Practicality beats purity.
+Mind your words, they are important.
+Favor focus over features.
+Keep it logically awesome.
+Speak like a human.
+Keep it logically awesome.
+Mind your words, they are important.
+Anything added dilutes everything else.
+Design for failure.
+Non-blocking is better than blocking.
+Half measures are as bad as nothing at all.
+Anything added dilutes everything else.
+Responsive is better than fast.
+It's not fully shipped until it's fast.
+Encourage flow.
+Half measures are as bad as nothing at all.
+Anything added dilutes everything else.
+Approachable is better than simple.
+Practicality beats purity.
+Design for failure.
+Anything added dilutes everything else.
+Responsive is better than fast.
+Non-blocking is better than blocking.
+It's not fully shipped until it's fast.
+Mind your words, they are important.
+Non-blocking is better than blocking.
+Avoid administrative distraction.
+Anything added dilutes everything else.
+Approachable is better than simple.
+It's not fully shipped until it's fast.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Keep it logically awesome.
+Mind your words, they are important.
+Half measures are as bad as nothing at all.
+Half measures are as bad as nothing at all.
+Speak like a human.
+Encourage flow.
+Mind your words, they are important.
+Favor focus over features.
+Practicality beats purity.
+Avoid administrative distraction.
+Mind your words, they are important.
+Non-blocking is better than blocking.
+Encourage flow.
+Keep it logically awesome.
+Responsive is better than fast.
+Anything added dilutes everything else.
+Favor focus over features.
+Encourage flow.
+Design for failure.
+Keep it logically awesome.
+Encourage flow.
+Non-blocking is better than blocking.
+Keep it logically awesome.
+Half measures are as bad as nothing at all.
+Responsive is better than fast.
+Practicality beats purity.
+Anything added dilutes everything else.
+Responsive is better than fast.
+Approachable is better than simple.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Avoid administrative distraction.
+Half measures are as bad as nothing at all.
+Approachable is better than simple.
+Favor focus over features.
+Practicality beats purity.
+Avoid administrative distraction.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+Half measures are as bad as nothing at all.
+Speak like a human.
+Encourage flow.
+Non-blocking is better than blocking.
+Encourage flow.
+Favor focus over features.
+Practicality beats purity.
+Approachable is better than simple.
+Approachable is better than simple.
+Favor focus over features.
+Non-blocking is better than blocking.
+Anything added dilutes everything else.
+Approachable is better than simple.
+Anything added dilutes everything else.
+It's not fully shipped until it's fast.
+Design for failure.
+Approachable is better than simple.
+Design for failure.
+Half measures are as bad as nothing at all.
+Encourage flow.
+Responsive is better than fast.
+Responsive is better than fast.
+Keep it logically awesome.
+Avoid administrative distraction.
+Approachable is better than simple.
+Mind your words, they are important.
+Speak like a human.
+Responsive is better than fast.
+Keep it logically awesome.
+Keep it logically awesome.
+Encourage flow.
+Speak like a human.
+Non-blocking is better than blocking.
+Responsive is better than fast.
+It's not fully shipped until it's fast.
+Responsive is better than fast.
+Favor focus over features.
+Approachable is better than simple.
+Speak like a human.
+Responsive is better than fast.
+Mind your words, they are important.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Design for failure.
+Speak like a human.
+Half measures are as bad as nothing at all.
+Approachable is better than simple.
+Mind your words, they are important.
+Keep it logically awesome.
+Keep it logically awesome.
+Encourage flow.
+Speak like a human.
+Speak like a human.
+Avoid administrative distraction.
+Mind your words, they are important.
+Non-blocking is better than blocking.
+Practicality beats purity.
+Favor focus over features.
+Approachable is better than simple.
+Favor focus over features.
+Avoid administrative distraction.
+Responsive is better than fast.
+Design for failure.
+It's not fully shipped until it's fast.
+Keep it logically awesome.
+Responsive is better than fast.
+Keep it logically awesome.
+Mind your words, they are important.
+Responsive is better than fast.
+Favor focus over features.
+Mind your words, they are important.
+Design for failure.
+Responsive is better than fast.
+Speak like a human.
+Responsive is better than fast.
+Speak like a human.
+Anything added dilutes everything else.
+Non-blocking is better than blocking.
+Favor focus over features.
+Practicality beats purity.
+Speak like a human.
+Avoid administrative distraction.
+Favor focus over features.
+Keep it logically awesome.
+Keep it logically awesome.
+Approachable is better than simple.
+Encourage flow.
+Avoid administrative distraction.
+Approachable is better than simple.
+Practicality beats purity.
+Keep it logically awesome.
+Keep it logically awesome.
+Keep it logically awesome.
+Speak like a human.
+Mind your words, they are important.
+Design for failure.
+Non-blocking is better than blocking.
+Responsive is better than fast.
+Practicality beats purity.
+Non-blocking is better than blocking.
+Mind your words, they are important.
+Non-blocking is better than blocking.
+Mind your words, they are important.
+Design for failure.
+Encourage flow.
+Avoid administrative distraction.
+Approachable is better than simple.
+Practicality beats purity.
+Speak like a human.
+Anything added dilutes everything else.
+Half measures are as bad as nothing at all.
+Approachable is better than simple.
+Favor focus over features.
+Speak like a human.
+Responsive is better than fast.
+Keep it logically awesome.
+Half measures are as bad as nothing at all.
+Mind your words, they are important.
+Favor focus over features.
+Encourage flow.
+Approachable is better than simple.
+Favor focus over features.
+Practicality beats purity.
+Speak like a human.
+It's not fully shipped until it's fast.
+Mind your words, they are important.
+Practicality beats purity.
+Approachable is better than simple.
+Speak like a human.
+Practicality beats purity.
+Favor focus over features.
+Responsive is better than fast.
+Approachable is better than simple.
+Speak like a human.
+Non-blocking is better than blocking.
+Half measures are as bad as nothing at all.
+Design for failure.
+Anything added dilutes everything else.
+It's not fully shipped until it's fast.
+Approachable is better than simple.
+It's not fully shipped until it's fast.
+Speak like a human.
+Favor focus over features.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+It's not fully shipped until it's fast.
+Approachable is better than simple.
+Anything added dilutes everything else.
+Design for failure.
+It's not fully shipped until it's fast.
+Avoid administrative distraction.
+Practicality beats purity.
+Speak like a human.
+Keep it logically awesome.
+Encourage flow.
+Avoid administrative distraction.
+Mind your words, they are important.
+Encourage flow.
+Responsive is better than fast.
+Encourage flow.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Half measures are as bad as nothing at all.
+It's not fully shipped until it's fast.
+Responsive is better than fast.
+Favor focus over features.
+Favor focus over features.
+Practicality beats purity.
+Practicality beats purity.
+Speak like a human.
+Design for failure.
+It's not fully shipped until it's fast.
+Design for failure.
+Approachable is better than simple.
+Keep it logically awesome.
+It's not fully shipped until it's fast.
+Mind your words, they are important.
+Practicality beats purity.
+Anything added dilutes everything else.
+Design for failure.
+Anything added dilutes everything else.
+Half measures are as bad as nothing at all.
+Avoid administrative distraction.
+Design for failure.
+Design for failure.
+Encourage flow.
+Half measures are as bad as nothing at all.
+Keep it logically awesome.
+Keep it logically awesome.
+Favor focus over features.
+Keep it logically awesome.
+Design for failure.
+Responsive is better than fast.
+Anything added dilutes everything else.
+Mind your words, they are important.
+Favor focus over features.
+Anything added dilutes everything else.
+Non-blocking is better than blocking.
+Mind your words, they are important.
+Practicality beats purity.
+Keep it logically awesome.
+Encourage flow.
+Encourage flow.
+Non-blocking is better than blocking.
+Speak like a human.
+Design for failure.
+Half measures are as bad as nothing at all.
+Anything added dilutes everything else.
+Speak like a human.
+Favor focus over features.
+Avoid administrative distraction.
+Encourage flow.
+Design for failure.
+It's not fully shipped until it's fast.
+Half measures are as bad as nothing at all.
+Design for failure.
+Anything added dilutes everything else.
+Mind your words, they are important.
+Speak like a human.
+Half measures are as bad as nothing at all.
+Practicality beats purity.
+Responsive is better than fast.
+Anything added dilutes everything else.
+Half measures are as bad as nothing at all.
+Practicality beats purity.
+Approachable is better than simple.
+Encourage flow.
+Keep it logically awesome.
+It's not fully shipped until it's fast.
+Keep it logically awesome.
+Speak like a human.
+Mind your words, they are important.
+Responsive is better than fast.
+Approachable is better than simple.
+Speak like a human.
+Design for failure.
+Anything added dilutes everything else.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Avoid administrative distraction.
+Encourage flow.
+Design for failure.
+Mind your words, they are important.
+Design for failure.
+Favor focus over features.
+Practicality beats purity.
+Approachable is better than simple.
+Non-blocking is better than blocking.
+Non-blocking is better than blocking.
+Keep it logically awesome.
+Encourage flow.
+Keep it logically awesome.
+Half measures are as bad as nothing at all.
+Speak like a human.
+Encourage flow.
+It's not fully shipped until it's fast.
+Speak like a human.
+Half measures are as bad as nothing at all.
+Encourage flow.
+Design for failure.
+Keep it logically awesome.
+Keep it logically awesome.
+Favor focus over features.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+Favor focus over features.
+Non-blocking is better than blocking.
+Mind your words, they are important.
+Approachable is better than simple.
+Approachable is better than simple.
+Half measures are as bad as nothing at all.
+Approachable is better than simple.
+Speak like a human.
+Non-blocking is better than blocking.
+It's not fully shipped until it's fast.
+It's not fully shipped until it's fast.
+It's not fully shipped until it's fast.
+Keep it logically awesome.
+Practicality beats purity.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Avoid administrative distraction.
+Avoid administrative distraction.
+Speak like a human.
+Approachable is better than simple.
+Encourage flow.
+Anything added dilutes everything else.
+Speak like a human.
+Favor focus over features.
+Practicality beats purity.
+It's not fully shipped until it's fast.
+Responsive is better than fast.
+Practicality beats purity.
+Approachable is better than simple.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Keep it logically awesome.
+Anything added dilutes everything else.
+Half measures are as bad as nothing at all.
+Design for failure.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+Design for failure.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+Keep it logically awesome.
+Half measures are as bad as nothing at all.
+Speak like a human.
+It's not fully shipped until it's fast.
+It's not fully shipped until it's fast.
+Half measures are as bad as nothing at all.
+Non-blocking is better than blocking.
+Mind your words, they are important.
+Anything added dilutes everything else.
+Responsive is better than fast.
+Encourage flow.
+Favor focus over features.
+Keep it logically awesome.
+Keep it logically awesome.
+Favor focus over features.
+Avoid administrative distraction.
+Approachable is better than simple.
+Practicality beats purity.
+Speak like a human.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Anything added dilutes everything else.
+Keep it logically awesome.
+Half measures are as bad as nothing at all.
+Non-blocking is better than blocking.
+It's not fully shipped until it's fast.
+Speak like a human.
+Half measures are as bad as nothing at all.
+It's not fully shipped until it's fast.
+Design for failure.
+Favor focus over features.
+Encourage flow.
+Encourage flow.
+Encourage flow.
+Non-blocking is better than blocking.
+Avoid administrative distraction.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Non-blocking is better than blocking.
+Non-blocking is better than blocking.
+Half measures are as bad as nothing at all.
+It's not fully shipped until it's fast.
+Approachable is better than simple.
+Approachable is better than simple.
+Encourage flow.
+Encourage flow.
+Practicality beats purity.
+Non-blocking is better than blocking.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Encourage flow.
+Responsive is better than fast.
+Responsive is better than fast.
+Encourage flow.
+Practicality beats purity.
+Speak like a human.
+Responsive is better than fast.
+Keep it logically awesome.
+Keep it logically awesome.
+Avoid administrative distraction.
+Avoid administrative distraction.
+Design for failure.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+Mind your words, they are important.
+Speak like a human.
+Keep it logically awesome.
+Approachable is better than simple.
+It's not fully shipped until it's fast.
+Responsive is better than fast.
+Encourage flow.
+Design for failure.
+Approachable is better than simple.
+Half measures are as bad as nothing at all.
+Speak like a human.
+Practicality beats purity.
+Design for failure.
+Approachable is better than simple.
+Half measures are as bad as nothing at all.
+Anything added dilutes everything else.
+Approachable is better than simple.
+Favor focus over features.
+Practicality beats purity.
+Anything added dilutes everything else.
+Speak like a human.
+Mind your words, they are important.
+Avoid administrative distraction.
+It's not fully shipped until it's fast.
+Approachable is better than simple.
+Practicality beats purity.
+It's not fully shipped until it's fast.
+Non-blocking is better than blocking.
+Half measures are as bad as nothing at all.
+Keep it logically awesome.
+Half measures are as bad as nothing at all.
+Mind your words, they are important.
+Half measures are as bad as nothing at all.
+Responsive is better than fast.
+Non-blocking is better than blocking.
+Anything added dilutes everything else.
+Design for failure.
+Encourage flow.
+Favor focus over features.
+Encourage flow.
+Encourage flow.
+Approachable is better than simple.
+Avoid administrative distraction.
+Design for failure.
+Favor focus over features.
+Half measures are as bad as nothing at all.
+Non-blocking is better than blocking.
+Practicality beats purity.
+Encourage flow.
+Practicality beats purity.
+Anything added dilutes everything else.
+Non-blocking is better than blocking.
+Keep it logically awesome.
+Keep it logically awesome.
+Design for failure.
+Favor focus over features.
+Encourage flow.
+Half measures are as bad as nothing at all.
+Half measures are as bad as nothing at all.
+Favor focus over features.
+Half measures are as bad as nothing at all.
+Mind your words, they are important.
+Keep it logically awesome.
+Anything added dilutes everything else.
+Keep it logically awesome.
+Encourage flow.
+Encourage flow.
+Avoid administrative distraction.
+Practicality beats purity.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Half measures are as bad as nothing at all.
+Speak like a human.
+Keep it logically awesome.
+Anything added dilutes everything else.
+Speak like a human.
+Keep it logically awesome.
+Encourage flow.
+Avoid administrative distraction.
+Approachable is better than simple.
+Non-blocking is better than blocking.
+Practicality beats purity.
+Favor focus over features.
+Keep it logically awesome.
+Keep it logically awesome.
+Design for failure.
+Mind your words, they are important.
+Responsive is better than fast.
+Responsive is better than fast.
+Favor focus over features.
+Speak like a human.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Design for failure.
+Approachable is better than simple.
+Approachable is better than simple.
+Non-blocking is better than blocking.
+Design for failure.
+Practicality beats purity.
+Anything added dilutes everything else.
+Favor focus over features.
+Encourage flow.
+It's not fully shipped until it's fast.
+Practicality beats purity.
+Approachable is better than simple.
+Mind your words, they are important.
+Favor focus over features.
+Encourage flow.
+Avoid administrative distraction.
+Keep it logically awesome.
+Mind your words, they are important.
+Responsive is better than fast.
+Half measures are as bad as nothing at all.
+Encourage flow.
+Favor focus over features.
+Favor focus over features.
+Mind your words, they are important.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+Encourage flow.
+Non-blocking is better than blocking.
+It's not fully shipped until it's fast.
+Speak like a human.
+Speak like a human.
+Encourage flow.
+Anything added dilutes everything else.
+It's not fully shipped until it's fast.
+Design for failure.
+Responsive is better than fast.
+Half measures are as bad as nothing at all.
+Non-blocking is better than blocking.
+Practicality beats purity.
+Responsive is better than fast.
+Anything added dilutes everything else.
+Keep it logically awesome.
+Encourage flow.
+Practicality beats purity.
+Responsive is better than fast.
+Practicality beats purity.
+Design for failure.
+Favor focus over features.
+Practicality beats purity.
+Approachable is better than simple.
+Encourage flow.
+Avoid administrative distraction.
+Responsive is better than fast.
+Practicality beats purity.
+It's not fully shipped until it's fast.
+Non-blocking is better than blocking.
+Approachable is better than simple.
+Non-blocking is better than blocking.
+Favor focus over features.
+Approachable is better than simple.
+Avoid administrative distraction.
+Half measures are as bad as nothing at all.
+Mind your words, they are important.
+Encourage flow.
+Mind your words, they are important.
+Non-blocking is better than blocking.
+Approachable is better than simple.
+It's not fully shipped until it's fast.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+Half measures are as bad as nothing at all.
+Practicality beats purity.
+Keep it logically awesome.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Approachable is better than simple.
+Speak like a human.
+Mind your words, they are important.
+Favor focus over features.
+Favor focus over features.
+Non-blocking is better than blocking.
+Approachable is better than simple.
+Design for failure.
+Approachable is better than simple.
+Mind your words, they are important.
+Keep it logically awesome.
+Keep it logically awesome.
+Practicality beats purity.
+Practicality beats purity.
+Approachable is better than simple.
+Mind your words, they are important.
+Speak like a human.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Design for failure.
+Anything added dilutes everything else.
+Mind your words, they are important.
+Anything added dilutes everything else.
+It's not fully shipped until it's fast.
+Mind your words, they are important.
+Anything added dilutes everything else.
+Encourage flow.
+Approachable is better than simple.
+Encourage flow.
+Mind your words, they are important.
+Favor focus over features.
+Design for failure.
+Half measures are as bad as nothing at all.
+Encourage flow.
+Approachable is better than simple.
+It's not fully shipped until it's fast.
+Practicality beats purity.
+Mind your words, they are important.
+Mind your words, they are important.
+Favor focus over features.
+Speak like a human.
+Favor focus over features.
+Design for failure.
+Design for failure.
+Speak like a human.
+Speak like a human.
+Design for failure.
+Speak like a human.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+Avoid administrative distraction.
+Half measures are as bad as nothing at all.
+Non-blocking is better than blocking.
+Non-blocking is better than blocking.
+Design for failure.
+It's not fully shipped until it's fast.
+It's not fully shipped until it's fast.
+Speak like a human.
+Responsive is better than fast.
+Encourage flow.
+Approachable is better than simple.
+Encourage flow.
+Favor focus over features.
+Design for failure.
+It's not fully shipped until it's fast.
+Non-blocking is better than blocking.
+Non-blocking is better than blocking.
+Encourage flow.
+Keep it logically awesome.
+Favor focus over features.
+Half measures are as bad as nothing at all.
+Speak like a human.
+Encourage flow.
+Anything added dilutes everything else.
+Speak like a human.
+Practicality beats purity.
+Encourage flow.
+Responsive is better than fast.
+Design for failure.
+It's not fully shipped until it's fast.
+Approachable is better than simple.
+Keep it logically awesome.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Anything added dilutes everything else.
+Speak like a human.
+Practicality beats purity.
+Design for failure.
+Half measures are as bad as nothing at all.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Speak like a human.
+Half measures are as bad as nothing at all.
+Avoid administrative distraction.
+Speak like a human.
+Non-blocking is better than blocking.
+Speak like a human.
+Avoid administrative distraction.
+Non-blocking is better than blocking.
+Approachable is better than simple.
+Anything added dilutes everything else.
+Favor focus over features.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Half measures are as bad as nothing at all.
+Keep it logically awesome.
+Practicality beats purity.
+Practicality beats purity.
+Design for failure.
+Design for failure.
+Speak like a human.
+Approachable is better than simple.
+Responsive is better than fast.
+It's not fully shipped until it's fast.
+Speak like a human.
+Encourage flow.
+Half measures are as bad as nothing at all.
+Speak like a human.
+Encourage flow.
+Approachable is better than simple.
+Favor focus over features.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+It's not fully shipped until it's fast.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Design for failure.
+Half measures are as bad as nothing at all.
+Responsive is better than fast.
+Design for failure.
+Encourage flow.
+Half measures are as bad as nothing at all.
+Half measures are as bad as nothing at all.
+Approachable is better than simple.
+Half measures are as bad as nothing at all.
+Approachable is better than simple.
+Avoid administrative distraction.
+Avoid administrative distraction.
+It's not fully shipped until it's fast.
+Speak like a human.
+Design for failure.
+Keep it logically awesome.
+Keep it logically awesome.
+Responsive is better than fast.
+Speak like a human.
+Design for failure.
+Mind your words, they are important.
+Mind your words, they are important.
+Half measures are as bad as nothing at all.
+Speak like a human.
+Approachable is better than simple.
+Speak like a human.
+Half measures are as bad as nothing at all.
+Avoid administrative distraction.
+Practicality beats purity.
+It's not fully shipped until it's fast.
+Approachable is better than simple.
+Anything added dilutes everything else.
+Speak like a human.
+Mind your words, they are important.
+Encourage flow.
+Half measures are as bad as nothing at all.
+Non-blocking is better than blocking.
+Half measures are as bad as nothing at all.
+Mind your words, they are important.
+Practicality beats purity.
+Design for failure.
+Speak like a human.
+Mind your words, they are important.
+Speak like a human.
+Favor focus over features.
+Non-blocking is better than blocking.
+Keep it logically awesome.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Approachable is better than simple.
+Anything added dilutes everything else.
+Encourage flow.
+Keep it logically awesome.
+Keep it logically awesome.
+Anything added dilutes everything else.
+Keep it logically awesome.
+Speak like a human.
+Anything added dilutes everything else.
+Design for failure.
+Practicality beats purity.
+Mind your words, they are important.
+Speak like a human.
+Keep it logically awesome.
+Half measures are as bad as nothing at all.
+Keep it logically awesome.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Responsive is better than fast.
+Responsive is better than fast.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Anything added dilutes everything else.
+Mind your words, they are important.
+Half measures are as bad as nothing at all.
+Design for failure.
+Approachable is better than simple.
+Design for failure.
+Mind your words, they are important.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+Half measures are as bad as nothing at all.
+Design for failure.
+Anything added dilutes everything else.
+Favor focus over features.
+Non-blocking is better than blocking.
+Encourage flow.
+Keep it logically awesome.
+Keep it logically awesome.
+Encourage flow.
+Non-blocking is better than blocking.
+Speak like a human.
+Approachable is better than simple.
+Avoid administrative distraction.
+Mind your words, they are important.
+Non-blocking is better than blocking.
+Half measures are as bad as nothing at all.
+Favor focus over features.
+Half measures are as bad as nothing at all.
+It's not fully shipped until it's fast.
+It's not fully shipped until it's fast.
+It's not fully shipped until it's fast.
+Avoid administrative distraction.
+Mind your words, they are important.
+Design for failure.
+Half measures are as bad as nothing at all.
+Encourage flow.
+Avoid administrative distraction.
+Approachable is better than simple.
+Anything added dilutes everything else.
+Practicality beats purity.
+Mind your words, they are important.
+Speak like a human.
+Keep it logically awesome.
+Design for failure.
+Encourage flow.
+Encourage flow.
+Anything added dilutes everything else.
+Half measures are as bad as nothing at all.
+It's not fully shipped until it's fast.
+It's not fully shipped until it's fast.
+Keep it logically awesome.
+Favor focus over features.
+Half measures are as bad as nothing at all.
+Speak like a human.
+Keep it logically awesome.
+Practicality beats purity.
+Avoid administrative distraction.
+Approachable is better than simple.
+Mind your words, they are important.
+Keep it logically awesome.
+Keep it logically awesome.
+It's not fully shipped until it's fast.
+Keep it logically awesome.
+Avoid administrative distraction.
+Anything added dilutes everything else.
+Approachable is better than simple.
+Speak like a human.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+Keep it logically awesome.
+Avoid administrative distraction.
+Responsive is better than fast.
+Responsive is better than fast.
+Half measures are as bad as nothing at all.
+Non-blocking is better than blocking.
+Responsive is better than fast.
+Speak like a human.
+Keep it logically awesome.
+Speak like a human.
+Responsive is better than fast.
+Non-blocking is better than blocking.
+Speak like a human.
+Half measures are as bad as nothing at all.
+Encourage flow.
+Avoid administrative distraction.
+Practicality beats purity.
+Non-blocking is better than blocking.
+Approachable is better than simple.
+Responsive is better than fast.
+Speak like a human.
+Keep it logically awesome.
+Mind your words, they are important.
+Non-blocking is better than blocking.
+Design for failure.
+Anything added dilutes everything else.
+Speak like a human.
+Encourage flow.
+Non-blocking is better than blocking.
+Encourage flow.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Approachable is better than simple.
+Responsive is better than fast.
+Speak like a human.
+Half measures are as bad as nothing at all.
+Half measures are as bad as nothing at all.
+It's not fully shipped until it's fast.
+Responsive is better than fast.
+Avoid administrative distraction.
+Practicality beats purity.
+Anything added dilutes everything else.
+Non-blocking is better than blocking.
+Non-blocking is better than blocking.
+Approachable is better than simple.
+Approachable is better than simple.
+Mind your words, they are important.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+Keep it logically awesome.
+Avoid administrative distraction.
+Practicality beats purity.
+Non-blocking is better than blocking.
+Non-blocking is better than blocking.
+Practicality beats purity.
+Avoid administrative distraction.
+Responsive is better than fast.
+It's not fully shipped until it's fast.
+Mind your words, they are important.
+Anything added dilutes everything else.
+Mind your words, they are important.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Non-blocking is better than blocking.
+Design for failure.
+Design for failure.
+Half measures are as bad as nothing at all.
+Speak like a human.
+Approachable is better than simple.
+Approachable is better than simple.
+Practicality beats purity.
+It's not fully shipped until it's fast.
+Half measures are as bad as nothing at all.
+Avoid administrative distraction.
+Avoid administrative distraction.
+Speak like a human.
+Keep it logically awesome.
+Favor focus over features.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Encourage flow.
+Approachable is better than simple.
+Approachable is better than simple.
+Responsive is better than fast.
+Practicality beats purity.
+Encourage flow.
+Encourage flow.
+It's not fully shipped until it's fast.
+Practicality beats purity.
+Mind your words, they are important.
+Practicality beats purity.
+Speak like a human.
+Favor focus over features.
+Half measures are as bad as nothing at all.
+Practicality beats purity.
+Practicality beats purity.
+Design for failure.
+Approachable is better than simple.
+Practicality beats purity.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+It's not fully shipped until it's fast.
+Speak like a human.
+Mind your words, they are important.
+Encourage flow.
+Avoid administrative distraction.
+Favor focus over features.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Responsive is better than fast.
+Approachable is better than simple.
+Encourage flow.
+Speak like a human.
+Mind your words, they are important.
+Non-blocking is better than blocking.
+Responsive is better than fast.
+Design for failure.
+Responsive is better than fast.
+Practicality beats purity.
+Keep it logically awesome.
+Mind your words, they are important.
+Avoid administrative distraction.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Favor focus over features.
+Responsive is better than fast.
+Non-blocking is better than blocking.
+Favor focus over features.
+Approachable is better than simple.
+Non-blocking is better than blocking.
+Non-blocking is better than blocking.
+Non-blocking is better than blocking.
+Responsive is better than fast.
+Approachable is better than simple.
+Half measures are as bad as nothing at all.
+It's not fully shipped until it's fast.
+Keep it logically awesome.
+Design for failure.
+Half measures are as bad as nothing at all.
+It's not fully shipped until it's fast.
+Non-blocking is better than blocking.
+Approachable is better than simple.
+Speak like a human.
+Encourage flow.
+It's not fully shipped until it's fast.
+Anything added dilutes everything else.
+It's not fully shipped until it's fast.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+Design for failure.
+Half measures are as bad as nothing at all.
+Encourage flow.
+Speak like a human.
+Keep it logically awesome.
+Responsive is better than fast.
+It's not fully shipped until it's fast.
+Design for failure.
+Approachable is better than simple.
+It's not fully shipped until it's fast.
+Half measures are as bad as nothing at all.
+Practicality beats purity.
+Practicality beats purity.
+Speak like a human.
+Approachable is better than simple.
+Mind your words, they are important.
+Encourage flow.
+Design for failure.
+Speak like a human.
+Avoid administrative distraction.
+Approachable is better than simple.
+Non-blocking is better than blocking.
+Speak like a human.
+Anything added dilutes everything else.
+It's not fully shipped until it's fast.
+Speak like a human.
+Responsive is better than fast.
+Avoid administrative distraction.
+Practicality beats purity.
+Mind your words, they are important.
+Encourage flow.
+Avoid administrative distraction.
+Keep it logically awesome.
+Favor focus over features.
+Practicality beats purity.
+Speak like a human.
+Keep it logically awesome.
+Avoid administrative distraction.
+Speak like a human.
+It's not fully shipped until it's fast.
+Practicality beats purity.
+Avoid administrative distraction.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Half measures are as bad as nothing at all.
+Half measures are as bad as nothing at all.
+Encourage flow.
+Encourage flow.
+Speak like a human.
+Avoid administrative distraction.
+Practicality beats purity.
+Approachable is better than simple.
+Anything added dilutes everything else.
+Favor focus over features.
+Mind your words, they are important.
+Avoid administrative distraction.
+Mind your words, they are important.
+Practicality beats purity.
+Design for failure.
+Responsive is better than fast.
+Anything added dilutes everything else.
+Approachable is better than simple.
+Speak like a human.
+Approachable is better than simple.
+Keep it logically awesome.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Approachable is better than simple.
+Favor focus over features.
+Encourage flow.
+Mind your words, they are important.
+Responsive is better than fast.
+Design for failure.
+Non-blocking is better than blocking.
+Favor focus over features.
+Speak like a human.
+Keep it logically awesome.
+Practicality beats purity.
+Mind your words, they are important.
+Responsive is better than fast.
+Half measures are as bad as nothing at all.
+Keep it logically awesome.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Half measures are as bad as nothing at all.
+Keep it logically awesome.
+Avoid administrative distraction.
+Favor focus over features.
+Keep it logically awesome.
+Half measures are as bad as nothing at all.
+Speak like a human.
+Keep it logically awesome.
+It's not fully shipped until it's fast.
+Speak like a human.
+Keep it logically awesome.
+Practicality beats purity.
+It's not fully shipped until it's fast.
+Practicality beats purity.
+Keep it logically awesome.
+Approachable is better than simple.
+It's not fully shipped until it's fast.
+Mind your words, they are important.
+Avoid administrative distraction.
+Responsive is better than fast.
+It's not fully shipped until it's fast.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+Half measures are as bad as nothing at all.
+Design for failure.
+Half measures are as bad as nothing at all.
+Non-blocking is better than blocking.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+Avoid administrative distraction.
+Speak like a human.
+Responsive is better than fast.
+It's not fully shipped until it's fast.
+Half measures are as bad as nothing at all.
+Keep it logically awesome.
+Anything added dilutes everything else.
+Speak like a human.
+Encourage flow.
+Responsive is better than fast.
+Keep it logically awesome.
+It's not fully shipped until it's fast.
+Non-blocking is better than blocking.
+Keep it logically awesome.
+It's not fully shipped until it's fast.
+Keep it logically awesome.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Favor focus over features.
+Approachable is better than simple.
+Avoid administrative distraction.
+Practicality beats purity.
+Mind your words, they are important.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Encourage flow.
+Design for failure.
+It's not fully shipped until it's fast.
+Practicality beats purity.
+Avoid administrative distraction.
+Approachable is better than simple.
+Practicality beats purity.
+Avoid administrative distraction.
+Approachable is better than simple.
+It's not fully shipped until it's fast.
+Encourage flow.
+Speak like a human.
+It's not fully shipped until it's fast.
+Half measures are as bad as nothing at all.
+Non-blocking is better than blocking.
+Speak like a human.
+Anything added dilutes everything else.
+Half measures are as bad as nothing at all.
+Non-blocking is better than blocking.
+Avoid administrative distraction.
+Responsive is better than fast.
+Non-blocking is better than blocking.
+Design for failure.
+Favor focus over features.
+Design for failure.
+Avoid administrative distraction.
+Anything added dilutes everything else.
+Favor focus over features.
+It's not fully shipped until it's fast.
+Mind your words, they are important.
+Encourage flow.
+Responsive is better than fast.
+Speak like a human.
+Anything added dilutes everything else.
+Speak like a human.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Non-blocking is better than blocking.
+Approachable is better than simple.
+Speak like a human.
+Keep it logically awesome.
+Responsive is better than fast.
+It's not fully shipped until it's fast.
+Design for failure.
+Mind your words, they are important.
+Speak like a human.
+Anything added dilutes everything else.
+Half measures are as bad as nothing at all.
+Keep it logically awesome.
+Half measures are as bad as nothing at all.
+Responsive is better than fast.
+Avoid administrative distraction.
+Half measures are as bad as nothing at all.
+It's not fully shipped until it's fast.
+It's not fully shipped until it's fast.
+Design for failure.
+Non-blocking is better than blocking.
+Half measures are as bad as nothing at all.
+Practicality beats purity.
+Favor focus over features.
+Non-blocking is better than blocking.
+Approachable is better than simple.
+Practicality beats purity.
+Design for failure.
+Design for failure.
+Design for failure.
+Anything added dilutes everything else.
+It's not fully shipped until it's fast.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Practicality beats purity.
+Non-blocking is better than blocking.
+Favor focus over features.
+Encourage flow.
+Favor focus over features.
+Keep it logically awesome.
+Avoid administrative distraction.
+Speak like a human.
+Encourage flow.
+Design for failure.
+Half measures are as bad as nothing at all.
+Non-blocking is better than blocking.
+Keep it logically awesome.
+Favor focus over features.
+Non-blocking is better than blocking.
+Anything added dilutes everything else.
+Responsive is better than fast.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Favor focus over features.
+Approachable is better than simple.
+It's not fully shipped until it's fast.
+Encourage flow.
+Practicality beats purity.
+Responsive is better than fast.
+Practicality beats purity.
+Speak like a human.
+Half measures are as bad as nothing at all.
+Anything added dilutes everything else.
+Keep it logically awesome.
+Half measures are as bad as nothing at all.
+Speak like a human.
+Anything added dilutes everything else.
+Keep it logically awesome.
+Encourage flow.
+Speak like a human.
+Approachable is better than simple.
+Encourage flow.
+Half measures are as bad as nothing at all.
+Design for failure.
+Half measures are as bad as nothing at all.
+Favor focus over features.
+Favor focus over features.
+Responsive is better than fast.
+Half measures are as bad as nothing at all.
+Speak like a human.
+Keep it logically awesome.
+Design for failure.
+Practicality beats purity.
+Speak like a human.
+Avoid administrative distraction.
+Speak like a human.
+Encourage flow.
+Anything added dilutes everything else.
+Mind your words, they are important.
+Half measures are as bad as nothing at all.
+It's not fully shipped until it's fast.
+Design for failure.
+It's not fully shipped until it's fast.
+Practicality beats purity.
+Approachable is better than simple.
+Half measures are as bad as nothing at all.
+Practicality beats purity.
+Practicality beats purity.
+Speak like a human.
+Non-blocking is better than blocking.
+Favor focus over features.
+Mind your words, they are important.
+Mind your words, they are important.
+Encourage flow.
+Mind your words, they are important.
+Favor focus over features.
+Anything added dilutes everything else.
+Approachable is better than simple.
+Encourage flow.
+Practicality beats purity.
+Anything added dilutes everything else.
+Practicality beats purity.
+Favor focus over features.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+Encourage flow.
+It's not fully shipped until it's fast.
+Responsive is better than fast.
+Approachable is better than simple.
+Keep it logically awesome.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Speak like a human.
+Keep it logically awesome.
+Design for failure.
+Design for failure.
+Speak like a human.
+Approachable is better than simple.
+Non-blocking is better than blocking.
+Responsive is better than fast.
+Non-blocking is better than blocking.
+Encourage flow.
+Avoid administrative distraction.
+Mind your words, they are important.
+Avoid administrative distraction.
+Responsive is better than fast.
+Half measures are as bad as nothing at all.
+Anything added dilutes everything else.
+It's not fully shipped until it's fast.
+Mind your words, they are important.
+Keep it logically awesome.
+Speak like a human.
+Keep it logically awesome.
+Design for failure.
+Practicality beats purity.
+Speak like a human.
+Responsive is better than fast.
+Design for failure.
+Speak like a human.
+Half measures are as bad as nothing at all.
+Encourage flow.
+Avoid administrative distraction.
+Encourage flow.
+Favor focus over features.
+Half measures are as bad as nothing at all.
+Half measures are as bad as nothing at all.
+Speak like a human.
+Speak like a human.
+Responsive is better than fast.
+Keep it logically awesome.
+Avoid administrative distraction.
+Non-blocking is better than blocking.
+Favor focus over features.
+Speak like a human.
+Approachable is better than simple.
+Encourage flow.
+Approachable is better than simple.
+Anything added dilutes everything else.
+Favor focus over features.
+Anything added dilutes everything else.
+Non-blocking is better than blocking.
+Mind your words, they are important.
+Favor focus over features.
+Approachable is better than simple.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+Practicality beats purity.
+Favor focus over features.
+Anything added dilutes everything else.
+Practicality beats purity.
+Encourage flow.
+Speak like a human.
+Half measures are as bad as nothing at all.
+Half measures are as bad as nothing at all.
+Practicality beats purity.
+It's not fully shipped until it's fast.
+Non-blocking is better than blocking.
+Keep it logically awesome.
+Avoid administrative distraction.
+Encourage flow.
+Half measures are as bad as nothing at all.
+Practicality beats purity.
+Design for failure.
+Avoid administrative distraction.
+Favor focus over features.
+Favor focus over features.
+Practicality beats purity.
+Practicality beats purity.
+Non-blocking is better than blocking.
+Approachable is better than simple.
+Responsive is better than fast.
+Favor focus over features.
+Approachable is better than simple.
+Favor focus over features.
+It's not fully shipped until it's fast.
+Keep it logically awesome.
+Design for failure.
+Favor focus over features.
+Avoid administrative distraction.
+Speak like a human.
+Mind your words, they are important.
+Half measures are as bad as nothing at all.
+Keep it logically awesome.
+Design for failure.
+Avoid administrative distraction.
+Half measures are as bad as nothing at all.
+Favor focus over features.
+Non-blocking is better than blocking.
+Practicality beats purity.
+Encourage flow.
+Responsive is better than fast.
+Half measures are as bad as nothing at all.
+Responsive is better than fast.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Favor focus over features.
+Non-blocking is better than blocking.
+Keep it logically awesome.
+It's not fully shipped until it's fast.
+Anything added dilutes everything else.
+Practicality beats purity.
+Non-blocking is better than blocking.
+Practicality beats purity.
+Anything added dilutes everything else.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Anything added dilutes everything else.
+It's not fully shipped until it's fast.
+Non-blocking is better than blocking.
+Mind your words, they are important.
+Keep it logically awesome.
+Responsive is better than fast.
+Anything added dilutes everything else.
+Encourage flow.
+Half measures are as bad as nothing at all.
+Anything added dilutes everything else.
+Approachable is better than simple.
+Responsive is better than fast.
+Half measures are as bad as nothing at all.
+Favor focus over features.
+Approachable is better than simple.
+It's not fully shipped until it's fast.
+Design for failure.
+Speak like a human.
+Practicality beats purity.
+Speak like a human.
+Practicality beats purity.
+Approachable is better than simple.
+It's not fully shipped until it's fast.
+Half measures are as bad as nothing at all.
+Approachable is better than simple.
+Speak like a human.
+Mind your words, they are important.
+Favor focus over features.
+Avoid administrative distraction.
+Encourage flow.
+Keep it logically awesome.
+Half measures are as bad as nothing at all.
+Favor focus over features.
+Half measures are as bad as nothing at all.
+Mind your words, they are important.
+Avoid administrative distraction.
+Design for failure.
+Non-blocking is better than blocking.
+Half measures are as bad as nothing at all.
+Practicality beats purity.
+It's not fully shipped until it's fast.
+Encourage flow.
+Mind your words, they are important.
+Non-blocking is better than blocking.
+Favor focus over features.
+Encourage flow.
+Favor focus over features.
+Practicality beats purity.
+Non-blocking is better than blocking.
+Non-blocking is better than blocking.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Favor focus over features.
+Responsive is better than fast.
+Encourage flow.
+Approachable is better than simple.
+Design for failure.
+Encourage flow.
+Design for failure.
+Practicality beats purity.
+Responsive is better than fast.
+Encourage flow.
+Avoid administrative distraction.
+Practicality beats purity.
+Mind your words, they are important.
+Speak like a human.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+Avoid administrative distraction.
+Anything added dilutes everything else.
+Encourage flow.
+It's not fully shipped until it's fast.
+Half measures are as bad as nothing at all.
+Approachable is better than simple.
+Favor focus over features.
+It's not fully shipped until it's fast.
+Avoid administrative distraction.
+Approachable is better than simple.
+Mind your words, they are important.
+Mind your words, they are important.
+Responsive is better than fast.
+Avoid administrative distraction.
+Approachable is better than simple.
+Avoid administrative distraction.
+It's not fully shipped until it's fast.
+Approachable is better than simple.
+Approachable is better than simple.
+Speak like a human.
+Avoid administrative distraction.
+Encourage flow.
+Approachable is better than simple.
+Speak like a human.
+Encourage flow.
+Speak like a human.
+Half measures are as bad as nothing at all.
+Responsive is better than fast.
+Anything added dilutes everything else.
+It's not fully shipped until it's fast.
+Keep it logically awesome.
+Mind your words, they are important.
+Half measures are as bad as nothing at all.
+Keep it logically awesome.
+Speak like a human.
+Half measures are as bad as nothing at all.
+Non-blocking is better than blocking.
+Responsive is better than fast.
+Anything added dilutes everything else.
+Practicality beats purity.
+Encourage flow.
+Anything added dilutes everything else.
+Encourage flow.
+Mind your words, they are important.
+Responsive is better than fast.
+It's not fully shipped until it's fast.
+It's not fully shipped until it's fast.
+Non-blocking is better than blocking.
+Speak like a human.
+Non-blocking is better than blocking.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+It's not fully shipped until it's fast.
+Keep it logically awesome.
+Mind your words, they are important.
+Approachable is better than simple.
+It's not fully shipped until it's fast.
+Anything added dilutes everything else.
+Keep it logically awesome.
+Responsive is better than fast.
+Favor focus over features.
+Practicality beats purity.
+Design for failure.
+Favor focus over features.
+Practicality beats purity.
+Favor focus over features.
+Design for failure.
+Anything added dilutes everything else.
+Approachable is better than simple.
+Speak like a human.
+Approachable is better than simple.
+Non-blocking is better than blocking.
+Responsive is better than fast.
+Practicality beats purity.
+Practicality beats purity.
+Avoid administrative distraction.
+Encourage flow.
+Practicality beats purity.
+Keep it logically awesome.
+Approachable is better than simple.
+Approachable is better than simple.
+Non-blocking is better than blocking.
+Non-blocking is better than blocking.
+Mind your words, they are important.
+Responsive is better than fast.
+It's not fully shipped until it's fast.
+Practicality beats purity.
+Keep it logically awesome.
+Half measures are as bad as nothing at all.
+Mind your words, they are important.
+Mind your words, they are important.
+Practicality beats purity.
+Approachable is better than simple.
+It's not fully shipped until it's fast.
+Practicality beats purity.
+Mind your words, they are important.
+Avoid administrative distraction.
+Favor focus over features.
+Design for failure.
+Responsive is better than fast.
+Responsive is better than fast.
+Favor focus over features.
+Keep it logically awesome.
+Speak like a human.
+Keep it logically awesome.
+Speak like a human.
+Half measures are as bad as nothing at all.
+Design for failure.
+Anything added dilutes everything else.
+Non-blocking is better than blocking.
+Half measures are as bad as nothing at all.
+Non-blocking is better than blocking.
+Half measures are as bad as nothing at all.
+Favor focus over features.
+Speak like a human.
+Speak like a human.
+Anything added dilutes everything else.
+Encourage flow.
+Encourage flow.
+Encourage flow.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+Non-blocking is better than blocking.
+Avoid administrative distraction.
+Mind your words, they are important.
+Avoid administrative distraction.
+Approachable is better than simple.
+Keep it logically awesome.
+Design for failure.
+Anything added dilutes everything else.
+Mind your words, they are important.
+Design for failure.
+Mind your words, they are important.
+Speak like a human.
+Responsive is better than fast.
+Mind your words, they are important.
+Half measures are as bad as nothing at all.
+Avoid administrative distraction.
+Non-blocking is better than blocking.
+Anything added dilutes everything else.
+Speak like a human.
+Avoid administrative distraction.
+Favor focus over features.
+Practicality beats purity.
+Anything added dilutes everything else.
+Speak like a human.
+Favor focus over features.
+Encourage flow.
+Mind your words, they are important.
+Half measures are as bad as nothing at all.
+Practicality beats purity.
+Speak like a human.
+Speak like a human.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+Half measures are as bad as nothing at all.
+Favor focus over features.
+Approachable is better than simple.
+Approachable is better than simple.
+Responsive is better than fast.
+Non-blocking is better than blocking.
+Favor focus over features.
+Encourage flow.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Speak like a human.
+It's not fully shipped until it's fast.
+Speak like a human.
+Design for failure.
+Design for failure.
+Responsive is better than fast.
+Responsive is better than fast.
+Speak like a human.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Encourage flow.
+Design for failure.
+Keep it logically awesome.
+Avoid administrative distraction.
+Speak like a human.
+Favor focus over features.
+Responsive is better than fast.
+Responsive is better than fast.
+Approachable is better than simple.
+Mind your words, they are important.
+Avoid administrative distraction.
+Non-blocking is better than blocking.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+Anything added dilutes everything else.
+Favor focus over features.
+Encourage flow.
+Avoid administrative distraction.
+Encourage flow.
+Favor focus over features.
+Non-blocking is better than blocking.
+Anything added dilutes everything else.
+Half measures are as bad as nothing at all.
+Avoid administrative distraction.
+Half measures are as bad as nothing at all.
+Anything added dilutes everything else.
+Keep it logically awesome.
+Anything added dilutes everything else.
+Half measures are as bad as nothing at all.
+Design for failure.
+Favor focus over features.
+Practicality beats purity.
+Avoid administrative distraction.
+Speak like a human.
+Approachable is better than simple.
+Avoid administrative distraction.
+Non-blocking is better than blocking.
+It's not fully shipped until it's fast.
+Half measures are as bad as nothing at all.
+Approachable is better than simple.
+Design for failure.
+Speak like a human.
+Favor focus over features.
+Responsive is better than fast.
+Design for failure.
+Responsive is better than fast.
+Keep it logically awesome.
+Favor focus over features.
+Non-blocking is better than blocking.
+Responsive is better than fast.
+Approachable is better than simple.
+Responsive is better than fast.
+Responsive is better than fast.
+Avoid administrative distraction.
+Non-blocking is better than blocking.
+Favor focus over features.
+Responsive is better than fast.
+Keep it logically awesome.
+Keep it logically awesome.
+Keep it logically awesome.
+It's not fully shipped until it's fast.
+Mind your words, they are important.
+Encourage flow.
+Avoid administrative distraction.
+Keep it logically awesome.
+Mind your words, they are important.
+Design for failure.
+Responsive is better than fast.
+Keep it logically awesome.
+Encourage flow.
+It's not fully shipped until it's fast.
+Responsive is better than fast.
+Mind your words, they are important.
+Responsive is better than fast.
+Avoid administrative distraction.
+It's not fully shipped until it's fast.
+Non-blocking is better than blocking.
+Mind your words, they are important.
+Speak like a human.
+Responsive is better than fast.
+Responsive is better than fast.
+Design for failure.
+Design for failure.
+Avoid administrative distraction.
+Design for failure.
+Non-blocking is better than blocking.
+Keep it logically awesome.
+Encourage flow.
+Design for failure.
+Keep it logically awesome.
+Favor focus over features.
+Design for failure.
+Keep it logically awesome.
+Responsive is better than fast.
+Responsive is better than fast.
+Favor focus over features.
+Design for failure.
+Keep it logically awesome.
+Encourage flow.
+Speak like a human.
+Approachable is better than simple.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Approachable is better than simple.
+It's not fully shipped until it's fast.
+Practicality beats purity.
+Keep it logically awesome.
+Encourage flow.
+Keep it logically awesome.
+Avoid administrative distraction.
+It's not fully shipped until it's fast.
+Keep it logically awesome.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+Half measures are as bad as nothing at all.
+Avoid administrative distraction.
+Keep it logically awesome.
+Favor focus over features.
+Responsive is better than fast.
+Speak like a human.
+Practicality beats purity.
+Avoid administrative distraction.
+Mind your words, they are important.
+Anything added dilutes everything else.
+Half measures are as bad as nothing at all.
+Encourage flow.
+Anything added dilutes everything else.
+Encourage flow.
+Keep it logically awesome.
+Avoid administrative distraction.
+Approachable is better than simple.
+Practicality beats purity.
+Favor focus over features.
+Mind your words, they are important.
+Half measures are as bad as nothing at all.
+Favor focus over features.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Speak like a human.
+Encourage flow.
+Speak like a human.
+Approachable is better than simple.
+Anything added dilutes everything else.
+Half measures are as bad as nothing at all.
+Anything added dilutes everything else.
+Speak like a human.
+Avoid administrative distraction.
+It's not fully shipped until it's fast.
+Speak like a human.
+Approachable is better than simple.
+Non-blocking is better than blocking.
+Approachable is better than simple.
+It's not fully shipped until it's fast.
+It's not fully shipped until it's fast.
+Approachable is better than simple.
+It's not fully shipped until it's fast.
+Practicality beats purity.
+It's not fully shipped until it's fast.
+Keep it logically awesome.
+Keep it logically awesome.
+Avoid administrative distraction.
+Anything added dilutes everything else.
+Half measures are as bad as nothing at all.
+Speak like a human.
+Half measures are as bad as nothing at all.
+Keep it logically awesome.
+Anything added dilutes everything else.
+Avoid administrative distraction.
+Keep it logically awesome.
+Encourage flow.
+Encourage flow.
+Keep it logically awesome.
+Responsive is better than fast.
+It's not fully shipped until it's fast.
+Mind your words, they are important.
+Practicality beats purity.
+Favor focus over features.
+Mind your words, they are important.
+Anything added dilutes everything else.
+Half measures are as bad as nothing at all.
+Mind your words, they are important.
+Half measures are as bad as nothing at all.
+Approachable is better than simple.
+Practicality beats purity.
+Speak like a human.
+Non-blocking is better than blocking.
+Approachable is better than simple.
+It's not fully shipped until it's fast.
+Anything added dilutes everything else.
+Design for failure.
+Mind your words, they are important.
+Design for failure.
+Approachable is better than simple.
+Practicality beats purity.
+Practicality beats purity.
+Speak like a human.
+Non-blocking is better than blocking.
+Design for failure.
+Speak like a human.
+It's not fully shipped until it's fast.
+Approachable is better than simple.
+Mind your words, they are important.
+Approachable is better than simple.
+Avoid administrative distraction.
+Anything added dilutes everything else.
+It's not fully shipped until it's fast.
+Approachable is better than simple.
+Responsive is better than fast.
+Responsive is better than fast.
+Approachable is better than simple.
+Anything added dilutes everything else.
+Non-blocking is better than blocking.
+Favor focus over features.
+Non-blocking is better than blocking.
+Keep it logically awesome.
+Approachable is better than simple.
+Mind your words, they are important.
+Half measures are as bad as nothing at all.
+Non-blocking is better than blocking.
+Mind your words, they are important.
+Avoid administrative distraction.
+Half measures are as bad as nothing at all.
+Half measures are as bad as nothing at all.
+Design for failure.
+Responsive is better than fast.
+Practicality beats purity.
+Mind your words, they are important.
+Design for failure.
+Practicality beats purity.
+Design for failure.
+Approachable is better than simple.
+Keep it logically awesome.
+Encourage flow.
+Approachable is better than simple.
+Speak like a human.
+Anything added dilutes everything else.
+Design for failure.
+Mind your words, they are important.
+Practicality beats purity.
+Speak like a human.
+Approachable is better than simple.
+Approachable is better than simple.
+Approachable is better than simple.
+Avoid administrative distraction.
+Design for failure.
+Avoid administrative distraction.
+Mind your words, they are important.
+Responsive is better than fast.
+Design for failure.
+Keep it logically awesome.
+Design for failure.
+Keep it logically awesome.
+Encourage flow.
+Non-blocking is better than blocking.
+Keep it logically awesome.
+It's not fully shipped until it's fast.
+Avoid administrative distraction.
+Responsive is better than fast.
+Anything added dilutes everything else.
+Half measures are as bad as nothing at all.
+Encourage flow.
+Avoid administrative distraction.
+Favor focus over features.
+Speak like a human.
+Avoid administrative distraction.
+Avoid administrative distraction.
+Approachable is better than simple.
+Avoid administrative distraction.
+Encourage flow.
+Favor focus over features.
+Avoid administrative distraction.
+Favor focus over features.
+Anything added dilutes everything else.
+It's not fully shipped until it's fast.
+Approachable is better than simple.
+Speak like a human.
+Responsive is better than fast.
+Avoid administrative distraction.
+Favor focus over features.
+Favor focus over features.
+Favor focus over features.
+Encourage flow.
+Half measures are as bad as nothing at all.
+Design for failure.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Encourage flow.
+Non-blocking is better than blocking.
+Keep it logically awesome.
+Anything added dilutes everything else.
+Design for failure.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Mind your words, they are important.
+Half measures are as bad as nothing at all.
+Encourage flow.
+It's not fully shipped until it's fast.
+Speak like a human.
+Keep it logically awesome.
+Design for failure.
+Anything added dilutes everything else.
+Practicality beats purity.
+Mind your words, they are important.
+Approachable is better than simple.
+Approachable is better than simple.
+Mind your words, they are important.
+Avoid administrative distraction.
+Keep it logically awesome.
+Anything added dilutes everything else.
+Responsive is better than fast.
+Responsive is better than fast.
+Design for failure.
+Mind your words, they are important.
+Half measures are as bad as nothing at all.
+Speak like a human.
+Non-blocking is better than blocking.
+Mind your words, they are important.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Practicality beats purity.
+Responsive is better than fast.
+It's not fully shipped until it's fast.
+Design for failure.
+Favor focus over features.
+Responsive is better than fast.
+Mind your words, they are important.
+Practicality beats purity.
+Responsive is better than fast.
+Keep it logically awesome.
+Half measures are as bad as nothing at all.
+Approachable is better than simple.
+Responsive is better than fast.
+Speak like a human.
+Avoid administrative distraction.
+Mind your words, they are important.
+Design for failure.
+Practicality beats purity.
+Anything added dilutes everything else.
+Anything added dilutes everything else.
+Mind your words, they are important.
+Half measures are as bad as nothing at all.
+It's not fully shipped until it's fast.
+Non-blocking is better than blocking.
+Half measures are as bad as nothing at all.
+Half measures are as bad as nothing at all.
+Anything added dilutes everything else.
+Responsive is better than fast.
+Half measures are as bad as nothing at all.
+Mind your words, they are important.
+Approachable is better than simple.
+Avoid administrative distraction.
+Design for failure.
+Practicality beats purity.
+Practicality beats purity.
+Keep it logically awesome.
+Keep it logically awesome.
+Responsive is better than fast.
+Design for failure.
+Anything added dilutes everything else.
+It's not fully shipped until it's fast.
+Practicality beats purity.
+Design for failure.
+Speak like a human.
+Half measures are as bad as nothing at all.
+It's not fully shipped until it's fast.
+Design for failure.
+It's not fully shipped until it's fast.
+Practicality beats purity.
+It's not fully shipped until it's fast.
+Practicality beats purity.
+Favor focus over features.
+Speak like a human.
+It's not fully shipped until it's fast.
+It's not fully shipped until it's fast.
+Anything added dilutes everything else.
+Practicality beats purity.
+Approachable is better than simple.
+Anything added dilutes everything else.
+Mind your words, they are important.
+Keep it logically awesome.
+Approachable is better than simple.
+Avoid administrative distraction.
+Encourage flow.
+Anything added dilutes everything else.
+Responsive is better than fast.
+Responsive is better than fast.
+Design for failure.
+It's not fully shipped until it's fast.
+Encourage flow.
+Speak like a human.
+Keep it logically awesome.
+Keep it logically awesome.
+Mind your words, they are important.
+Mind your words, they are important.
+Design for failure.
+Design for failure.
+Encourage flow.
+Design for failure.
+Avoid administrative distraction.
+Non-blocking is better than blocking.
+Encourage flow.
+Non-blocking is better than blocking.
+Approachable is better than simple.
+It's not fully shipped until it's fast.
+Keep it logically awesome.
+Practicality beats purity.
+Keep it logically awesome.
+Design for failure.
+Avoid administrative distraction.
+Non-blocking is better than blocking.
+Half measures are as bad as nothing at all.
+Design for failure.
+Avoid administrative distraction.
+Encourage flow.
+Speak like a human.
+Design for failure.
+Anything added dilutes everything else.
+Responsive is better than fast.
+Half measures are as bad as nothing at all.
+Avoid administrative distraction.
+Favor focus over features.
+Avoid administrative distraction.
+Mind your words, they are important.
+Responsive is better than fast.
+Speak like a human.
+Design for failure.
+Avoid administrative distraction.
+Mind your words, they are important.
+Mind your words, they are important.
+Responsive is better than fast.
+Half measures are as bad as nothing at all.
+Approachable is better than simple.
+Avoid administrative distraction.
+Avoid administrative distraction.
+Anything added dilutes everything else.
+It's not fully shipped until it's fast.
+Anything added dilutes everything else.
+Speak like a human.
+Design for failure.
+Design for failure.
+Encourage flow.
+Keep it logically awesome.
+It's not fully shipped until it's fast.
+Keep it logically awesome.
+Speak like a human.
+Non-blocking is better than blocking.
+Non-blocking is better than blocking.
+Avoid administrative distraction.
+Encourage flow.
+Non-blocking is better than blocking.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Favor focus over features.
+It's not fully shipped until it's fast.
+Design for failure.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Avoid administrative distraction.
+Encourage flow.
+Speak like a human.
+Encourage flow.
+Approachable is better than simple.
+Encourage flow.
+Design for failure.
+Non-blocking is better than blocking.
+Non-blocking is better than blocking.
+Mind your words, they are important.
+Design for failure.
+Approachable is better than simple.
+Avoid administrative distraction.
+Favor focus over features.
+Keep it logically awesome.
+Approachable is better than simple.
+Non-blocking is better than blocking.
+Half measures are as bad as nothing at all.
+Responsive is better than fast.
+Speak like a human.
+Mind your words, they are important.
+Favor focus over features.
+Practicality beats purity.
+Approachable is better than simple.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Non-blocking is better than blocking.
+Favor focus over features.
+Practicality beats purity.
+Approachable is better than simple.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+Speak like a human.
+Half measures are as bad as nothing at all.
+Avoid administrative distraction.
+Keep it logically awesome.
+Keep it logically awesome.
+Mind your words, they are important.
+Non-blocking is better than blocking.
+It's not fully shipped until it's fast.
+Practicality beats purity.
+Responsive is better than fast.
+Keep it logically awesome.
+It's not fully shipped until it's fast.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Keep it logically awesome.
+Practicality beats purity.
+Practicality beats purity.
+Encourage flow.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Practicality beats purity.
+Avoid administrative distraction.
+Speak like a human.
+Favor focus over features.
+Anything added dilutes everything else.
+Design for failure.
+It's not fully shipped until it's fast.
+Mind your words, they are important.
+Encourage flow.
+Anything added dilutes everything else.
+Non-blocking is better than blocking.
+Avoid administrative distraction.
+Approachable is better than simple.
+Anything added dilutes everything else.
+Keep it logically awesome.
+Keep it logically awesome.
+Speak like a human.
+Half measures are as bad as nothing at all.
+Favor focus over features.
+Encourage flow.
+Non-blocking is better than blocking.
+Encourage flow.
+Keep it logically awesome.
+Approachable is better than simple.
+Half measures are as bad as nothing at all.
+Design for failure.
+It's not fully shipped until it's fast.
+Mind your words, they are important.
+Speak like a human.
+Speak like a human.
+Avoid administrative distraction.
+Approachable is better than simple.
+Speak like a human.
+Mind your words, they are important.
+Speak like a human.
+Encourage flow.
+It's not fully shipped until it's fast.
+Keep it logically awesome.
+Half measures are as bad as nothing at all.
+Half measures are as bad as nothing at all.
+Anything added dilutes everything else.
+It's not fully shipped until it's fast.
+Responsive is better than fast.
+Favor focus over features.
+Encourage flow.
+Responsive is better than fast.
+Favor focus over features.
+Favor focus over features.
+Practicality beats purity.
+Encourage flow.
+Mind your words, they are important.
+Keep it logically awesome.
+Avoid administrative distraction.
+Mind your words, they are important.
+Design for failure.
+Approachable is better than simple.
+Encourage flow.
+Practicality beats purity.
+Favor focus over features.
+Avoid administrative distraction.
+Keep it logically awesome.
+Design for failure.
+Half measures are as bad as nothing at all.
+Avoid administrative distraction.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+Non-blocking is better than blocking.
+Approachable is better than simple.
+Favor focus over features.
+Design for failure.
+Keep it logically awesome.
+Anything added dilutes everything else.
+Practicality beats purity.
+Non-blocking is better than blocking.
+Favor focus over features.
+Half measures are as bad as nothing at all.
+Avoid administrative distraction.
+Encourage flow.
+Half measures are as bad as nothing at all.
+Favor focus over features.
+Favor focus over features.
+Favor focus over features.
+Encourage flow.
+Speak like a human.
+Design for failure.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Mind your words, they are important.
+Half measures are as bad as nothing at all.
+Keep it logically awesome.
+Responsive is better than fast.
+Approachable is better than simple.
+Responsive is better than fast.
+Responsive is better than fast.
+Approachable is better than simple.
+Design for failure.
+Half measures are as bad as nothing at all.
+Speak like a human.
+Speak like a human.
+Encourage flow.
+Responsive is better than fast.
+Mind your words, they are important.
+Non-blocking is better than blocking.
+Keep it logically awesome.
+Keep it logically awesome.
+Mind your words, they are important.
+Half measures are as bad as nothing at all.
+Mind your words, they are important.
+Favor focus over features.
+Design for failure.
+Speak like a human.
+Practicality beats purity.
+Favor focus over features.
+Responsive is better than fast.
+Speak like a human.
+Keep it logically awesome.
+Design for failure.
+Half measures are as bad as nothing at all.
+Speak like a human.
+Encourage flow.
+Design for failure.
+Responsive is better than fast.
+Mind your words, they are important.
+Avoid administrative distraction.
+Half measures are as bad as nothing at all.
+Non-blocking is better than blocking.
+Design for failure.
+Encourage flow.
+Encourage flow.
+Practicality beats purity.
+Favor focus over features.
+Favor focus over features.
+It's not fully shipped until it's fast.
+Speak like a human.
+Favor focus over features.
+Keep it logically awesome.
+Non-blocking is better than blocking.
+Anything added dilutes everything else.
+It's not fully shipped until it's fast.
+Keep it logically awesome.
+Approachable is better than simple.
+Responsive is better than fast.
+Practicality beats purity.
+It's not fully shipped until it's fast.
+Practicality beats purity.
+Practicality beats purity.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Responsive is better than fast.
+Favor focus over features.
+Encourage flow.
+Keep it logically awesome.
+Design for failure.
+Practicality beats purity.
+Approachable is better than simple.
+Avoid administrative distraction.
+Practicality beats purity.
+Non-blocking is better than blocking.
+Mind your words, they are important.
+Mind your words, they are important.
+Mind your words, they are important.
+Responsive is better than fast.
+Favor focus over features.
+It's not fully shipped until it's fast.
+Approachable is better than simple.
+Keep it logically awesome.
+It's not fully shipped until it's fast.
+Mind your words, they are important.
+Approachable is better than simple.
+Half measures are as bad as nothing at all.
+Anything added dilutes everything else.
+Favor focus over features.
+Mind your words, they are important.
+Avoid administrative distraction.
+It's not fully shipped until it's fast.
+Encourage flow.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Encourage flow.
+Keep it logically awesome.
+Avoid administrative distraction.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Approachable is better than simple.
+Keep it logically awesome.
+Approachable is better than simple.
+Half measures are as bad as nothing at all.
+Practicality beats purity.
+Encourage flow.
+Anything added dilutes everything else.
+Speak like a human.
+Keep it logically awesome.
+Practicality beats purity.
+Favor focus over features.
+Anything added dilutes everything else.
+Practicality beats purity.
+Responsive is better than fast.
+Design for failure.
+Speak like a human.
+Practicality beats purity.
+It's not fully shipped until it's fast.
+Design for failure.
+Design for failure.
+Practicality beats purity.
+Speak like a human.
+Mind your words, they are important.
+Anything added dilutes everything else.
+Speak like a human.
+Encourage flow.
+It's not fully shipped until it's fast.
+Keep it logically awesome.
+Half measures are as bad as nothing at all.
+Anything added dilutes everything else.
+Design for failure.
+Practicality beats purity.
+Favor focus over features.
+Favor focus over features.
+Responsive is better than fast.
+Approachable is better than simple.
+Half measures are as bad as nothing at all.
+Encourage flow.
+Encourage flow.
+Practicality beats purity.
+Half measures are as bad as nothing at all.
+Half measures are as bad as nothing at all.
+Encourage flow.
+Practicality beats purity.
+Speak like a human.
+Speak like a human.
+Non-blocking is better than blocking.
+Speak like a human.
+It's not fully shipped until it's fast.
+Responsive is better than fast.
+Design for failure.
+Avoid administrative distraction.
+Anything added dilutes everything else.
+Favor focus over features.
+Design for failure.
+Approachable is better than simple.
+Approachable is better than simple.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Encourage flow.
+Design for failure.
+Design for failure.
+Speak like a human.
+Approachable is better than simple.
+Keep it logically awesome.
+Mind your words, they are important.
+Anything added dilutes everything else.
+Responsive is better than fast.
+Responsive is better than fast.
+Avoid administrative distraction.
+Practicality beats purity.
+Responsive is better than fast.
+Approachable is better than simple.
+Non-blocking is better than blocking.
+Avoid administrative distraction.
+Encourage flow.
+Non-blocking is better than blocking.
+Speak like a human.
+Speak like a human.
+Avoid administrative distraction.
+Anything added dilutes everything else.
+Non-blocking is better than blocking.
+Keep it logically awesome.
+Keep it logically awesome.
+Encourage flow.
+It's not fully shipped until it's fast.
+Favor focus over features.
+Responsive is better than fast.
+Favor focus over features.
+Mind your words, they are important.
+It's not fully shipped until it's fast.
+Mind your words, they are important.
+Speak like a human.
+Anything added dilutes everything else.
+Responsive is better than fast.
+Avoid administrative distraction.
+Non-blocking is better than blocking.
+Responsive is better than fast.
+It's not fully shipped until it's fast.
+Half measures are as bad as nothing at all.
+Non-blocking is better than blocking.
diff --git a/tests/github-client.test.ts b/tests/github-client.test.ts
new file mode 100644
index 0000000..2d28c64
--- /dev/null
+++ b/tests/github-client.test.ts
@@ -0,0 +1,8 @@
+import github from "../lib/github-client";
+
+describe("github-client", () => {
+ test("user-agent", () => {
+ const ua = github.defaults.headers["user-agent"];
+ expect(ua).toMatch(/^@swinton\/commit\/\d+\.\d+\.\d+$/);
+ });
+});
diff --git a/tsconfig.json b/tsconfig.json
new file mode 100644
index 0000000..e0089e4
--- /dev/null
+++ b/tsconfig.json
@@ -0,0 +1,7 @@
+{
+ "compilerOptions": {
+ "target": "es2015",
+ "moduleResolution": "node",
+ "esModuleInterop": true /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
+ }
+}
diff --git a/zen.txt b/zen.txt
new file mode 100644
index 0000000..2b4ba07
--- /dev/null
+++ b/zen.txt
@@ -0,0 +1,2 @@
+Approachable is better than simple.
+Practicality beats purity.