diff --git a/.commitlintrc.js b/.commitlintrc.js
new file mode 100644
index 00000000..5b0b1a52
--- /dev/null
+++ b/.commitlintrc.js
@@ -0,0 +1,10 @@
+/* This file is automatically added by @npmcli/template-oss. Do not edit. */
+
+module.exports = {
+  extends: ['@commitlint/config-conventional'],
+  rules: {
+    'type-enum': [2, 'always', ['feat', 'fix', 'docs', 'deps', 'chore']],
+    'header-max-length': [2, 'always', 80],
+    'subject-case': [0, 'always', ['lower-case', 'sentence-case', 'start-case']],
+  },
+}
diff --git a/.eslintrc.js b/.eslintrc.js
new file mode 100644
index 00000000..f21d26ec
--- /dev/null
+++ b/.eslintrc.js
@@ -0,0 +1,20 @@
+/* This file is automatically added by @npmcli/template-oss. Do not edit. */
+
+'use strict'
+
+const { readdirSync: readdir } = require('fs')
+
+const localConfigs = readdir(__dirname)
+  .filter((file) => file.startsWith('.eslintrc.local.'))
+  .map((file) => `./${file}`)
+
+module.exports = {
+  root: true,
+  ignorePatterns: [
+    'tap-testdir*/',
+  ],
+  extends: [
+    '@npmcli',
+    ...localConfigs,
+  ],
+}
diff --git a/.eslintrc.local.js b/.eslintrc.local.js
new file mode 100644
index 00000000..5b7c98ea
--- /dev/null
+++ b/.eslintrc.local.js
@@ -0,0 +1,18 @@
+'use strict'
+
+module.exports = {
+  overrides: [
+    {
+      files: ['bin/**', 'classes/**', 'functions/**', 'internal/**', 'ranges/**'],
+      rules: {
+        'import/no-extraneous-dependencies': [
+          'error',
+          {
+            devDependencies: false,
+          },
+        ],
+        'import/no-nodejs-modules': ['error'],
+      },
+    },
+  ],
+}
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
new file mode 100644
index 00000000..2c54b0d2
--- /dev/null
+++ b/.github/CODEOWNERS
@@ -0,0 +1,3 @@
+# This file is automatically added by @npmcli/template-oss. Do not edit.
+
+* @npm/cli-team
diff --git a/.github/ISSUE_TEMPLATE/bug.yml b/.github/ISSUE_TEMPLATE/bug.yml
new file mode 100644
index 00000000..d043192f
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug.yml
@@ -0,0 +1,54 @@
+# This file is automatically added by @npmcli/template-oss. Do not edit.
+
+name: Bug
+description: File a bug/issue
+title: "[BUG] <title>"
+labels: [ Bug, Needs Triage ]
+
+body:
+  - type: checkboxes
+    attributes:
+      label: Is there an existing issue for this?
+      description: Please [search here](./issues) to see if an issue already exists for your problem.
+      options:
+        - label: I have searched the existing issues
+          required: true
+  - type: textarea
+    attributes:
+      label: Current Behavior
+      description: A clear & concise description of what you're experiencing.
+    validations:
+      required: false
+  - type: textarea
+    attributes:
+      label: Expected Behavior
+      description: A clear & concise description of what you expected to happen.
+    validations:
+      required: false
+  - type: textarea
+    attributes:
+      label: Steps To Reproduce
+      description: Steps to reproduce the behavior.
+      value: |
+        1. In this environment...
+        2. With this config...
+        3. Run '...'
+        4. See error...
+    validations:
+      required: false
+  - type: textarea
+    attributes:
+      label: Environment
+      description: |
+        examples:
+          - **npm**: 7.6.3
+          - **Node**: 13.14.0
+          - **OS**: Ubuntu 20.04
+          - **platform**: Macbook Pro
+      value: |
+        - npm:
+        - Node:
+        - OS:
+        - platform:
+    validations:
+      required: false
diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
new file mode 100644
index 00000000..d640909f
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,3 @@
+# This file is automatically added by @npmcli/template-oss. Do not edit.
+
+blank_issues_enabled: true
diff --git a/.github/actions/create-check/action.yml b/.github/actions/create-check/action.yml
new file mode 100644
index 00000000..0e7d6ce0
--- /dev/null
+++ b/.github/actions/create-check/action.yml
@@ -0,0 +1,52 @@
+# This file is automatically added by @npmcli/template-oss. Do not edit.
+
+name: 'Create Check'
+inputs:
+  name:
+    required: true
+  token:
+    required: true
+  sha:
+    required: true
+  check-name:
+    default: ''
+outputs:
+  check-id:
+    value: ${{ steps.create-check.outputs.check_id }}
+runs:
+  using: "composite"
+  steps:
+    - name: Get Workflow Job
+      uses: actions/github-script@v6
+      id: workflow
+      env:
+        JOB_NAME: "${{ inputs.name }}"
+        SHA: "${{ inputs.sha }}"
+      with:
+        result-encoding: string
+        script: |
+          const { repo: { owner, repo}, runId, serverUrl } = context          
+          const { JOB_NAME, SHA } = process.env
+
+          const job = await github.rest.actions.listJobsForWorkflowRun({
+            owner,
+            repo,
+            run_id: runId,
+            per_page: 100
+          }).then(r => r.data.jobs.find(j => j.name.endsWith(JOB_NAME)))
+
+          return [
+            `This check is assosciated with ${serverUrl}/${owner}/${repo}/commit/${SHA}.`,
+            'Run logs:',
+            job?.html_url || `could not be found for a job ending with: "${JOB_NAME}"`,
+          ].join(' ')
+    - name: Create Check
+      uses: LouisBrunner/checks-action@v1.6.0
+      id: create-check
+      with:
+        token: ${{ inputs.token }}
+        sha: ${{ inputs.sha }}
+        status: in_progress
+        name: ${{ inputs.check-name || inputs.name }}
+        output: |
+          {"summary":"${{ steps.workflow.outputs.result }}"}
diff --git a/.github/actions/install-latest-npm/action.yml b/.github/actions/install-latest-npm/action.yml
new file mode 100644
index 00000000..8339dbf0
--- /dev/null
+++ b/.github/actions/install-latest-npm/action.yml
@@ -0,0 +1,58 @@
+# This file is automatically added by @npmcli/template-oss. Do not edit.
+
+name: 'Install Latest npm'
+description: 'Install the latest version of npm compatible with the Node version'
+inputs:
+  node:
+    description: 'Current Node version'
+    required: true
+runs:
+  using: "composite"
+  steps:
+    # node 10/12/14 ship with npm@6, which is known to fail when updating itself in windows
+    - name: Update Windows npm
+      if: |
+        runner.os == 'Windows' && (
+          startsWith(inputs.node, 'v10.') ||
+          startsWith(inputs.node, 'v12.') ||
+          startsWith(inputs.node, 'v14.')
+        )
+      shell: cmd
+      run: |
+        curl -sO https://registry.npmjs.org/npm/-/npm-7.5.4.tgz
+        tar xf npm-7.5.4.tgz
+        cd package
+        node lib/npm.js install --no-fund --no-audit -g ..\npm-7.5.4.tgz
+        cd ..
+        rmdir /s /q package
+    - name: Install Latest npm
+      shell: bash
+      env:
+        NODE_VERSION: ${{ inputs.node }}
+      working-directory: ${{ runner.temp }}
+      run: |
+        MATCH=""
+        SPECS=("latest" "next-10" "next-9" "next-8" "next-7" "next-6")
+
+        echo "node@$NODE_VERSION"
+
+        for SPEC in ${SPECS[@]}; do
+          ENGINES=$(npm view npm@$SPEC --json | jq -r '.engines.node')
+          echo "Checking if node@$NODE_VERSION satisfies npm@$SPEC ($ENGINES)"
+
+          if npx semver -r "$ENGINES" "$NODE_VERSION" > /dev/null; then
+            MATCH=$SPEC
+            echo "Found compatible version: npm@$MATCH"
+            break
+          fi  
+        done
+
+        if [ -z $MATCH ]; then
+          echo "Could not find a compatible version of npm for node@$NODE_VERSION"
+          exit 1
+        fi
+
+        npm i --prefer-online --no-fund --no-audit -g npm@$MATCH
+    - name: npm Version
+      shell: bash
+      run: npm -v
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 00000000..d735ccf2
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,53 @@
+# This file is automatically added by @npmcli/template-oss. Do not edit.
+
+version: 2
+
+updates:
+  - package-ecosystem: npm
+    directory: /
+    schedule:
+      interval: daily
+    target-branch: "main"
+    allow:
+      - dependency-type: direct
+    versioning-strategy: increase-if-necessary
+    commit-message:
+      prefix: deps
+      prefix-development: chore
+    labels:
+      - "Dependencies"
+    open-pull-requests-limit: 10
+  - package-ecosystem: npm
+    directory: /
+    schedule:
+      interval: daily
+    target-branch: "release/v5"
+    allow:
+      - dependency-type: direct
+        dependency-name: "@npmcli/template-oss"
+    versioning-strategy: increase-if-necessary
+    commit-message:
+      prefix: deps
+      prefix-development: chore
+    labels:
+      - "Dependencies"
+      - "Backport"
+      - "release/v5"
+    open-pull-requests-limit: 10
+  - package-ecosystem: npm
+    directory: /
+    schedule:
+      interval: daily
+    target-branch: "release/v6"
+    allow:
+      - dependency-type: direct
+        dependency-name: "@npmcli/template-oss"
+    versioning-strategy: increase-if-necessary
+    commit-message:
+      prefix: deps
+      prefix-development: chore
+    labels:
+      - "Dependencies"
+      - "Backport"
+      - "release/v6"
+    open-pull-requests-limit: 10
diff --git a/.github/matchers/tap.json b/.github/matchers/tap.json
new file mode 100644
index 00000000..2c81ea98
--- /dev/null
+++ b/.github/matchers/tap.json
@@ -0,0 +1,32 @@
+{
+  "//@npmcli/template-oss": "This file is automatically added by @npmcli/template-oss. Do not edit.",
+  "problemMatcher": [
+    {
+      "owner": "tap",
+      "pattern": [
+        {
+          "regexp": "^\\s*not ok \\d+ - (.*)",
+          "message": 1
+        },
+        {
+          "regexp": "^\\s*---"
+        },
+        {
+          "regexp": "^\\s*at:"
+        },
+        {
+          "regexp": "^\\s*line:\\s*(\\d+)",
+          "line": 1
+        },
+        {
+          "regexp": "^\\s*column:\\s*(\\d+)",
+          "column": 1
+        },
+        {
+          "regexp": "^\\s*file:\\s*(.*)",
+          "file": 1
+        }
+      ]
+    }
+  ]
+}
diff --git a/.github/settings.yml b/.github/settings.yml
new file mode 100644
index 00000000..206b6eeb
--- /dev/null
+++ b/.github/settings.yml
@@ -0,0 +1,55 @@
+# This file is automatically added by @npmcli/template-oss. Do not edit.
+
+repository:
+  allow_merge_commit: false
+  allow_rebase_merge: true
+  allow_squash_merge: true
+  squash_merge_commit_title: PR_TITLE
+  squash_merge_commit_message: PR_BODY
+  delete_branch_on_merge: true
+  enable_automated_security_fixes: true
+  enable_vulnerability_alerts: true
+
+branches:
+  - name: main
+    protection:
+      required_status_checks: null
+      enforce_admins: true
+      block_creations: true
+      required_pull_request_reviews:
+        required_approving_review_count: 1
+        require_code_owner_reviews: true
+        require_last_push_approval: true
+        dismiss_stale_reviews: true
+      restrictions:
+        apps: []
+        users: []
+        teams: [ "cli-team" ]
+  - name: release/v5
+    protection:
+      required_status_checks: null
+      enforce_admins: true
+      block_creations: true
+      required_pull_request_reviews:
+        required_approving_review_count: 1
+        require_code_owner_reviews: true
+        require_last_push_approval: true
+        dismiss_stale_reviews: true
+      restrictions:
+        apps: []
+        users: []
+        teams: [ "cli-team" ]
+  - name: release/v6
+    protection:
+      required_status_checks: null
+      enforce_admins: true
+      block_creations: true
+      required_pull_request_reviews:
+        required_approving_review_count: 1
+        require_code_owner_reviews: true
+        require_last_push_approval: true
+        dismiss_stale_reviews: true
+      restrictions:
+        apps: []
+        users: []
+        teams: [ "cli-team" ]
diff --git a/.github/workflows/audit.yml b/.github/workflows/audit.yml
new file mode 100644
index 00000000..fa3163a8
--- /dev/null
+++ b/.github/workflows/audit.yml
@@ -0,0 +1,41 @@
+# This file is automatically added by @npmcli/template-oss. Do not edit.
+
+name: Audit
+
+on:
+  workflow_dispatch:
+  schedule:
+    # "At 08:00 UTC (01:00 PT) on Monday" https://crontab.guru/#0_8_*_*_1
+    - cron: "0 8 * * 1"
+
+jobs:
+  audit:
+    name: Audit Dependencies
+    if: github.repository_owner == 'npm'
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Setup Git User
+        run: |
+          git config --global user.email "npm-cli+bot@github.com"
+          git config --global user.name "npm CLI robot"
+      - name: Setup Node
+        uses: actions/setup-node@v3
+        id: node
+        with:
+          node-version: 20.x
+          check-latest: contains('20.x', '.x')
+      - name: Install Latest npm
+        uses: ./.github/actions/install-latest-npm
+        with:
+          node: ${{ steps.node.outputs.node-version }}
+      - name: Install Dependencies
+        run: npm i --ignore-scripts --no-audit --no-fund --package-lock
+      - name: Run Production Audit
+        run: npm audit --omit=dev
+      - name: Run Full Audit
+        run: npm audit --audit-level=none
diff --git a/.github/workflows/ci-release.yml b/.github/workflows/ci-release.yml
new file mode 100644
index 00000000..9f9c2a2a
--- /dev/null
+++ b/.github/workflows/ci-release.yml
@@ -0,0 +1,137 @@
+# This file is automatically added by @npmcli/template-oss. Do not edit.
+
+name: CI - Release
+
+on:
+  workflow_dispatch:
+    inputs:
+      ref:
+        required: true
+        type: string
+        default: main
+  workflow_call:
+    inputs:
+      ref:
+        required: true
+        type: string
+      check-sha:
+        required: true
+        type: string
+
+jobs:
+  lint-all:
+    name: Lint All
+    if: github.repository_owner == 'npm'
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          ref: ${{ inputs.ref }}
+      - name: Setup Git User
+        run: |
+          git config --global user.email "npm-cli+bot@github.com"
+          git config --global user.name "npm CLI robot"
+      - name: Create Check
+        id: create-check
+        if: ${{ inputs.check-sha }}
+        uses: ./.github/actions/create-check
+        with:
+          name: "Lint All"
+          token: ${{ secrets.GITHUB_TOKEN }}
+          sha: ${{ inputs.check-sha }}
+      - name: Setup Node
+        uses: actions/setup-node@v3
+        id: node
+        with:
+          node-version: 20.x
+          check-latest: contains('20.x', '.x')
+      - name: Install Latest npm
+        uses: ./.github/actions/install-latest-npm
+        with:
+          node: ${{ steps.node.outputs.node-version }}
+      - name: Install Dependencies
+        run: npm i --ignore-scripts --no-audit --no-fund
+      - name: Lint
+        run: npm run lint --ignore-scripts
+      - name: Post Lint
+        run: npm run postlint --ignore-scripts
+      - name: Conclude Check
+        uses: LouisBrunner/checks-action@v1.6.0
+        if: always()
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          conclusion: ${{ job.status }}
+          check_id: ${{ steps.create-check.outputs.check-id }}
+
+  test-all:
+    name: Test All - ${{ matrix.platform.name }} - ${{ matrix.node-version }}
+    if: github.repository_owner == 'npm'
+    strategy:
+      fail-fast: false
+      matrix:
+        platform:
+          - name: Linux
+            os: ubuntu-latest
+            shell: bash
+          - name: macOS
+            os: macos-latest
+            shell: bash
+          - name: Windows
+            os: windows-latest
+            shell: cmd
+        node-version:
+          - 10.0.0
+          - 10.x
+          - 12.x
+          - 14.x
+          - 16.x
+          - 18.x
+          - 20.x
+    runs-on: ${{ matrix.platform.os }}
+    defaults:
+      run:
+        shell: ${{ matrix.platform.shell }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          ref: ${{ inputs.ref }}
+      - name: Setup Git User
+        run: |
+          git config --global user.email "npm-cli+bot@github.com"
+          git config --global user.name "npm CLI robot"
+      - name: Create Check
+        id: create-check
+        if: ${{ inputs.check-sha }}
+        uses: ./.github/actions/create-check
+        with:
+          name: "Test All - ${{ matrix.platform.name }} - ${{ matrix.node-version }}"
+          token: ${{ secrets.GITHUB_TOKEN }}
+          sha: ${{ inputs.check-sha }}
+      - name: Setup Node
+        uses: actions/setup-node@v3
+        id: node
+        with:
+          node-version: ${{ matrix.node-version }}
+          check-latest: contains(matrix.node-version, '.x')
+      - name: Install Latest npm
+        uses: ./.github/actions/install-latest-npm
+        with:
+          node: ${{ steps.node.outputs.node-version }}
+      - name: Install Dependencies
+        run: npm i --ignore-scripts --no-audit --no-fund
+      - name: Add Problem Matcher
+        run: echo "::add-matcher::.github/matchers/tap.json"
+      - name: Test
+        run: npm test --ignore-scripts
+      - name: Conclude Check
+        uses: LouisBrunner/checks-action@v1.6.0
+        if: always()
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          conclusion: ${{ job.status }}
+          check_id: ${{ steps.create-check.outputs.check-id }}
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 00000000..f65f93a6
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,98 @@
+# This file is automatically added by @npmcli/template-oss. Do not edit.
+
+name: CI
+
+on:
+  workflow_dispatch:
+  pull_request:
+  push:
+    branches:
+      - main
+      - release/v*
+  schedule:
+    # "At 09:00 UTC (02:00 PT) on Monday" https://crontab.guru/#0_9_*_*_1
+    - cron: "0 9 * * 1"
+
+jobs:
+  lint:
+    name: Lint
+    if: github.repository_owner == 'npm'
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Setup Git User
+        run: |
+          git config --global user.email "npm-cli+bot@github.com"
+          git config --global user.name "npm CLI robot"
+      - name: Setup Node
+        uses: actions/setup-node@v3
+        id: node
+        with:
+          node-version: 20.x
+          check-latest: contains('20.x', '.x')
+      - name: Install Latest npm
+        uses: ./.github/actions/install-latest-npm
+        with:
+          node: ${{ steps.node.outputs.node-version }}
+      - name: Install Dependencies
+        run: npm i --ignore-scripts --no-audit --no-fund
+      - name: Lint
+        run: npm run lint --ignore-scripts
+      - name: Post Lint
+        run: npm run postlint --ignore-scripts
+
+  test:
+    name: Test - ${{ matrix.platform.name }} - ${{ matrix.node-version }}
+    if: github.repository_owner == 'npm'
+    strategy:
+      fail-fast: false
+      matrix:
+        platform:
+          - name: Linux
+            os: ubuntu-latest
+            shell: bash
+          - name: macOS
+            os: macos-latest
+            shell: bash
+          - name: Windows
+            os: windows-latest
+            shell: cmd
+        node-version:
+          - 10.0.0
+          - 10.x
+          - 12.x
+          - 14.x
+          - 16.x
+          - 18.x
+          - 20.x
+    runs-on: ${{ matrix.platform.os }}
+    defaults:
+      run:
+        shell: ${{ matrix.platform.shell }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Setup Git User
+        run: |
+          git config --global user.email "npm-cli+bot@github.com"
+          git config --global user.name "npm CLI robot"
+      - name: Setup Node
+        uses: actions/setup-node@v3
+        id: node
+        with:
+          node-version: ${{ matrix.node-version }}
+          check-latest: contains(matrix.node-version, '.x')
+      - name: Install Latest npm
+        uses: ./.github/actions/install-latest-npm
+        with:
+          node: ${{ steps.node.outputs.node-version }}
+      - name: Install Dependencies
+        run: npm i --ignore-scripts --no-audit --no-fund
+      - name: Add Problem Matcher
+        run: echo "::add-matcher::.github/matchers/tap.json"
+      - name: Test
+        run: npm test --ignore-scripts
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
new file mode 100644
index 00000000..9fb3f79a
--- /dev/null
+++ b/.github/workflows/codeql-analysis.yml
@@ -0,0 +1,38 @@
+# This file is automatically added by @npmcli/template-oss. Do not edit.
+
+name: CodeQL
+
+on:
+  push:
+    branches:
+      - main
+      - release/v*
+  pull_request:
+    branches:
+      - main
+      - release/v*
+  schedule:
+    # "At 10:00 UTC (03:00 PT) on Monday" https://crontab.guru/#0_10_*_*_1
+    - cron: "0 10 * * 1"
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Setup Git User
+        run: |
+          git config --global user.email "npm-cli+bot@github.com"
+          git config --global user.name "npm CLI robot"
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v2
+        with:
+          languages: javascript
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v2
diff --git a/.github/workflows/post-dependabot.yml b/.github/workflows/post-dependabot.yml
new file mode 100644
index 00000000..11a7b7c8
--- /dev/null
+++ b/.github/workflows/post-dependabot.yml
@@ -0,0 +1,123 @@
+# This file is automatically added by @npmcli/template-oss. Do not edit.
+
+name: Post Dependabot
+
+on: pull_request
+
+permissions:
+  contents: write
+
+jobs:
+  template-oss:
+    name: template-oss
+    if: github.repository_owner == 'npm' && github.actor == 'dependabot[bot]'
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          ref: ${{ github.event.pull_request.head.ref }}
+      - name: Setup Git User
+        run: |
+          git config --global user.email "npm-cli+bot@github.com"
+          git config --global user.name "npm CLI robot"
+      - name: Setup Node
+        uses: actions/setup-node@v3
+        id: node
+        with:
+          node-version: 20.x
+          check-latest: contains('20.x', '.x')
+      - name: Install Latest npm
+        uses: ./.github/actions/install-latest-npm
+        with:
+          node: ${{ steps.node.outputs.node-version }}
+      - name: Install Dependencies
+        run: npm i --ignore-scripts --no-audit --no-fund
+      - name: Fetch Dependabot Metadata
+        id: metadata
+        uses: dependabot/fetch-metadata@v1
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+
+      # Dependabot can update multiple directories so we output which directory
+      # it is acting on so we can run the command for the correct root or workspace
+      - name: Get Dependabot Directory
+        if: contains(steps.metadata.outputs.dependency-names, '@npmcli/template-oss')
+        id: flags
+        run: |
+          dependabot_dir="${{ steps.metadata.outputs.directory }}"
+          if [[ "$dependabot_dir" == "/" ]]; then
+            echo "workspace=-iwr" >> $GITHUB_OUTPUT
+          else
+            # strip leading slash from directory so it works as a
+            # a path to the workspace flag
+            echo "workspace=-w ${dependabot_dir#/}" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Apply Changes
+        if: steps.flags.outputs.workspace
+        id: apply
+        run: |
+          npm run template-oss-apply ${{ steps.flags.outputs.workspace }}
+          if [[ `git status --porcelain` ]]; then
+            echo "changes=true" >> $GITHUB_OUTPUT
+          fi
+          # This only sets the conventional commit prefix. This workflow can't reliably determine
+          # what the breaking change is though. If a BREAKING CHANGE message is required then
+          # this PR check will fail and the commit will be amended with stafftools
+          if [[ "${{ steps.metadata.outputs.update-type }}" == "version-update:semver-major" ]]; then
+            prefix='feat!'
+          else
+            prefix='chore'
+          fi
+          echo "message=$prefix: postinstall for dependabot template-oss PR" >> $GITHUB_OUTPUT
+
+      # This step will fail if template-oss has made any workflow updates. It is impossible
+      # for a workflow to update other workflows. In the case it does fail, we continue
+      # and then try to apply only a portion of the changes in the next step
+      - name: Push All Changes
+        if: steps.apply.outputs.changes
+        id: push
+        continue-on-error: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          git commit -am "${{ steps.apply.outputs.message }}"
+          git push
+
+      # If the previous step failed, then reset the commit and remove any workflow changes
+      # and attempt to commit and push again. This is helpful because we will have a commit
+      # with the correct prefix that we can then --amend with @npmcli/stafftools later.
+      - name: Push All Changes Except Workflows
+        if: steps.apply.outputs.changes && steps.push.outcome == 'failure'
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          git reset HEAD~
+          git checkout HEAD -- .github/workflows/
+          git clean -fd .github/workflows/
+          git commit -am "${{ steps.apply.outputs.message }}"
+          git push
+
+      # Check if all the necessary template-oss changes were applied. Since we continued
+      # on errors in one of the previous steps, this check will fail if our follow up
+      # only applied a portion of the changes and we need to followup manually.
+      #
+      # Note that this used to run `lint` and `postlint` but that will fail this action
+      # if we've also shipped any linting changes separate from template-oss. We do
+      # linting in another action, so we want to fail this one only if there are
+      # template-oss changes that could not be applied.
+      - name: Check Changes
+        if: steps.apply.outputs.changes
+        run: |
+          npm exec --offline ${{ steps.flags.outputs.workspace }} -- template-oss-check
+
+      - name: Fail on Breaking Change
+        if: steps.apply.outputs.changes && startsWith(steps.apply.outputs.message, 'feat!')
+        run: |
+          echo "This PR has a breaking change. Run 'npx -p @npmcli/stafftools gh template-oss-fix'"
+          echo "for more information on how to fix this with a BREAKING CHANGE footer."
+          exit 1
diff --git a/.github/workflows/pull-request.yml b/.github/workflows/pull-request.yml
new file mode 100644
index 00000000..0b5789e0
--- /dev/null
+++ b/.github/workflows/pull-request.yml
@@ -0,0 +1,50 @@
+# This file is automatically added by @npmcli/template-oss. Do not edit.
+
+name: Pull Request
+
+on:
+  pull_request:
+    types:
+      - opened
+      - reopened
+      - edited
+      - synchronize
+
+jobs:
+  commitlint:
+    name: Lint Commits
+    if: github.repository_owner == 'npm'
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+      - name: Setup Git User
+        run: |
+          git config --global user.email "npm-cli+bot@github.com"
+          git config --global user.name "npm CLI robot"
+      - name: Setup Node
+        uses: actions/setup-node@v3
+        id: node
+        with:
+          node-version: 20.x
+          check-latest: contains('20.x', '.x')
+      - name: Install Latest npm
+        uses: ./.github/actions/install-latest-npm
+        with:
+          node: ${{ steps.node.outputs.node-version }}
+      - name: Install Dependencies
+        run: npm i --ignore-scripts --no-audit --no-fund
+      - name: Run Commitlint on Commits
+        id: commit
+        continue-on-error: true
+        run: npx --offline commitlint -V --from 'origin/${{ github.base_ref }}' --to ${{ github.event.pull_request.head.sha }}
+      - name: Run Commitlint on PR Title
+        if: steps.commit.outcome == 'failure'
+        env:
+          PR_TITLE: ${{ github.event.pull_request.title }}
+        run: echo "$PR_TITLE" | npx --offline commitlint -V
diff --git a/.github/workflows/release-integration.yml b/.github/workflows/release-integration.yml
new file mode 100644
index 00000000..36637581
--- /dev/null
+++ b/.github/workflows/release-integration.yml
@@ -0,0 +1,76 @@
+# This file is automatically added by @npmcli/template-oss. Do not edit.
+
+name: Release Integration
+
+on:
+  workflow_dispatch:
+    inputs:
+      releases:
+        required: true
+        type: string
+        description: 'A json array of releases. Required fields: publish: tagName, publishTag. publish check: pkgName, version'
+  workflow_call:
+    inputs:
+      releases:
+        required: true
+        type: string
+        description: 'A json array of releases. Required fields: publish: tagName, publishTag. publish check: pkgName, version'
+    secrets:
+      PUBLISH_TOKEN:
+        required: true
+
+jobs:
+  publish:
+    name: Publish
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: bash
+    permissions:
+      id-token: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          ref: ${{ fromJSON(inputs.releases)[0].tagName }}
+      - name: Setup Git User
+        run: |
+          git config --global user.email "npm-cli+bot@github.com"
+          git config --global user.name "npm CLI robot"
+      - name: Setup Node
+        uses: actions/setup-node@v3
+        id: node
+        with:
+          node-version: 20.x
+          check-latest: contains('20.x', '.x')
+      - name: Install Latest npm
+        uses: ./.github/actions/install-latest-npm
+        with:
+          node: ${{ steps.node.outputs.node-version }}
+      - name: Install Dependencies
+        run: npm i --ignore-scripts --no-audit --no-fund
+      - name: Set npm authToken
+        run: npm config set '//registry.npmjs.org/:_authToken'=\${PUBLISH_TOKEN}
+      - name: Publish
+        env:
+          PUBLISH_TOKEN: ${{ secrets.PUBLISH_TOKEN }}
+        run: |
+          EXIT_CODE=0
+
+          function each_release {
+            if npm publish --provenance --tag="$1"; then
+              echo 0
+            else
+              echo 1
+            fi
+          }
+
+          for release in $(echo '${{ inputs.releases }}' | jq -r '.[] | @base64'); do
+            PUBLISH_TAG=$(echo "$release" | base64 --decode | jq -r .publishTag)
+            STATUS=$(each_release "$PUBLISH_TAG")
+            if [[ "$STATUS" -eq 1 ]]; then
+              EXIT_CODE=$STATUS
+            fi
+          done
+
+          exit $EXIT_CODE
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 00000000..be675916
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,308 @@
+# This file is automatically added by @npmcli/template-oss. Do not edit.
+
+name: Release
+
+on:
+  push:
+    branches:
+      - main
+      - release/v*
+
+permissions:
+  contents: write
+  pull-requests: write
+  checks: write
+
+jobs:
+  release:
+    outputs:
+      pr: ${{ steps.release.outputs.pr }}
+      pr-branch: ${{ steps.release.outputs.pr-branch }}
+      pr-number: ${{ steps.release.outputs.pr-number }}
+      pr-sha: ${{ steps.release.outputs.pr-sha }}
+      releases: ${{ steps.release.outputs.releases }}
+      comment-id: ${{ steps.create-comment.outputs.comment-id || steps.update-comment.outputs.comment-id }}
+      check-id: ${{ steps.create-check.outputs.check-id }}
+    name: Release
+    if: github.repository_owner == 'npm'
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Setup Git User
+        run: |
+          git config --global user.email "npm-cli+bot@github.com"
+          git config --global user.name "npm CLI robot"
+      - name: Setup Node
+        uses: actions/setup-node@v3
+        id: node
+        with:
+          node-version: 20.x
+          check-latest: contains('20.x', '.x')
+      - name: Install Latest npm
+        uses: ./.github/actions/install-latest-npm
+        with:
+          node: ${{ steps.node.outputs.node-version }}
+      - name: Install Dependencies
+        run: npm i --ignore-scripts --no-audit --no-fund
+      - name: Release Please
+        id: release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: npx --offline template-oss-release-please --branch="${{ github.ref_name }}" --backport="" --defaultTag="latest"
+      - name: Create Release Manager Comment Text
+        if: steps.release.outputs.pr-number
+        uses: actions/github-script@v6
+        id: comment-text
+        with:
+          result-encoding: string
+          script: |
+            const { runId, repo: { owner, repo } } = context
+            const { data: workflow } = await github.rest.actions.getWorkflowRun({ owner, repo, run_id: runId })
+            return['## Release Manager', `Release workflow run: ${workflow.html_url}`].join('\n\n')
+      - name: Find Release Manager Comment
+        uses: peter-evans/find-comment@v2
+        if: steps.release.outputs.pr-number
+        id: found-comment
+        with:
+          issue-number: ${{ steps.release.outputs.pr-number }}
+          comment-author: 'github-actions[bot]'
+          body-includes: '## Release Manager'
+      - name: Create Release Manager Comment
+        id: create-comment
+        if: steps.release.outputs.pr-number && !steps.found-comment.outputs.comment-id
+        uses: peter-evans/create-or-update-comment@v3
+        with:
+          issue-number: ${{ steps.release.outputs.pr-number }}
+          body: ${{ steps.comment-text.outputs.result }}
+      - name: Update Release Manager Comment
+        id: update-comment
+        if: steps.release.outputs.pr-number && steps.found-comment.outputs.comment-id
+        uses: peter-evans/create-or-update-comment@v3
+        with:
+          comment-id: ${{ steps.found-comment.outputs.comment-id }}
+          body: ${{ steps.comment-text.outputs.result }}
+          edit-mode: 'replace'
+      - name: Create Check
+        id: create-check
+        uses: ./.github/actions/create-check
+        if: steps.release.outputs.pr-sha
+        with:
+          name: "Release"
+          token: ${{ secrets.GITHUB_TOKEN }}
+          sha: ${{ steps.release.outputs.pr-sha }}
+
+  update:
+    needs: release
+    outputs:
+      sha: ${{ steps.commit.outputs.sha }}
+      check-id: ${{ steps.create-check.outputs.check-id }}
+    name: Update - Release
+    if: github.repository_owner == 'npm' && needs.release.outputs.pr
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          ref: ${{ needs.release.outputs.pr-branch }}
+      - name: Setup Git User
+        run: |
+          git config --global user.email "npm-cli+bot@github.com"
+          git config --global user.name "npm CLI robot"
+      - name: Setup Node
+        uses: actions/setup-node@v3
+        id: node
+        with:
+          node-version: 20.x
+          check-latest: contains('20.x', '.x')
+      - name: Install Latest npm
+        uses: ./.github/actions/install-latest-npm
+        with:
+          node: ${{ steps.node.outputs.node-version }}
+      - name: Install Dependencies
+        run: npm i --ignore-scripts --no-audit --no-fund
+      - name: Create Release Manager Checklist Text
+        id: comment-text
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: npm exec --offline -- template-oss-release-manager --pr="${{ needs.release.outputs.pr-number }}" --backport="" --defaultTag="latest" --publish
+      - name: Append Release Manager Comment
+        uses: peter-evans/create-or-update-comment@v3
+        with:
+          comment-id: ${{ needs.release.outputs.comment-id }}
+          body: ${{ steps.comment-text.outputs.result }}
+          edit-mode: 'append'
+      - name: Run Post Pull Request Actions
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: npm run rp-pull-request --ignore-scripts --if-present -- --pr="${{ needs.release.outputs.pr-number }}" --commentId="${{ needs.release.outputs.comment-id }}"
+      - name: Commit
+        id: commit
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          git commit --all --amend --no-edit || true
+          git push --force-with-lease
+          echo "sha=$(git rev-parse HEAD)" >> $GITHUB_OUTPUT
+      - name: Create Check
+        id: create-check
+        uses: ./.github/actions/create-check
+        with:
+          name: "Update - Release"
+          check-name: "Release"
+          token: ${{ secrets.GITHUB_TOKEN }}
+          sha: ${{ steps.commit.outputs.sha }}
+      - name: Conclude Check
+        uses: LouisBrunner/checks-action@v1.6.0
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          conclusion: ${{ job.status }}
+          check_id: ${{ needs.release.outputs.check-id }}
+
+  ci:
+    name: CI - Release
+    needs: [ release, update ]
+    if: needs.release.outputs.pr
+    uses: ./.github/workflows/ci-release.yml
+    with:
+      ref: ${{ needs.release.outputs.pr-branch }}
+      check-sha: ${{ needs.update.outputs.sha }}
+
+  post-ci:
+    needs: [ release, update, ci ]
+    name: Post CI - Release
+    if: github.repository_owner == 'npm' && needs.release.outputs.pr && always()
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - name: Get CI Conclusion
+        id: conclusion
+        run: |
+          result=""
+          if [[ "${{ contains(needs.*.result, 'failure') }}" == "true" ]]; then
+            result="failure"
+          elif [[ "${{ contains(needs.*.result, 'cancelled') }}" == "true" ]]; then
+            result="cancelled"
+          else
+            result="success"
+          fi
+          echo "result=$result" >> $GITHUB_OUTPUT
+      - name: Conclude Check
+        uses: LouisBrunner/checks-action@v1.6.0
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          conclusion: ${{ steps.conclusion.outputs.result }}
+          check_id: ${{ needs.update.outputs.check-id }}
+
+  post-release:
+    needs: release
+    outputs:
+      comment-id: ${{ steps.create-comment.outputs.comment-id }}
+    name: Post Release - Release
+    if: github.repository_owner == 'npm' && needs.release.outputs.releases
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - name: Create Release PR Comment Text
+        id: comment-text
+        uses: actions/github-script@v6
+        env:
+          RELEASES: ${{ needs.release.outputs.releases }}
+        with:
+          result-encoding: string
+          script: |
+            const releases = JSON.parse(process.env.RELEASES)
+            const { runId, repo: { owner, repo } } = context
+            const issue_number = releases[0].prNumber
+            const runUrl = `https://github.com/${owner}/${repo}/actions/runs/${runId}`
+
+            return [
+              '## Release Workflow\n',
+              ...releases.map(r => `- \`${r.pkgName}@${r.version}\` ${r.url}`),
+              `- Workflow run: :arrows_counterclockwise: ${runUrl}`,
+            ].join('\n')
+      - name: Create Release PR Comment
+        id: create-comment
+        uses: peter-evans/create-or-update-comment@v3
+        with:
+          issue-number: ${{ fromJSON(needs.release.outputs.releases)[0].prNumber }}
+          body: ${{ steps.comment-text.outputs.result }}
+
+  release-integration:
+    needs: release
+    name: Release Integration
+    if: needs.release.outputs.releases
+    uses: ./.github/workflows/release-integration.yml
+    permissions:
+      id-token: write
+    secrets:
+      PUBLISH_TOKEN: ${{ secrets.PUBLISH_TOKEN }}
+    with:
+      releases: ${{ needs.release.outputs.releases }}
+
+  post-release-integration:
+    needs: [ release, release-integration, post-release ]
+    name: Post Release Integration - Release
+    if: github.repository_owner == 'npm' && needs.release.outputs.releases && always()
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - name: Get Post Release Conclusion
+        id: conclusion
+        run: |
+          if [[ "${{ contains(needs.*.result, 'failure') }}" == "true" ]]; then
+            result="x"
+          elif [[ "${{ contains(needs.*.result, 'cancelled') }}" == "true" ]]; then
+            result="heavy_multiplication_x"
+          else
+            result="white_check_mark"
+          fi
+          echo "result=$result" >> $GITHUB_OUTPUT
+      - name: Find Release PR Comment
+        uses: peter-evans/find-comment@v2
+        id: found-comment
+        with:
+          issue-number: ${{ fromJSON(needs.release.outputs.releases)[0].prNumber }}
+          comment-author: 'github-actions[bot]'
+          body-includes: '## Release Workflow'
+      - name: Create Release PR Comment Text
+        id: comment-text
+        if: steps.found-comment.outputs.comment-id
+        uses: actions/github-script@v6
+        env:
+          RESULT: ${{ steps.conclusion.outputs.result }}
+          BODY: ${{ steps.found-comment.outputs.comment-body }}
+        with:
+          result-encoding: string
+          script: |
+            const { RESULT, BODY } = process.env
+            const body = [BODY.replace(/(Workflow run: :)[a-z_]+(:)/, `$1${RESULT}$2`)]
+            if (RESULT !== 'white_check_mark') {
+              body.push(':rotating_light::rotating_light::rotating_light:')
+              body.push([
+                '@npm/cli-team: The post-release workflow failed for this release.',
+                'Manual steps may need to be taken after examining the workflow output.'
+              ].join(' '))
+              body.push(':rotating_light::rotating_light::rotating_light:')
+            }
+            return body.join('\n\n').trim()
+      - name: Update Release PR Comment
+        if: steps.comment-text.outputs.result
+        uses: peter-evans/create-or-update-comment@v3
+        with:
+          comment-id: ${{ steps.found-comment.outputs.comment-id }}
+          body: ${{ steps.comment-text.outputs.result }}
+          edit-mode: 'replace'
diff --git a/.gitignore b/.gitignore
index 7a13b7a3..1bcc5e25 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,39 @@
-/node_modules
-.*.swp
-coverage/
-.nyc_output/
-.idea
+# This file is automatically added by @npmcli/template-oss. Do not edit.
+
+# ignore everything in the root
+/*
+# transient test directories
+tap-testdir*/
+
+# keep these
+!**/.gitignore
+!/.commitlintrc.js
+!/.eslintrc.js
+!/.eslintrc.local.*
+!/.github/
+!/.gitignore
+!/.npmrc
+!/.release-please-manifest.json
+!/bin/
+!/CHANGELOG*
+!/classes/
+!/CODE_OF_CONDUCT.md
+!/CONTRIBUTING.md
+!/docs/
+!/functions/
+!/index.js
+!/internal/
+!/lib/
+!/LICENSE*
+!/map.js
+!/package.json
+!/preload.js
+!/range.bnf
+!/ranges/
+!/README*
+!/release-please-config.json
+!/scripts/
+!/SECURITY.md
+!/tap-snapshots/
+!/test/
+!/tsconfig.json
diff --git a/.npmrc b/.npmrc
new file mode 100644
index 00000000..529f93e7
--- /dev/null
+++ b/.npmrc
@@ -0,0 +1,3 @@
+; This file is automatically added by @npmcli/template-oss. Do not edit.
+
+package-lock=false
diff --git a/.release-please-manifest.json b/.release-please-manifest.json
new file mode 100644
index 00000000..4c4a46ef
--- /dev/null
+++ b/.release-please-manifest.json
@@ -0,0 +1,3 @@
+{
+  ".": "7.6.0"
+}
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index 90b879c1..00000000
--- a/.travis.yml
+++ /dev/null
@@ -1,16 +0,0 @@
-language: node_js
-
-node_js:
-  - 11
-  - 10
-  - 8
-
-os:
-  - linux
-
-cache:
-  directories:
-    - $HOME/.npm
-
-notifications:
-  email: false
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 66304fdd..451daa10 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,208 @@
-# changes log
+# Changelog
+
+## [7.6.0](https://github.com/npm/node-semver/compare/v7.5.4...v7.6.0) (2024-01-31)
+
+### Features
+
+* [`a7ab13a`](https://github.com/npm/node-semver/commit/a7ab13a46201e342d34e84a989632b380f755baf) [#671](https://github.com/npm/node-semver/pull/671) preserve pre-release and build parts of a version on coerce (#671) (@madtisa, madtisa, @wraithgar)
+
+### Chores
+
+* [`816c7b2`](https://github.com/npm/node-semver/commit/816c7b2cbfcb1986958a290f941eddfd0441139e) [#667](https://github.com/npm/node-semver/pull/667) postinstall for dependabot template-oss PR (@lukekarrys)
+* [`0bd24d9`](https://github.com/npm/node-semver/commit/0bd24d943cbd1a7f6a2b8d384590bfa98559e1de) [#667](https://github.com/npm/node-semver/pull/667) bump @npmcli/template-oss from 4.21.1 to 4.21.3 (@dependabot[bot])
+* [`e521932`](https://github.com/npm/node-semver/commit/e521932f115a81030f4e7c34e8631cdd3c6a108b) [#652](https://github.com/npm/node-semver/pull/652) postinstall for dependabot template-oss PR (@lukekarrys)
+* [`8873991`](https://github.com/npm/node-semver/commit/88739918080debeb239aae840b35c07436148e50) [#652](https://github.com/npm/node-semver/pull/652) chore: chore: postinstall for dependabot template-oss PR (@lukekarrys)
+* [`f317dc8`](https://github.com/npm/node-semver/commit/f317dc8689781bcfd98e2c32b46157276acdd47c) [#652](https://github.com/npm/node-semver/pull/652) bump @npmcli/template-oss from 4.19.0 to 4.21.0 (@dependabot[bot])
+* [`7303db1`](https://github.com/npm/node-semver/commit/7303db1fe54d6905b23ccb0162878e37d73535ef) [#658](https://github.com/npm/node-semver/pull/658) add clean() test for build metadata (#658) (@jethrodaniel)
+* [`6240d75`](https://github.com/npm/node-semver/commit/6240d75a7c620b0a222f05969a91fdc3dc2be0fb) [#656](https://github.com/npm/node-semver/pull/656) add missing quotes in README.md (#656) (@zyxkad)
+* [`14d263f`](https://github.com/npm/node-semver/commit/14d263faa156e408a033b9b12a2f87735c2df42c) [#625](https://github.com/npm/node-semver/pull/625) postinstall for dependabot template-oss PR (@lukekarrys)
+* [`7c34e1a`](https://github.com/npm/node-semver/commit/7c34e1ac1bcc0bc6579b30745c96075c69bd0332) [#625](https://github.com/npm/node-semver/pull/625) bump @npmcli/template-oss from 4.18.1 to 4.19.0 (@dependabot[bot])
+* [`123e0b0`](https://github.com/npm/node-semver/commit/123e0b03287e1af295ef82d55f55c16805596f35) [#622](https://github.com/npm/node-semver/pull/622) postinstall for dependabot template-oss PR (@lukekarrys)
+* [`737d5e1`](https://github.com/npm/node-semver/commit/737d5e1cf10e631bab8a28594aa2d5c9d4090814) [#622](https://github.com/npm/node-semver/pull/622) bump @npmcli/template-oss from 4.18.0 to 4.18.1 (@dependabot[bot])
+* [`cce6180`](https://github.com/npm/node-semver/commit/cce61804ba6f997225a1267135c06676fe0524d2) [#598](https://github.com/npm/node-semver/pull/598) postinstall for dependabot template-oss PR (@lukekarrys)
+* [`b914a3d`](https://github.com/npm/node-semver/commit/b914a3d0d26ca27d2685053d7d390af4e02eedd9) [#598](https://github.com/npm/node-semver/pull/598) bump @npmcli/template-oss from 4.17.0 to 4.18.0 (@dependabot[bot])
+
+## [7.5.4](https://github.com/npm/node-semver/compare/v7.5.3...v7.5.4) (2023-07-07)
+
+### Bug Fixes
+
+* [`cc6fde2`](https://github.com/npm/node-semver/commit/cc6fde2d34b95cb600d126649d926901bd2a9703) [#588](https://github.com/npm/node-semver/pull/588) trim each range set before parsing (@lukekarrys)
+* [`99d8287`](https://github.com/npm/node-semver/commit/99d8287516a1d2abf0286033e2e26eca6b69c09f) [#583](https://github.com/npm/node-semver/pull/583) correctly parse long build ids as valid (#583) (@lukekarrys)
+
+## [7.5.3](https://github.com/npm/node-semver/compare/v7.5.2...v7.5.3) (2023-06-22)
+
+### Bug Fixes
+
+* [`abdd93d`](https://github.com/npm/node-semver/commit/abdd93d55496d22e3c15a454a5cf13f101e48bce) [#571](https://github.com/npm/node-semver/pull/571) set max lengths in regex for numeric and build identifiers (#571) (@lukekarrys)
+
+### Documentation
+
+* [`bf53dd8`](https://github.com/npm/node-semver/commit/bf53dd8da15a17eb6b8111115d0d8ef341fea5db) [#569](https://github.com/npm/node-semver/pull/569) add example for `>` comparator (#569) (@mbtools)
+
+## [7.5.2](https://github.com/npm/node-semver/compare/v7.5.1...v7.5.2) (2023-06-15)
+
+### Bug Fixes
+
+* [`58c791f`](https://github.com/npm/node-semver/commit/58c791f40ba8cf4be35a5ca6644353ecd6249edc) [#566](https://github.com/npm/node-semver/pull/566) diff when detecting major change from prerelease (#566) (@lukekarrys)
+* [`5c8efbc`](https://github.com/npm/node-semver/commit/5c8efbcb3c6c125af10746d054faff13e8c33fbd) [#565](https://github.com/npm/node-semver/pull/565) preserve build in raw after inc (#565) (@lukekarrys)
+* [`717534e`](https://github.com/npm/node-semver/commit/717534ee353682f3bcf33e60a8af4292626d4441) [#564](https://github.com/npm/node-semver/pull/564) better handling of whitespace (#564) (@lukekarrys)
+
+## [7.5.1](https://github.com/npm/node-semver/compare/v7.5.0...v7.5.1) (2023-05-12)
+
+### Bug Fixes
+
+* [`d30d25a`](https://github.com/npm/node-semver/commit/d30d25a5c1fb963c3cc9178cb1769fe45e4a3cab) [#559](https://github.com/npm/node-semver/pull/559) show type on invalid semver error (#559) (@tjenkinson)
+
+## [7.5.0](https://github.com/npm/node-semver/compare/v7.4.0...v7.5.0) (2023-04-17)
+
+### Features
+
+* [`503a4e5`](https://github.com/npm/node-semver/commit/503a4e52fe2b1c6ed1400d33149f7733c8361eed) [#548](https://github.com/npm/node-semver/pull/548) allow identifierBase to be false (#548) (@lsvalina)
+
+### Bug Fixes
+
+* [`e219bb4`](https://github.com/npm/node-semver/commit/e219bb454036a0c23e34407591f921c8edb688e7) [#552](https://github.com/npm/node-semver/pull/552) throw on bad version with correct error message (#552) (@wraithgar)
+* [`fc2f3df`](https://github.com/npm/node-semver/commit/fc2f3df0b5d25253b3580607e111a9a280d888ca) [#546](https://github.com/npm/node-semver/pull/546) incorrect results from diff sometimes with prerelease versions (#546) (@tjenkinson)
+* [`2781767`](https://github.com/npm/node-semver/commit/27817677794f592b592bf6181a80a4824ff762b2) [#547](https://github.com/npm/node-semver/pull/547) avoid re-instantiating SemVer during diff compare (#547) (@macno)
+
+## [7.4.0](https://github.com/npm/node-semver/compare/v7.3.8...v7.4.0) (2023-04-10)
+
+### Features
+
+* [`113f513`](https://github.com/npm/node-semver/commit/113f51312a1a6b6aa50d4f9486b4fde21782c1f5) [#532](https://github.com/npm/node-semver/pull/532) identifierBase parameter for .inc (#532) (@wraithgar, @b-bly)
+* [`48d8f8f`](https://github.com/npm/node-semver/commit/48d8f8fa63bf6e35db70ff840b6da1a51596a5a8) [#530](https://github.com/npm/node-semver/pull/530) export new RELEASE_TYPES constant (@hcharley)
+
+### Bug Fixes
+
+* [`940723d`](https://github.com/npm/node-semver/commit/940723d22bca824993627c45ac30dd3d2854b8cd) [#538](https://github.com/npm/node-semver/pull/538) intersects with v0.0.0 and v0.0.0-0 (#538) (@wraithgar)
+* [`aa516b5`](https://github.com/npm/node-semver/commit/aa516b50b32f5a144017d8fc1b9efe0540963c91) [#535](https://github.com/npm/node-semver/pull/535) faster parse options (#535) (@H4ad)
+* [`61e6ea1`](https://github.com/npm/node-semver/commit/61e6ea1e9b7af01baf19ab0c0a63c8e3ebfac97c) [#536](https://github.com/npm/node-semver/pull/536) faster cache key factory for range (#536) (@H4ad)
+* [`f8b8b61`](https://github.com/npm/node-semver/commit/f8b8b619e71746a47852a9d301f3087ab311444f) [#541](https://github.com/npm/node-semver/pull/541) optimistic parse (#541) (@H4ad)
+* [`796cbe2`](https://github.com/npm/node-semver/commit/796cbe29b06d102e1b16f3ed78eaba210ece951e) [#533](https://github.com/npm/node-semver/pull/533) semver.diff prerelease to release recognition (#533) (@wraithgar, @dominique-blockchain)
+* [`3f222b1`](https://github.com/npm/node-semver/commit/3f222b144033525ca9f8a2ce5bc6e02f0401881f) [#537](https://github.com/npm/node-semver/pull/537) reuse comparators on subset (#537) (@H4ad)
+* [`f66cc45`](https://github.com/npm/node-semver/commit/f66cc45c6e82eebb4b5b51af73e7b8dcaeda7e21) [#539](https://github.com/npm/node-semver/pull/539) faster diff (#539) (@H4ad)
+
+### Documentation
+
+* [`c5d29df`](https://github.com/npm/node-semver/commit/c5d29df6f75741fea27fffe3b88c9c3b28e3ca73) [#530](https://github.com/npm/node-semver/pull/530) Add "Constants" section to README (@hcharley)
+
+## [7.3.8](https://github.com/npm/node-semver/compare/v7.3.7...v7.3.8) (2022-10-04)
+
+### Bug Fixes
+
+* [`d8ef32c`](https://github.com/npm/node-semver/commit/d8ef32cee7a7e34310838f32451c9bcf52956b64) [#383](https://github.com/npm/node-semver/pull/383) add support for node.js esm auto exports (#383) (@MylesBorins)
+
+### Documentation
+
+* [`7209b14`](https://github.com/npm/node-semver/commit/7209b14ccd7ca35b9a1077a0b67d9ce884fe6d00) [#477](https://github.com/npm/node-semver/pull/477) update range.js comments to clarify the caret ranges examples (#477) (@amitse)
+
+### [7.3.7](https://github.com/npm/node-semver/compare/v7.3.6...v7.3.7) (2022-04-11)
+
+
+### Bug Fixes
+
+* allow node >=10 ([85b269a](https://github.com/npm/node-semver/commit/85b269a90806713d2a41e8e990b0ea6bc274b171))
+* **bin:** get correct value from arg separated by equals ([#449](https://github.com/npm/node-semver/issues/449)) ([4ceca76](https://github.com/npm/node-semver/commit/4ceca76729c577166395f19172854cbbcce3cec1)), closes [#431](https://github.com/npm/node-semver/issues/431)
+* ensure SemVer instance passed to inc are not modified ([#427](https://github.com/npm/node-semver/issues/427)) ([f070dde](https://github.com/npm/node-semver/commit/f070dde0cc22894ac254e281cb36a79ab790272d))
+* inc prerelease with numeric preid ([#380](https://github.com/npm/node-semver/issues/380)) ([802e161](https://github.com/npm/node-semver/commit/802e16174fe2a704dba16e97891ce36dc4f2ad76))
+
+
+### Dependencies
+
+* revert to lru-cache@6 ([22ae54d](https://github.com/npm/node-semver/commit/22ae54d66c2dec8200947066dbb9c33bb729b8a8))
+
+### [7.3.6](https://github.com/npm/node-semver/compare/v7.3.5...v7.3.6) (2022-04-05)
+
+
+### Bug Fixes
+
+* https://github.com/npm/node-semver/issues/329 ([cb1ca1d](https://github.com/npm/node-semver/commit/cb1ca1d5480a6c07c12ac31ba5f2071ed530c4ed))
+* properly escape dots in `GTE0` regexes ([#432](https://github.com/npm/node-semver/issues/432)) ([11494f1](https://github.com/npm/node-semver/commit/11494f1446a907c8fa5d9cfbc9fab04d553311f5))
+* replace deprecated String.prototype.substr() ([#445](https://github.com/npm/node-semver/issues/445)) ([e2d55e7](https://github.com/npm/node-semver/commit/e2d55e79f0d288ea88c0e0ba6620fe5636a4a552))
+* replace regex used to split ranges ([#434](https://github.com/npm/node-semver/issues/434)) ([9ab7b71](https://github.com/npm/node-semver/commit/9ab7b717dd7848c639b8ce3366d2241d430cdad2))
+
+
+### Documentation
+
+* clarify * range behavior ([cb1ca1d](https://github.com/npm/node-semver/commit/cb1ca1d5480a6c07c12ac31ba5f2071ed530c4ed))
+
+
+### Dependencies
+
+* lru-cache@7.4.0 ([#442](https://github.com/npm/node-semver/issues/442)) ([9a3064c](https://github.com/npm/node-semver/commit/9a3064c242cdce3c1c39cae37a83d93ead363b37))
+* tap@16.0.0 ([#439](https://github.com/npm/node-semver/issues/439)) ([60cbb3f](https://github.com/npm/node-semver/commit/60cbb3fd4a4d32979f3aa0a2aa4e185753106545))
+
+## 7.3.0
+
+* Add `subset(r1, r2)` method to determine if `r1` range is entirely
+  contained by `r2` range.
+
+## 7.2.3
+
+* Fix handling of `includePrelease` mode where version ranges like `1.0.0 -
+  2.0.0` would include `3.0.0-pre` and not `1.0.0-pre`.
+
+## 7.2.2
+
+* Fix bug where `2.0.0-pre` would be included in `^1.0.0` if
+  `includePrerelease` was set to true.
+
+## 7.2.0
+
+* Add `simplifyRange` method to attempt to generate a more human-readable
+  range expression that is equivalent to a supplied range, for a given set
+  of versions.
+
+## 7.1.2
+
+* Remove fancy lazy-loading logic, as it was causing problems for webpack
+  users.
+
+## 7.1.0
+
+* Add `require('semver/preload')` to load the entire module without using
+  lazy getter methods.
+
+## 7.0.0
+
+* Refactor module into separate files for better tree-shaking
+* Drop support for very old node versions, use const/let, `=>` functions,
+  and classes.
+
+## 6.3.0
+
+* Expose the token enum on the exports
+
+## 6.2.0
+
+* Coerce numbers to strings when passed to semver.coerce()
+* Add `rtl` option to coerce from right to left
+
+## 6.1.3
+
+* Handle X-ranges properly in includePrerelease mode
+
+## 6.1.2
+
+* Do not throw when testing invalid version strings
+
+## 6.1.1
+
+* Add options support for semver.coerce()
+* Handle undefined version passed to Range.test
+
+## 6.1.0
+
+* Add semver.compareBuild function
+* Support `*` in semver.intersects
+
+## 6.0
+
+* Fix `intersects` logic.
+
+    This is technically a bug fix, but since it is also a change to behavior
+    that may require users updating their code, it is marked as a major
+    version increment.
 
 ## 5.7
 
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
new file mode 100644
index 00000000..167043c2
--- /dev/null
+++ b/CODE_OF_CONDUCT.md
@@ -0,0 +1,7 @@
+<!-- This file is automatically added by @npmcli/template-oss. Do not edit. -->
+
+All interactions in this repo are covered by the [npm Code of
+Conduct](https://docs.npmjs.com/policies/conduct)
+
+The npm cli team may, at its own discretion, moderate, remove, or edit
+any interactions such as pull requests, issues, and comments.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index e88ff8f8..69e88788 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1 +1,50 @@
-Please consider signing [the neveragain.tech pledge](http://neveragain.tech/)
+<!-- This file is automatically added by @npmcli/template-oss. Do not edit. -->
+
+# Contributing
+
+## Code of Conduct
+
+All interactions in the **npm** organization on GitHub are considered to be covered by our standard [Code of Conduct](https://docs.npmjs.com/policies/conduct).
+
+## Reporting Bugs
+
+Before submitting a new bug report please search for an existing or similar report.
+
+Use one of our existing issue templates if you believe you've come across a unique problem.
+
+Duplicate issues, or issues that don't use one of our templates may get closed without a response.
+
+## Pull Request Conventions
+
+### Commits
+
+We use [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/).
+
+When opening a pull request please be sure that either the pull request title, or each commit in the pull request, has one of the following prefixes:
+
+ - `feat`: For when introducing a new feature.  The result will be a new semver minor version of the package when it is next published.
+ - `fix`: For bug fixes. The result will be a new semver patch version of the package when it is next published.
+ - `docs`: For documentation updates.  The result will be a new semver patch version of the package when it is next published.
+ - `chore`: For changes that do not affect the published module.  Often these are changes to tests.  The result will be *no* change to the version of the package when it is next published (as the commit does not affect the published version).
+
+### Test Coverage
+
+Pull requests made against this repo will run `npm test` automatically.  Please make sure tests pass locally before submitting a PR.
+
+Every new feature or bug fix should come with a corresponding test or tests that validate the solutions. Testing also reports on code coverage and will fail if code coverage drops.
+
+### Linting
+
+Linting is also done automatically once tests pass.  `npm run lintfix` will fix most linting errors automatically.
+
+Please make sure linting passes before submitting a PR.
+
+## What _not_ to contribute?
+
+### Dependencies
+
+It should be noted that our team does not accept third-party dependency updates/PRs.  If you submit a PR trying to update our dependencies we will close it with or without a reference to these contribution guidelines.
+
+### Tools/Automation
+
+Our core team is responsible for the maintenance of the tooling/automation in this project and we ask contributors to not make changes to these when contributing (e.g. `.github/*`, `.eslintrc.json`, `.licensee.json`).  Most of those files also have a header at the top to remind folks they are automatically generated.  Pull requests that alter these will not be accepted.
diff --git a/README.md b/README.md
index e5ccecec..a9d3a278 100644
--- a/README.md
+++ b/README.md
@@ -4,7 +4,7 @@ semver(1) -- The semantic versioner for npm
 ## Install
 
 ```bash
-npm install --save semver
+npm install semver
 ````
 
 ## Usage
@@ -25,6 +25,63 @@ semver.valid(semver.coerce('v2')) // '2.0.0'
 semver.valid(semver.coerce('42.6.7.9.3-alpha')) // '42.6.7'
 ```
 
+You can also just load the module for the function that you care about, if
+you'd like to minimize your footprint.
+
+```js
+// load the whole API at once in a single object
+const semver = require('semver')
+
+// or just load the bits you need
+// all of them listed here, just pick and choose what you want
+
+// classes
+const SemVer = require('semver/classes/semver')
+const Comparator = require('semver/classes/comparator')
+const Range = require('semver/classes/range')
+
+// functions for working with versions
+const semverParse = require('semver/functions/parse')
+const semverValid = require('semver/functions/valid')
+const semverClean = require('semver/functions/clean')
+const semverInc = require('semver/functions/inc')
+const semverDiff = require('semver/functions/diff')
+const semverMajor = require('semver/functions/major')
+const semverMinor = require('semver/functions/minor')
+const semverPatch = require('semver/functions/patch')
+const semverPrerelease = require('semver/functions/prerelease')
+const semverCompare = require('semver/functions/compare')
+const semverRcompare = require('semver/functions/rcompare')
+const semverCompareLoose = require('semver/functions/compare-loose')
+const semverCompareBuild = require('semver/functions/compare-build')
+const semverSort = require('semver/functions/sort')
+const semverRsort = require('semver/functions/rsort')
+
+// low-level comparators between versions
+const semverGt = require('semver/functions/gt')
+const semverLt = require('semver/functions/lt')
+const semverEq = require('semver/functions/eq')
+const semverNeq = require('semver/functions/neq')
+const semverGte = require('semver/functions/gte')
+const semverLte = require('semver/functions/lte')
+const semverCmp = require('semver/functions/cmp')
+const semverCoerce = require('semver/functions/coerce')
+
+// working with ranges
+const semverSatisfies = require('semver/functions/satisfies')
+const semverMaxSatisfying = require('semver/ranges/max-satisfying')
+const semverMinSatisfying = require('semver/ranges/min-satisfying')
+const semverToComparators = require('semver/ranges/to-comparators')
+const semverMinVersion = require('semver/ranges/min-version')
+const semverValidRange = require('semver/ranges/valid')
+const semverOutside = require('semver/ranges/outside')
+const semverGtr = require('semver/ranges/gtr')
+const semverLtr = require('semver/ranges/ltr')
+const semverIntersects = require('semver/ranges/intersects')
+const simplifyRange = require('semver/ranges/simplify')
+const rangeSubset = require('semver/ranges/subset')
+```
+
 As a command-line utility:
 
 ```
@@ -53,6 +110,9 @@ Options:
 -l --loose
         Interpret versions and ranges loosely
 
+-n <0|1>
+        This is the base to be used for the prerelease identifier.
+
 -p --include-prerelease
         Always include prerelease versions in range matching
 
@@ -60,6 +120,12 @@ Options:
         Coerce a string into SemVer if possible
         (does not imply --loose)
 
+--rtl
+        Coerce version strings right to left
+
+--ltr
+        Coerce version strings left to right (default)
+
 Program exits successfully if any valid version satisfies
 all supplied ranges, and prints all satisfying versions.
 
@@ -93,7 +159,9 @@ of primitive `operators` is:
 
 For example, the comparator `>=1.2.7` would match the versions
 `1.2.7`, `1.2.8`, `2.5.3`, and `1.3.9`, but not the versions `1.2.6`
-or `1.1.0`.
+or `1.1.0`. The comparator `>1` is equivalent to `>=2.0.0` and
+would match the versions `2.0.0` and `3.1.0`, but not the versions
+`1.0.1` or `1.1.0`.
 
 Comparators can be joined by whitespace to form a `comparator set`,
 which is satisfied by the **intersection** of all of the comparators
@@ -169,6 +237,35 @@ $ semver 1.2.4-beta.0 -i prerelease
 1.2.4-beta.1
 ```
 
+#### Prerelease Identifier Base
+
+The method `.inc` takes an optional parameter 'identifierBase' string
+that will let you let your prerelease number as zero-based or one-based.
+Set to `false` to omit the prerelease number altogether.
+If you do not specify this parameter, it will default to zero-based.
+
+```javascript
+semver.inc('1.2.3', 'prerelease', 'beta', '1')
+// '1.2.4-beta.1'
+```
+
+```javascript
+semver.inc('1.2.3', 'prerelease', 'beta', false)
+// '1.2.4-beta'
+```
+
+command-line example:
+
+```bash
+$ semver 1.2.3 -i prerelease --preid beta -n 1
+1.2.4-beta.1
+```
+
+```bash
+$ semver 1.2.3 -i prerelease --preid beta -n false
+1.2.4-beta
+```
+
 ### Advanced Range Syntax
 
 Advanced range syntax desugars to primitive comparators in
@@ -193,37 +290,39 @@ inclusive range, then all versions that start with the supplied parts
 of the tuple are accepted, but nothing that would be greater than the
 provided tuple parts.
 
-* `1.2.3 - 2.3` := `>=1.2.3 <2.4.0`
-* `1.2.3 - 2` := `>=1.2.3 <3.0.0`
+* `1.2.3 - 2.3` := `>=1.2.3 <2.4.0-0`
+* `1.2.3 - 2` := `>=1.2.3 <3.0.0-0`
 
 #### X-Ranges `1.2.x` `1.X` `1.2.*` `*`
 
 Any of `X`, `x`, or `*` may be used to "stand in" for one of the
 numeric values in the `[major, minor, patch]` tuple.
 
-* `*` := `>=0.0.0` (Any version satisfies)
-* `1.x` := `>=1.0.0 <2.0.0` (Matching major version)
-* `1.2.x` := `>=1.2.0 <1.3.0` (Matching major and minor versions)
+* `*` := `>=0.0.0` (Any non-prerelease version satisfies, unless
+  `includePrerelease` is specified, in which case any version at all
+  satisfies)
+* `1.x` := `>=1.0.0 <2.0.0-0` (Matching major version)
+* `1.2.x` := `>=1.2.0 <1.3.0-0` (Matching major and minor versions)
 
 A partial version range is treated as an X-Range, so the special
 character is in fact optional.
 
 * `""` (empty string) := `*` := `>=0.0.0`
-* `1` := `1.x.x` := `>=1.0.0 <2.0.0`
-* `1.2` := `1.2.x` := `>=1.2.0 <1.3.0`
+* `1` := `1.x.x` := `>=1.0.0 <2.0.0-0`
+* `1.2` := `1.2.x` := `>=1.2.0 <1.3.0-0`
 
 #### Tilde Ranges `~1.2.3` `~1.2` `~1`
 
 Allows patch-level changes if a minor version is specified on the
 comparator.  Allows minor-level changes if not.
 
-* `~1.2.3` := `>=1.2.3 <1.(2+1).0` := `>=1.2.3 <1.3.0`
-* `~1.2` := `>=1.2.0 <1.(2+1).0` := `>=1.2.0 <1.3.0` (Same as `1.2.x`)
-* `~1` := `>=1.0.0 <(1+1).0.0` := `>=1.0.0 <2.0.0` (Same as `1.x`)
-* `~0.2.3` := `>=0.2.3 <0.(2+1).0` := `>=0.2.3 <0.3.0`
-* `~0.2` := `>=0.2.0 <0.(2+1).0` := `>=0.2.0 <0.3.0` (Same as `0.2.x`)
-* `~0` := `>=0.0.0 <(0+1).0.0` := `>=0.0.0 <1.0.0` (Same as `0.x`)
-* `~1.2.3-beta.2` := `>=1.2.3-beta.2 <1.3.0` Note that prereleases in
+* `~1.2.3` := `>=1.2.3 <1.(2+1).0` := `>=1.2.3 <1.3.0-0`
+* `~1.2` := `>=1.2.0 <1.(2+1).0` := `>=1.2.0 <1.3.0-0` (Same as `1.2.x`)
+* `~1` := `>=1.0.0 <(1+1).0.0` := `>=1.0.0 <2.0.0-0` (Same as `1.x`)
+* `~0.2.3` := `>=0.2.3 <0.(2+1).0` := `>=0.2.3 <0.3.0-0`
+* `~0.2` := `>=0.2.0 <0.(2+1).0` := `>=0.2.0 <0.3.0-0` (Same as `0.2.x`)
+* `~0` := `>=0.0.0 <(0+1).0.0` := `>=0.0.0 <1.0.0-0` (Same as `0.x`)
+* `~1.2.3-beta.2` := `>=1.2.3-beta.2 <1.3.0-0` Note that prereleases in
   the `1.2.3` version will be allowed, if they are greater than or
   equal to `beta.2`.  So, `1.2.3-beta.4` would be allowed, but
   `1.2.4-beta.2` would not, because it is a prerelease of a
@@ -231,7 +330,7 @@ comparator.  Allows minor-level changes if not.
 
 #### Caret Ranges `^1.2.3` `^0.2.5` `^0.0.4`
 
-Allows changes that do not modify the left-most non-zero digit in the
+Allows changes that do not modify the left-most non-zero element in the
 `[major, minor, patch]` tuple.  In other words, this allows patch and
 minor updates for versions `1.0.0` and above, patch updates for
 versions `0.X >=0.1.0`, and *no* updates for versions `0.0.X`.
@@ -245,15 +344,15 @@ However, it presumes that there will *not* be breaking changes between
 `0.2.4` and `0.2.5`.  It allows for changes that are presumed to be
 additive (but non-breaking), according to commonly observed practices.
 
-* `^1.2.3` := `>=1.2.3 <2.0.0`
-* `^0.2.3` := `>=0.2.3 <0.3.0`
-* `^0.0.3` := `>=0.0.3 <0.0.4`
-* `^1.2.3-beta.2` := `>=1.2.3-beta.2 <2.0.0` Note that prereleases in
+* `^1.2.3` := `>=1.2.3 <2.0.0-0`
+* `^0.2.3` := `>=0.2.3 <0.3.0-0`
+* `^0.0.3` := `>=0.0.3 <0.0.4-0`
+* `^1.2.3-beta.2` := `>=1.2.3-beta.2 <2.0.0-0` Note that prereleases in
   the `1.2.3` version will be allowed, if they are greater than or
   equal to `beta.2`.  So, `1.2.3-beta.4` would be allowed, but
   `1.2.4-beta.2` would not, because it is a prerelease of a
   different `[major, minor, patch]` tuple.
-* `^0.0.3-beta` := `>=0.0.3-beta <0.0.4`  Note that prereleases in the
+* `^0.0.3-beta` := `>=0.0.3-beta <0.0.4-0`  Note that prereleases in the
   `0.0.3` version *only* will be allowed, if they are greater than or
   equal to `beta`.  So, `0.0.3-pr.2` would be allowed.
 
@@ -261,16 +360,16 @@ When parsing caret ranges, a missing `patch` value desugars to the
 number `0`, but will allow flexibility within that value, even if the
 major and minor versions are both `0`.
 
-* `^1.2.x` := `>=1.2.0 <2.0.0`
-* `^0.0.x` := `>=0.0.0 <0.1.0`
-* `^0.0` := `>=0.0.0 <0.1.0`
+* `^1.2.x` := `>=1.2.0 <2.0.0-0`
+* `^0.0.x` := `>=0.0.0 <0.1.0-0`
+* `^0.0` := `>=0.0.0 <0.1.0-0`
 
 A missing `minor` and `patch` values will desugar to zero, but also
 allow flexibility within those values, even if the major version is
 zero.
 
-* `^1.x` := `>=1.0.0 <2.0.0`
-* `^0.x` := `>=0.0.0 <1.0.0`
+* `^1.x` := `>=1.0.0 <2.0.0-0`
+* `^0.x` := `>=0.0.0 <1.0.0-0`
 
 ### Range Grammar
 
@@ -354,6 +453,9 @@ strings that they parse.
   `v2` is greater.  Sorts in ascending order if passed to `Array.sort()`.
 * `rcompare(v1, v2)`: The reverse of compare.  Sorts an array of versions
   in descending order when passed to `Array.sort()`.
+* `compareBuild(v1, v2)`: The same as `compare` but considers `build` when two versions
+  are equal.  Sorts in ascending order if passed to `Array.sort()`.
+  `v2` is greater.  Sorts in ascending order if passed to `Array.sort()`.
 * `diff(v1, v2)`: Returns difference between two versions by the release type
   (`major`, `premajor`, `minor`, `preminor`, `patch`, `prepatch`, or `prerelease`),
   or null if the versions are the same.
@@ -382,6 +484,16 @@ strings that they parse.
   `hilo` argument must be either the string `'>'` or `'<'`.  (This is
   the function called by `gtr` and `ltr`.)
 * `intersects(range)`: Return true if any of the ranges comparators intersect
+* `simplifyRange(versions, range)`: Return a "simplified" range that
+  matches the same items in `versions` list as the range specified.  Note
+  that it does *not* guarantee that it would match the same versions in all
+  cases, only for the set of versions provided.  This is useful when
+  generating ranges by joining together multiple versions with `||`
+  programmatically, to provide the user with something a bit more
+  ergonomic.  If the provided range is shorter in string-length than the
+  generated range, then that is returned.
+* `subset(subRange, superRange)`: Return `true` if the `subRange` range is
+  entirely contained by the `superRange` range.
 
 Note that, since ranges may be non-contiguous, a version might not be
 greater than a range, less than a range, *or* satisfy a range!  For
@@ -396,16 +508,134 @@ range, use the `satisfies(version, range)` function.
 
 ### Coercion
 
-* `coerce(version)`: Coerces a string to semver if possible
-
-This aims to provide a very forgiving translation of a non-semver
-string to semver. It looks for the first digit in a string, and
-consumes all remaining characters which satisfy at least a partial semver
-(e.g., `1`, `1.2`, `1.2.3`) up to the max permitted length (256 characters).
-Longer versions are simply truncated (`4.6.3.9.2-alpha2` becomes `4.6.3`).
-All surrounding text is simply ignored (`v3.4 replaces v3.3.1` becomes `3.4.0`).
-Only text which lacks digits will fail coercion (`version one` is not valid).
-The maximum  length for any semver component considered for coercion is 16 characters;
-longer components will be ignored (`10000000000000000.4.7.4` becomes `4.7.4`).
-The maximum value for any semver component is `Integer.MAX_SAFE_INTEGER || (2**53 - 1)`;
-higher value components are invalid (`9999999999999999.4.7.4` is likely invalid).
+* `coerce(version, options)`: Coerces a string to semver if possible
+
+This aims to provide a very forgiving translation of a non-semver string to
+semver. It looks for the first digit in a string, and consumes all
+remaining characters which satisfy at least a partial semver (e.g., `1`,
+`1.2`, `1.2.3`) up to the max permitted length (256 characters).  Longer
+versions are simply truncated (`4.6.3.9.2-alpha2` becomes `4.6.3`).  All
+surrounding text is simply ignored (`v3.4 replaces v3.3.1` becomes
+`3.4.0`).  Only text which lacks digits will fail coercion (`version one`
+is not valid).  The maximum  length for any semver component considered for
+coercion is 16 characters; longer components will be ignored
+(`10000000000000000.4.7.4` becomes `4.7.4`).  The maximum value for any
+semver component is `Number.MAX_SAFE_INTEGER || (2**53 - 1)`; higher value
+components are invalid (`9999999999999999.4.7.4` is likely invalid).
+
+If the `options.rtl` flag is set, then `coerce` will return the right-most
+coercible tuple that does not share an ending index with a longer coercible
+tuple.  For example, `1.2.3.4` will return `2.3.4` in rtl mode, not
+`4.0.0`.  `1.2.3/4` will return `4.0.0`, because the `4` is not a part of
+any other overlapping SemVer tuple.
+
+If the `options.includePrerelease` flag is set, then the `coerce` result will contain
+prerelease and build parts of a version.  For example, `1.2.3.4-rc.1+rev.2`
+will preserve prerelease `rc.1` and build `rev.2` in the result.
+
+### Clean
+
+* `clean(version)`: Clean a string to be a valid semver if possible
+
+This will return a cleaned and trimmed semver version. If the provided
+version is not valid a null will be returned. This does not work for
+ranges.
+
+ex.
+* `s.clean(' = v 2.1.5foo')`: `null`
+* `s.clean(' = v 2.1.5foo', { loose: true })`: `'2.1.5-foo'`
+* `s.clean(' = v 2.1.5-foo')`: `null`
+* `s.clean(' = v 2.1.5-foo', { loose: true })`: `'2.1.5-foo'`
+* `s.clean('=v2.1.5')`: `'2.1.5'`
+* `s.clean('  =v2.1.5')`: `'2.1.5'`
+* `s.clean('      2.1.5   ')`: `'2.1.5'`
+* `s.clean('~1.0.0')`: `null`
+
+## Constants
+
+As a convenience, helper constants are exported to provide information about what `node-semver` supports:
+
+### `RELEASE_TYPES`
+
+- major
+- premajor
+- minor
+- preminor
+- patch
+- prepatch
+- prerelease
+
+```
+const semver = require('semver');
+
+if (semver.RELEASE_TYPES.includes(arbitraryUserInput)) {
+  console.log('This is a valid release type!');
+} else {
+  console.warn('This is NOT a valid release type!');
+}
+```
+
+### `SEMVER_SPEC_VERSION`
+
+2.0.0
+
+```
+const semver = require('semver');
+
+console.log('We are currently using the semver specification version:', semver.SEMVER_SPEC_VERSION);
+```
+
+## Exported Modules
+
+<!--
+TODO: Make sure that all of these items are documented (classes aren't,
+eg), and then pull the module name into the documentation for that specific
+thing.
+-->
+
+You may pull in just the part of this semver utility that you need, if you
+are sensitive to packing and tree-shaking concerns.  The main
+`require('semver')` export uses getter functions to lazily load the parts
+of the API that are used.
+
+The following modules are available:
+
+* `require('semver')`
+* `require('semver/classes')`
+* `require('semver/classes/comparator')`
+* `require('semver/classes/range')`
+* `require('semver/classes/semver')`
+* `require('semver/functions/clean')`
+* `require('semver/functions/cmp')`
+* `require('semver/functions/coerce')`
+* `require('semver/functions/compare')`
+* `require('semver/functions/compare-build')`
+* `require('semver/functions/compare-loose')`
+* `require('semver/functions/diff')`
+* `require('semver/functions/eq')`
+* `require('semver/functions/gt')`
+* `require('semver/functions/gte')`
+* `require('semver/functions/inc')`
+* `require('semver/functions/lt')`
+* `require('semver/functions/lte')`
+* `require('semver/functions/major')`
+* `require('semver/functions/minor')`
+* `require('semver/functions/neq')`
+* `require('semver/functions/parse')`
+* `require('semver/functions/patch')`
+* `require('semver/functions/prerelease')`
+* `require('semver/functions/rcompare')`
+* `require('semver/functions/rsort')`
+* `require('semver/functions/satisfies')`
+* `require('semver/functions/sort')`
+* `require('semver/functions/valid')`
+* `require('semver/ranges/gtr')`
+* `require('semver/ranges/intersects')`
+* `require('semver/ranges/ltr')`
+* `require('semver/ranges/max-satisfying')`
+* `require('semver/ranges/min-satisfying')`
+* `require('semver/ranges/min-version')`
+* `require('semver/ranges/outside')`
+* `require('semver/ranges/to-comparators')`
+* `require('semver/ranges/valid')`
+
diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 00000000..9cd2deaf
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,13 @@
+<!-- This file is automatically added by @npmcli/template-oss. Do not edit. -->
+
+GitHub takes the security of our software products and services seriously, including the open source code repositories managed through our GitHub organizations, such as [GitHub](https://github.com/GitHub).
+
+If you believe you have found a security vulnerability in this GitHub-owned open source repository, you can report it to us in one of two ways. 
+
+If the vulnerability you have found is *not* [in scope for the GitHub Bug Bounty Program](https://bounty.github.com/#scope) or if you do not wish to be considered for a bounty reward, please report the issue to us directly through [opensource-security@github.com](mailto:opensource-security@github.com).
+
+If the vulnerability you have found is [in scope for the GitHub Bug Bounty Program](https://bounty.github.com/#scope) and you would like for your finding to be considered for a bounty reward, please submit the vulnerability to us through [HackerOne](https://hackerone.com/github) in order to be eligible to receive a bounty award.
+
+**Please do not report security vulnerabilities through public GitHub issues, discussions, or pull requests.**
+
+Thanks for helping make GitHub safe for everyone.
diff --git a/bin/semver b/bin/semver
deleted file mode 100755
index 801e77f1..00000000
--- a/bin/semver
+++ /dev/null
@@ -1,160 +0,0 @@
-#!/usr/bin/env node
-// Standalone semver comparison program.
-// Exits successfully and prints matching version(s) if
-// any supplied version is valid and passes all tests.
-
-var argv = process.argv.slice(2)
-
-var versions = []
-
-var range = []
-
-var inc = null
-
-var version = require('../package.json').version
-
-var loose = false
-
-var includePrerelease = false
-
-var coerce = false
-
-var identifier
-
-var semver = require('../semver')
-
-var reverse = false
-
-var options = {}
-
-main()
-
-function main () {
-  if (!argv.length) return help()
-  while (argv.length) {
-    var a = argv.shift()
-    var indexOfEqualSign = a.indexOf('=')
-    if (indexOfEqualSign !== -1) {
-      a = a.slice(0, indexOfEqualSign)
-      argv.unshift(a.slice(indexOfEqualSign + 1))
-    }
-    switch (a) {
-      case '-rv': case '-rev': case '--rev': case '--reverse':
-        reverse = true
-        break
-      case '-l': case '--loose':
-        loose = true
-        break
-      case '-p': case '--include-prerelease':
-        includePrerelease = true
-        break
-      case '-v': case '--version':
-        versions.push(argv.shift())
-        break
-      case '-i': case '--inc': case '--increment':
-        switch (argv[0]) {
-          case 'major': case 'minor': case 'patch': case 'prerelease':
-          case 'premajor': case 'preminor': case 'prepatch':
-            inc = argv.shift()
-            break
-          default:
-            inc = 'patch'
-            break
-        }
-        break
-      case '--preid':
-        identifier = argv.shift()
-        break
-      case '-r': case '--range':
-        range.push(argv.shift())
-        break
-      case '-c': case '--coerce':
-        coerce = true
-        break
-      case '-h': case '--help': case '-?':
-        return help()
-      default:
-        versions.push(a)
-        break
-    }
-  }
-
-  var options = { loose: loose, includePrerelease: includePrerelease }
-
-  versions = versions.map(function (v) {
-    return coerce ? (semver.coerce(v) || { version: v }).version : v
-  }).filter(function (v) {
-    return semver.valid(v)
-  })
-  if (!versions.length) return fail()
-  if (inc && (versions.length !== 1 || range.length)) { return failInc() }
-
-  for (var i = 0, l = range.length; i < l; i++) {
-    versions = versions.filter(function (v) {
-      return semver.satisfies(v, range[i], options)
-    })
-    if (!versions.length) return fail()
-  }
-  return success(versions)
-}
-
-function failInc () {
-  console.error('--inc can only be used on a single version with no range')
-  fail()
-}
-
-function fail () { process.exit(1) }
-
-function success () {
-  var compare = reverse ? 'rcompare' : 'compare'
-  versions.sort(function (a, b) {
-    return semver[compare](a, b, options)
-  }).map(function (v) {
-    return semver.clean(v, options)
-  }).map(function (v) {
-    return inc ? semver.inc(v, inc, options, identifier) : v
-  }).forEach(function (v, i, _) { console.log(v) })
-}
-
-function help () {
-  console.log(['SemVer ' + version,
-    '',
-    'A JavaScript implementation of the https://semver.org/ specification',
-    'Copyright Isaac Z. Schlueter',
-    '',
-    'Usage: semver [options] <version> [<version> [...]]',
-    'Prints valid versions sorted by SemVer precedence',
-    '',
-    'Options:',
-    '-r --range <range>',
-    '        Print versions that match the specified range.',
-    '',
-    '-i --increment [<level>]',
-    '        Increment a version by the specified level.  Level can',
-    '        be one of: major, minor, patch, premajor, preminor,',
-    "        prepatch, or prerelease.  Default level is 'patch'.",
-    '        Only one version may be specified.',
-    '',
-    '--preid <identifier>',
-    '        Identifier to be used to prefix premajor, preminor,',
-    '        prepatch or prerelease version increments.',
-    '',
-    '-l --loose',
-    '        Interpret versions and ranges loosely',
-    '',
-    '-p --include-prerelease',
-    '        Always include prerelease versions in range matching',
-    '',
-    '-c --coerce',
-    '        Coerce a string into SemVer if possible',
-    '        (does not imply --loose)',
-    '',
-    'Program exits successfully if any valid version satisfies',
-    'all supplied ranges, and prints all satisfying versions.',
-    '',
-    'If no satisfying versions are found, then exits failure.',
-    '',
-    'Versions are printed in ascending order, so supplying',
-    'multiple versions to the utility will just sort them.'
-  ].join('\n'))
-}
diff --git a/bin/semver.js b/bin/semver.js
new file mode 100755
index 00000000..242b7ade
--- /dev/null
+++ b/bin/semver.js
@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+// Standalone semver comparison program.
+// Exits successfully and prints matching version(s) if
+// any supplied version is valid and passes all tests.
+
+const argv = process.argv.slice(2)
+
+let versions = []
+
+const range = []
+
+let inc = null
+
+const version = require('../package.json').version
+
+let loose = false
+
+let includePrerelease = false
+
+let coerce = false
+
+let rtl = false
+
+let identifier
+
+let identifierBase
+
+const semver = require('../')
+const parseOptions = require('../internal/parse-options')
+
+let reverse = false
+
+let options = {}
+
+const main = () => {
+  if (!argv.length) {
+    return help()
+  }
+  while (argv.length) {
+    let a = argv.shift()
+    const indexOfEqualSign = a.indexOf('=')
+    if (indexOfEqualSign !== -1) {
+      const value = a.slice(indexOfEqualSign + 1)
+      a = a.slice(0, indexOfEqualSign)
+      argv.unshift(value)
+    }
+    switch (a) {
+      case '-rv': case '-rev': case '--rev': case '--reverse':
+        reverse = true
+        break
+      case '-l': case '--loose':
+        loose = true
+        break
+      case '-p': case '--include-prerelease':
+        includePrerelease = true
+        break
+      case '-v': case '--version':
+        versions.push(argv.shift())
+        break
+      case '-i': case '--inc': case '--increment':
+        switch (argv[0]) {
+          case 'major': case 'minor': case 'patch': case 'prerelease':
+          case 'premajor': case 'preminor': case 'prepatch':
+            inc = argv.shift()
+            break
+          default:
+            inc = 'patch'
+            break
+        }
+        break
+      case '--preid':
+        identifier = argv.shift()
+        break
+      case '-r': case '--range':
+        range.push(argv.shift())
+        break
+      case '-n':
+        identifierBase = argv.shift()
+        if (identifierBase === 'false') {
+          identifierBase = false
+        }
+        break
+      case '-c': case '--coerce':
+        coerce = true
+        break
+      case '--rtl':
+        rtl = true
+        break
+      case '--ltr':
+        rtl = false
+        break
+      case '-h': case '--help': case '-?':
+        return help()
+      default:
+        versions.push(a)
+        break
+    }
+  }
+
+  options = parseOptions({ loose, includePrerelease, rtl })
+
+  versions = versions.map((v) => {
+    return coerce ? (semver.coerce(v, options) || { version: v }).version : v
+  }).filter((v) => {
+    return semver.valid(v)
+  })
+  if (!versions.length) {
+    return fail()
+  }
+  if (inc && (versions.length !== 1 || range.length)) {
+    return failInc()
+  }
+
+  for (let i = 0, l = range.length; i < l; i++) {
+    versions = versions.filter((v) => {
+      return semver.satisfies(v, range[i], options)
+    })
+    if (!versions.length) {
+      return fail()
+    }
+  }
+  return success(versions)
+}
+
+const failInc = () => {
+  console.error('--inc can only be used on a single version with no range')
+  fail()
+}
+
+const fail = () => process.exit(1)
+
+const success = () => {
+  const compare = reverse ? 'rcompare' : 'compare'
+  versions.sort((a, b) => {
+    return semver[compare](a, b, options)
+  }).map((v) => {
+    return semver.clean(v, options)
+  }).map((v) => {
+    return inc ? semver.inc(v, inc, options, identifier, identifierBase) : v
+  }).forEach((v, i, _) => {
+    console.log(v)
+  })
+}
+
+const help = () => console.log(
+`SemVer ${version}
+
+A JavaScript implementation of the https://semver.org/ specification
+Copyright Isaac Z. Schlueter
+
+Usage: semver [options] <version> [<version> [...]]
+Prints valid versions sorted by SemVer precedence
+
+Options:
+-r --range <range>
+        Print versions that match the specified range.
+
+-i --increment [<level>]
+        Increment a version by the specified level.  Level can
+        be one of: major, minor, patch, premajor, preminor,
+        prepatch, or prerelease.  Default level is 'patch'.
+        Only one version may be specified.
+
+--preid <identifier>
+        Identifier to be used to prefix premajor, preminor,
+        prepatch or prerelease version increments.
+
+-l --loose
+        Interpret versions and ranges loosely
+
+-p --include-prerelease
+        Always include prerelease versions in range matching
+
+-c --coerce
+        Coerce a string into SemVer if possible
+        (does not imply --loose)
+
+--rtl
+        Coerce version strings right to left
+
+--ltr
+        Coerce version strings left to right (default)
+
+-n <base>
+        Base number to be used for the prerelease identifier.
+        Can be either 0 or 1, or false to omit the number altogether.
+        Defaults to 0.
+
+Program exits successfully if any valid version satisfies
+all supplied ranges, and prints all satisfying versions.
+
+If no satisfying versions are found, then exits failure.
+
+Versions are printed in ascending order, so supplying
+multiple versions to the utility will just sort them.`)
+
+main()
diff --git a/classes/comparator.js b/classes/comparator.js
new file mode 100644
index 00000000..3d39c0ee
--- /dev/null
+++ b/classes/comparator.js
@@ -0,0 +1,141 @@
+const ANY = Symbol('SemVer ANY')
+// hoisted class for cyclic dependency
+class Comparator {
+  static get ANY () {
+    return ANY
+  }
+
+  constructor (comp, options) {
+    options = parseOptions(options)
+
+    if (comp instanceof Comparator) {
+      if (comp.loose === !!options.loose) {
+        return comp
+      } else {
+        comp = comp.value
+      }
+    }
+
+    comp = comp.trim().split(/\s+/).join(' ')
+    debug('comparator', comp, options)
+    this.options = options
+    this.loose = !!options.loose
+    this.parse(comp)
+
+    if (this.semver === ANY) {
+      this.value = ''
+    } else {
+      this.value = this.operator + this.semver.version
+    }
+
+    debug('comp', this)
+  }
+
+  parse (comp) {
+    const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]
+    const m = comp.match(r)
+
+    if (!m) {
+      throw new TypeError(`Invalid comparator: ${comp}`)
+    }
+
+    this.operator = m[1] !== undefined ? m[1] : ''
+    if (this.operator === '=') {
+      this.operator = ''
+    }
+
+    // if it literally is just '>' or '' then allow anything.
+    if (!m[2]) {
+      this.semver = ANY
+    } else {
+      this.semver = new SemVer(m[2], this.options.loose)
+    }
+  }
+
+  toString () {
+    return this.value
+  }
+
+  test (version) {
+    debug('Comparator.test', version, this.options.loose)
+
+    if (this.semver === ANY || version === ANY) {
+      return true
+    }
+
+    if (typeof version === 'string') {
+      try {
+        version = new SemVer(version, this.options)
+      } catch (er) {
+        return false
+      }
+    }
+
+    return cmp(version, this.operator, this.semver, this.options)
+  }
+
+  intersects (comp, options) {
+    if (!(comp instanceof Comparator)) {
+      throw new TypeError('a Comparator is required')
+    }
+
+    if (this.operator === '') {
+      if (this.value === '') {
+        return true
+      }
+      return new Range(comp.value, options).test(this.value)
+    } else if (comp.operator === '') {
+      if (comp.value === '') {
+        return true
+      }
+      return new Range(this.value, options).test(comp.semver)
+    }
+
+    options = parseOptions(options)
+
+    // Special cases where nothing can possibly be lower
+    if (options.includePrerelease &&
+      (this.value === '<0.0.0-0' || comp.value === '<0.0.0-0')) {
+      return false
+    }
+    if (!options.includePrerelease &&
+      (this.value.startsWith('<0.0.0') || comp.value.startsWith('<0.0.0'))) {
+      return false
+    }
+
+    // Same direction increasing (> or >=)
+    if (this.operator.startsWith('>') && comp.operator.startsWith('>')) {
+      return true
+    }
+    // Same direction decreasing (< or <=)
+    if (this.operator.startsWith('<') && comp.operator.startsWith('<')) {
+      return true
+    }
+    // same SemVer and both sides are inclusive (<= or >=)
+    if (
+      (this.semver.version === comp.semver.version) &&
+      this.operator.includes('=') && comp.operator.includes('=')) {
+      return true
+    }
+    // opposite directions less than
+    if (cmp(this.semver, '<', comp.semver, options) &&
+      this.operator.startsWith('>') && comp.operator.startsWith('<')) {
+      return true
+    }
+    // opposite directions greater than
+    if (cmp(this.semver, '>', comp.semver, options) &&
+      this.operator.startsWith('<') && comp.operator.startsWith('>')) {
+      return true
+    }
+    return false
+  }
+}
+
+module.exports = Comparator
+
+const parseOptions = require('../internal/parse-options')
+const { safeRe: re, t } = require('../internal/re')
+const cmp = require('../functions/cmp')
+const debug = require('../internal/debug')
+const SemVer = require('./semver')
+const Range = require('./range')
diff --git a/classes/index.js b/classes/index.js
new file mode 100644
index 00000000..5e3f5c9b
--- /dev/null
+++ b/classes/index.js
@@ -0,0 +1,5 @@
+module.exports = {
+  SemVer: require('./semver.js'),
+  Range: require('./range.js'),
+  Comparator: require('./comparator.js'),
+}
diff --git a/classes/range.js b/classes/range.js
new file mode 100644
index 00000000..7e7c4141
--- /dev/null
+++ b/classes/range.js
@@ -0,0 +1,539 @@
+// hoisted class for cyclic dependency
+class Range {
+  constructor (range, options) {
+    options = parseOptions(options)
+
+    if (range instanceof Range) {
+      if (
+        range.loose === !!options.loose &&
+        range.includePrerelease === !!options.includePrerelease
+      ) {
+        return range
+      } else {
+        return new Range(range.raw, options)
+      }
+    }
+
+    if (range instanceof Comparator) {
+      // just put it in the set and return
+      this.raw = range.value
+      this.set = [[range]]
+      this.format()
+      return this
+    }
+
+    this.options = options
+    this.loose = !!options.loose
+    this.includePrerelease = !!options.includePrerelease
+
+    // First reduce all whitespace as much as possible so we do not have to rely
+    // on potentially slow regexes like \s*. This is then stored and used for
+    // future error messages as well.
+    this.raw = range
+      .trim()
+      .split(/\s+/)
+      .join(' ')
+
+    // First, split on ||
+    this.set = this.raw
+      .split('||')
+      // map the range to a 2d array of comparators
+      .map(r => this.parseRange(r.trim()))
+      // throw out any comparator lists that are empty
+      // this generally means that it was not a valid range, which is allowed
+      // in loose mode, but will still throw if the WHOLE range is invalid.
+      .filter(c => c.length)
+
+    if (!this.set.length) {
+      throw new TypeError(`Invalid SemVer Range: ${this.raw}`)
+    }
+
+    // if we have any that are not the null set, throw out null sets.
+    if (this.set.length > 1) {
+      // keep the first one, in case they're all null sets
+      const first = this.set[0]
+      this.set = this.set.filter(c => !isNullSet(c[0]))
+      if (this.set.length === 0) {
+        this.set = [first]
+      } else if (this.set.length > 1) {
+        // if we have any that are *, then the range is just *
+        for (const c of this.set) {
+          if (c.length === 1 && isAny(c[0])) {
+            this.set = [c]
+            break
+          }
+        }
+      }
+    }
+
+    this.format()
+  }
+
+  format () {
+    this.range = this.set
+      .map((comps) => comps.join(' ').trim())
+      .join('||')
+      .trim()
+    return this.range
+  }
+
+  toString () {
+    return this.range
+  }
+
+  parseRange (range) {
+    // memoize range parsing for performance.
+    // this is a very hot path, and fully deterministic.
+    const memoOpts =
+      (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) |
+      (this.options.loose && FLAG_LOOSE)
+    const memoKey = memoOpts + ':' + range
+    const cached = cache.get(memoKey)
+    if (cached) {
+      return cached
+    }
+
+    const loose = this.options.loose
+    // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
+    const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE]
+    range = range.replace(hr, hyphenReplace(this.options.includePrerelease))
+    debug('hyphen replace', range)
+
+    // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
+    range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace)
+    debug('comparator trim', range)
+
+    // `~ 1.2.3` => `~1.2.3`
+    range = range.replace(re[t.TILDETRIM], tildeTrimReplace)
+    debug('tilde trim', range)
+
+    // `^ 1.2.3` => `^1.2.3`
+    range = range.replace(re[t.CARETTRIM], caretTrimReplace)
+    debug('caret trim', range)
+
+    // At this point, the range is completely trimmed and
+    // ready to be split into comparators.
+
+    let rangeList = range
+      .split(' ')
+      .map(comp => parseComparator(comp, this.options))
+      .join(' ')
+      .split(/\s+/)
+      // >=0.0.0 is equivalent to *
+      .map(comp => replaceGTE0(comp, this.options))
+
+    if (loose) {
+      // in loose mode, throw out any that are not valid comparators
+      rangeList = rangeList.filter(comp => {
+        debug('loose invalid filter', comp, this.options)
+        return !!comp.match(re[t.COMPARATORLOOSE])
+      })
+    }
+    debug('range list', rangeList)
+
+    // if any comparators are the null set, then replace with JUST null set
+    // if more than one comparator, remove any * comparators
+    // also, don't include the same comparator more than once
+    const rangeMap = new Map()
+    const comparators = rangeList.map(comp => new Comparator(comp, this.options))
+    for (const comp of comparators) {
+      if (isNullSet(comp)) {
+        return [comp]
+      }
+      rangeMap.set(comp.value, comp)
+    }
+    if (rangeMap.size > 1 && rangeMap.has('')) {
+      rangeMap.delete('')
+    }
+
+    const result = [...rangeMap.values()]
+    cache.set(memoKey, result)
+    return result
+  }
+
+  intersects (range, options) {
+    if (!(range instanceof Range)) {
+      throw new TypeError('a Range is required')
+    }
+
+    return this.set.some((thisComparators) => {
+      return (
+        isSatisfiable(thisComparators, options) &&
+        range.set.some((rangeComparators) => {
+          return (
+            isSatisfiable(rangeComparators, options) &&
+            thisComparators.every((thisComparator) => {
+              return rangeComparators.every((rangeComparator) => {
+                return thisComparator.intersects(rangeComparator, options)
+              })
+            })
+          )
+        })
+      )
+    })
+  }
+
+  // if ANY of the sets match ALL of its comparators, then pass
+  test (version) {
+    if (!version) {
+      return false
+    }
+
+    if (typeof version === 'string') {
+      try {
+        version = new SemVer(version, this.options)
+      } catch (er) {
+        return false
+      }
+    }
+
+    for (let i = 0; i < this.set.length; i++) {
+      if (testSet(this.set[i], version, this.options)) {
+        return true
+      }
+    }
+    return false
+  }
+}
+
+module.exports = Range
+
+const LRU = require('lru-cache')
+const cache = new LRU({ max: 1000 })
+
+const parseOptions = require('../internal/parse-options')
+const Comparator = require('./comparator')
+const debug = require('../internal/debug')
+const SemVer = require('./semver')
+const {
+  safeRe: re,
+  t,
+  comparatorTrimReplace,
+  tildeTrimReplace,
+  caretTrimReplace,
+} = require('../internal/re')
+const { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require('../internal/constants')
+
+const isNullSet = c => c.value === '<0.0.0-0'
+const isAny = c => c.value === ''
+
+// take a set of comparators and determine whether there
+// exists a version which can satisfy it
+const isSatisfiable = (comparators, options) => {
+  let result = true
+  const remainingComparators = comparators.slice()
+  let testComparator = remainingComparators.pop()
+
+  while (result && remainingComparators.length) {
+    result = remainingComparators.every((otherComparator) => {
+      return testComparator.intersects(otherComparator, options)
+    })
+
+    testComparator = remainingComparators.pop()
+  }
+
+  return result
+}
+
+// comprised of xranges, tildes, stars, and gtlt's at this point.
+// already replaced the hyphen ranges
+// turn into a set of JUST comparators.
+const parseComparator = (comp, options) => {
+  debug('comp', comp, options)
+  comp = replaceCarets(comp, options)
+  debug('caret', comp)
+  comp = replaceTildes(comp, options)
+  debug('tildes', comp)
+  comp = replaceXRanges(comp, options)
+  debug('xrange', comp)
+  comp = replaceStars(comp, options)
+  debug('stars', comp)
+  return comp
+}
+
+const isX = id => !id || id.toLowerCase() === 'x' || id === '*'
+
+// ~, ~> --> * (any, kinda silly)
+// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0
+// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0
+// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0
+// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0
+// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0
+// ~0.0.1 --> >=0.0.1 <0.1.0-0
+const replaceTildes = (comp, options) => {
+  return comp
+    .trim()
+    .split(/\s+/)
+    .map((c) => replaceTilde(c, options))
+    .join(' ')
+}
+
+const replaceTilde = (comp, options) => {
+  const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE]
+  return comp.replace(r, (_, M, m, p, pr) => {
+    debug('tilde', comp, _, M, m, p, pr)
+    let ret
+
+    if (isX(M)) {
+      ret = ''
+    } else if (isX(m)) {
+      ret = `>=${M}.0.0 <${+M + 1}.0.0-0`
+    } else if (isX(p)) {
+      // ~1.2 == >=1.2.0 <1.3.0-0
+      ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`
+    } else if (pr) {
+      debug('replaceTilde pr', pr)
+      ret = `>=${M}.${m}.${p}-${pr
+      } <${M}.${+m + 1}.0-0`
+    } else {
+      // ~1.2.3 == >=1.2.3 <1.3.0-0
+      ret = `>=${M}.${m}.${p
+      } <${M}.${+m + 1}.0-0`
+    }
+
+    debug('tilde return', ret)
+    return ret
+  })
+}
+
+// ^ --> * (any, kinda silly)
+// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0
+// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0
+// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0
+// ^1.2.3 --> >=1.2.3 <2.0.0-0
+// ^1.2.0 --> >=1.2.0 <2.0.0-0
+// ^0.0.1 --> >=0.0.1 <0.0.2-0
+// ^0.1.0 --> >=0.1.0 <0.2.0-0
+const replaceCarets = (comp, options) => {
+  return comp
+    .trim()
+    .split(/\s+/)
+    .map((c) => replaceCaret(c, options))
+    .join(' ')
+}
+
+const replaceCaret = (comp, options) => {
+  debug('caret', comp, options)
+  const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET]
+  const z = options.includePrerelease ? '-0' : ''
+  return comp.replace(r, (_, M, m, p, pr) => {
+    debug('caret', comp, _, M, m, p, pr)
+    let ret
+
+    if (isX(M)) {
+      ret = ''
+    } else if (isX(m)) {
+      ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`
+    } else if (isX(p)) {
+      if (M === '0') {
+        ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`
+      } else {
+        ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`
+      }
+    } else if (pr) {
+      debug('replaceCaret pr', pr)
+      if (M === '0') {
+        if (m === '0') {
+          ret = `>=${M}.${m}.${p}-${pr
+          } <${M}.${m}.${+p + 1}-0`
+        } else {
+          ret = `>=${M}.${m}.${p}-${pr
+          } <${M}.${+m + 1}.0-0`
+        }
+      } else {
+        ret = `>=${M}.${m}.${p}-${pr
+        } <${+M + 1}.0.0-0`
+      }
+    } else {
+      debug('no pr')
+      if (M === '0') {
+        if (m === '0') {
+          ret = `>=${M}.${m}.${p
+          }${z} <${M}.${m}.${+p + 1}-0`
+        } else {
+          ret = `>=${M}.${m}.${p
+          }${z} <${M}.${+m + 1}.0-0`
+        }
+      } else {
+        ret = `>=${M}.${m}.${p
+        } <${+M + 1}.0.0-0`
+      }
+    }
+
+    debug('caret return', ret)
+    return ret
+  })
+}
+
+const replaceXRanges = (comp, options) => {
+  debug('replaceXRanges', comp, options)
+  return comp
+    .split(/\s+/)
+    .map((c) => replaceXRange(c, options))
+    .join(' ')
+}
+
+const replaceXRange = (comp, options) => {
+  comp = comp.trim()
+  const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE]
+  return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
+    debug('xRange', comp, ret, gtlt, M, m, p, pr)
+    const xM = isX(M)
+    const xm = xM || isX(m)
+    const xp = xm || isX(p)
+    const anyX = xp
+
+    if (gtlt === '=' && anyX) {
+      gtlt = ''
+    }
+
+    // if we're including prereleases in the match, then we need
+    // to fix this to -0, the lowest possible prerelease value
+    pr = options.includePrerelease ? '-0' : ''
+
+    if (xM) {
+      if (gtlt === '>' || gtlt === '<') {
+        // nothing is allowed
+        ret = '<0.0.0-0'
+      } else {
+        // nothing is forbidden
+        ret = '*'
+      }
+    } else if (gtlt && anyX) {
+      // we know patch is an x, because we have any x at all.
+      // replace X with 0
+      if (xm) {
+        m = 0
+      }
+      p = 0
+
+      if (gtlt === '>') {
+        // >1 => >=2.0.0
+        // >1.2 => >=1.3.0
+        gtlt = '>='
+        if (xm) {
+          M = +M + 1
+          m = 0
+          p = 0
+        } else {
+          m = +m + 1
+          p = 0
+        }
+      } else if (gtlt === '<=') {
+        // <=0.7.x is actually <0.8.0, since any 0.7.x should
+        // pass.  Similarly, <=7.x is actually <8.0.0, etc.
+        gtlt = '<'
+        if (xm) {
+          M = +M + 1
+        } else {
+          m = +m + 1
+        }
+      }
+
+      if (gtlt === '<') {
+        pr = '-0'
+      }
+
+      ret = `${gtlt + M}.${m}.${p}${pr}`
+    } else if (xm) {
+      ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`
+    } else if (xp) {
+      ret = `>=${M}.${m}.0${pr
+      } <${M}.${+m + 1}.0-0`
+    }
+
+    debug('xRange return', ret)
+
+    return ret
+  })
+}
+
+// Because * is AND-ed with everything else in the comparator,
+// and '' means "any version", just remove the *s entirely.
+const replaceStars = (comp, options) => {
+  debug('replaceStars', comp, options)
+  // Looseness is ignored here.  star is always as loose as it gets!
+  return comp
+    .trim()
+    .replace(re[t.STAR], '')
+}
+
+const replaceGTE0 = (comp, options) => {
+  debug('replaceGTE0', comp, options)
+  return comp
+    .trim()
+    .replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '')
+}
+
+// This function is passed to string.replace(re[t.HYPHENRANGE])
+// M, m, patch, prerelease, build
+// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
+// 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do
+// 1.2 - 3.4 => >=1.2.0 <3.5.0-0
+const hyphenReplace = incPr => ($0,
+  from, fM, fm, fp, fpr, fb,
+  to, tM, tm, tp, tpr, tb) => {
+  if (isX(fM)) {
+    from = ''
+  } else if (isX(fm)) {
+    from = `>=${fM}.0.0${incPr ? '-0' : ''}`
+  } else if (isX(fp)) {
+    from = `>=${fM}.${fm}.0${incPr ? '-0' : ''}`
+  } else if (fpr) {
+    from = `>=${from}`
+  } else {
+    from = `>=${from}${incPr ? '-0' : ''}`
+  }
+
+  if (isX(tM)) {
+    to = ''
+  } else if (isX(tm)) {
+    to = `<${+tM + 1}.0.0-0`
+  } else if (isX(tp)) {
+    to = `<${tM}.${+tm + 1}.0-0`
+  } else if (tpr) {
+    to = `<=${tM}.${tm}.${tp}-${tpr}`
+  } else if (incPr) {
+    to = `<${tM}.${tm}.${+tp + 1}-0`
+  } else {
+    to = `<=${to}`
+  }
+
+  return `${from} ${to}`.trim()
+}
+
+const testSet = (set, version, options) => {
+  for (let i = 0; i < set.length; i++) {
+    if (!set[i].test(version)) {
+      return false
+    }
+  }
+
+  if (version.prerelease.length && !options.includePrerelease) {
+    // Find the set of versions that are allowed to have prereleases
+    // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
+    // That should allow `1.2.3-pr.2` to pass.
+    // However, `1.2.4-alpha.notready` should NOT be allowed,
+    // even though it's within the range set by the comparators.
+    for (let i = 0; i < set.length; i++) {
+      debug(set[i].semver)
+      if (set[i].semver === Comparator.ANY) {
+        continue
+      }
+
+      if (set[i].semver.prerelease.length > 0) {
+        const allowed = set[i].semver
+        if (allowed.major === version.major &&
+            allowed.minor === version.minor &&
+            allowed.patch === version.patch) {
+          return true
+        }
+      }
+    }
+
+    // Version has a -pre, but it's not one of the ones we like.
+    return false
+  }
+
+  return true
+}
diff --git a/classes/semver.js b/classes/semver.js
new file mode 100644
index 00000000..84e84590
--- /dev/null
+++ b/classes/semver.js
@@ -0,0 +1,302 @@
+const debug = require('../internal/debug')
+const { MAX_LENGTH, MAX_SAFE_INTEGER } = require('../internal/constants')
+const { safeRe: re, t } = require('../internal/re')
+
+const parseOptions = require('../internal/parse-options')
+const { compareIdentifiers } = require('../internal/identifiers')
+class SemVer {
+  constructor (version, options) {
+    options = parseOptions(options)
+
+    if (version instanceof SemVer) {
+      if (version.loose === !!options.loose &&
+          version.includePrerelease === !!options.includePrerelease) {
+        return version
+      } else {
+        version = version.version
+      }
+    } else if (typeof version !== 'string') {
+      throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`)
+    }
+
+    if (version.length > MAX_LENGTH) {
+      throw new TypeError(
+        `version is longer than ${MAX_LENGTH} characters`
+      )
+    }
+
+    debug('SemVer', version, options)
+    this.options = options
+    this.loose = !!options.loose
+    // this isn't actually relevant for versions, but keep it so that we
+    // don't run into trouble passing this.options around.
+    this.includePrerelease = !!options.includePrerelease
+
+    const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL])
+
+    if (!m) {
+      throw new TypeError(`Invalid Version: ${version}`)
+    }
+
+    this.raw = version
+
+    // these are actually numbers
+    this.major = +m[1]
+    this.minor = +m[2]
+    this.patch = +m[3]
+
+    if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+      throw new TypeError('Invalid major version')
+    }
+
+    if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+      throw new TypeError('Invalid minor version')
+    }
+
+    if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+      throw new TypeError('Invalid patch version')
+    }
+
+    // numberify any prerelease numeric ids
+    if (!m[4]) {
+      this.prerelease = []
+    } else {
+      this.prerelease = m[4].split('.').map((id) => {
+        if (/^[0-9]+$/.test(id)) {
+          const num = +id
+          if (num >= 0 && num < MAX_SAFE_INTEGER) {
+            return num
+          }
+        }
+        return id
+      })
+    }
+
+    this.build = m[5] ? m[5].split('.') : []
+    this.format()
+  }
+
+  format () {
+    this.version = `${this.major}.${this.minor}.${this.patch}`
+    if (this.prerelease.length) {
+      this.version += `-${this.prerelease.join('.')}`
+    }
+    return this.version
+  }
+
+  toString () {
+    return this.version
+  }
+
+  compare (other) {
+    debug('SemVer.compare', this.version, this.options, other)
+    if (!(other instanceof SemVer)) {
+      if (typeof other === 'string' && other === this.version) {
+        return 0
+      }
+      other = new SemVer(other, this.options)
+    }
+
+    if (other.version === this.version) {
+      return 0
+    }
+
+    return this.compareMain(other) || this.comparePre(other)
+  }
+
+  compareMain (other) {
+    if (!(other instanceof SemVer)) {
+      other = new SemVer(other, this.options)
+    }
+
+    return (
+      compareIdentifiers(this.major, other.major) ||
+      compareIdentifiers(this.minor, other.minor) ||
+      compareIdentifiers(this.patch, other.patch)
+    )
+  }
+
+  comparePre (other) {
+    if (!(other instanceof SemVer)) {
+      other = new SemVer(other, this.options)
+    }
+
+    // NOT having a prerelease is > having one
+    if (this.prerelease.length && !other.prerelease.length) {
+      return -1
+    } else if (!this.prerelease.length && other.prerelease.length) {
+      return 1
+    } else if (!this.prerelease.length && !other.prerelease.length) {
+      return 0
+    }
+
+    let i = 0
+    do {
+      const a = this.prerelease[i]
+      const b = other.prerelease[i]
+      debug('prerelease compare', i, a, b)
+      if (a === undefined && b === undefined) {
+        return 0
+      } else if (b === undefined) {
+        return 1
+      } else if (a === undefined) {
+        return -1
+      } else if (a === b) {
+        continue
+      } else {
+        return compareIdentifiers(a, b)
+      }
+    } while (++i)
+  }
+
+  compareBuild (other) {
+    if (!(other instanceof SemVer)) {
+      other = new SemVer(other, this.options)
+    }
+
+    let i = 0
+    do {
+      const a = this.build[i]
+      const b = other.build[i]
+      debug('prerelease compare', i, a, b)
+      if (a === undefined && b === undefined) {
+        return 0
+      } else if (b === undefined) {
+        return 1
+      } else if (a === undefined) {
+        return -1
+      } else if (a === b) {
+        continue
+      } else {
+        return compareIdentifiers(a, b)
+      }
+    } while (++i)
+  }
+
+  // preminor will bump the version up to the next minor release, and immediately
+  // down to pre-release. premajor and prepatch work the same way.
+  inc (release, identifier, identifierBase) {
+    switch (release) {
+      case 'premajor':
+        this.prerelease.length = 0
+        this.patch = 0
+        this.minor = 0
+        this.major++
+        this.inc('pre', identifier, identifierBase)
+        break
+      case 'preminor':
+        this.prerelease.length = 0
+        this.patch = 0
+        this.minor++
+        this.inc('pre', identifier, identifierBase)
+        break
+      case 'prepatch':
+        // If this is already a prerelease, it will bump to the next version
+        // drop any prereleases that might already exist, since they are not
+        // relevant at this point.
+        this.prerelease.length = 0
+        this.inc('patch', identifier, identifierBase)
+        this.inc('pre', identifier, identifierBase)
+        break
+      // If the input is a non-prerelease version, this acts the same as
+      // prepatch.
+      case 'prerelease':
+        if (this.prerelease.length === 0) {
+          this.inc('patch', identifier, identifierBase)
+        }
+        this.inc('pre', identifier, identifierBase)
+        break
+
+      case 'major':
+        // If this is a pre-major version, bump up to the same major version.
+        // Otherwise increment major.
+        // 1.0.0-5 bumps to 1.0.0
+        // 1.1.0 bumps to 2.0.0
+        if (
+          this.minor !== 0 ||
+          this.patch !== 0 ||
+          this.prerelease.length === 0
+        ) {
+          this.major++
+        }
+        this.minor = 0
+        this.patch = 0
+        this.prerelease = []
+        break
+      case 'minor':
+        // If this is a pre-minor version, bump up to the same minor version.
+        // Otherwise increment minor.
+        // 1.2.0-5 bumps to 1.2.0
+        // 1.2.1 bumps to 1.3.0
+        if (this.patch !== 0 || this.prerelease.length === 0) {
+          this.minor++
+        }
+        this.patch = 0
+        this.prerelease = []
+        break
+      case 'patch':
+        // If this is not a pre-release version, it will increment the patch.
+        // If it is a pre-release it will bump up to the same patch version.
+        // 1.2.0-5 patches to 1.2.0
+        // 1.2.0 patches to 1.2.1
+        if (this.prerelease.length === 0) {
+          this.patch++
+        }
+        this.prerelease = []
+        break
+      // This probably shouldn't be used publicly.
+      // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
+      case 'pre': {
+        const base = Number(identifierBase) ? 1 : 0
+
+        if (!identifier && identifierBase === false) {
+          throw new Error('invalid increment argument: identifier is empty')
+        }
+
+        if (this.prerelease.length === 0) {
+          this.prerelease = [base]
+        } else {
+          let i = this.prerelease.length
+          while (--i >= 0) {
+            if (typeof this.prerelease[i] === 'number') {
+              this.prerelease[i]++
+              i = -2
+            }
+          }
+          if (i === -1) {
+            // didn't increment anything
+            if (identifier === this.prerelease.join('.') && identifierBase === false) {
+              throw new Error('invalid increment argument: identifier already exists')
+            }
+            this.prerelease.push(base)
+          }
+        }
+        if (identifier) {
+          // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
+          // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
+          let prerelease = [identifier, base]
+          if (identifierBase === false) {
+            prerelease = [identifier]
+          }
+          if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
+            if (isNaN(this.prerelease[1])) {
+              this.prerelease = prerelease
+            }
+          } else {
+            this.prerelease = prerelease
+          }
+        }
+        break
+      }
+      default:
+        throw new Error(`invalid increment argument: ${release}`)
+    }
+    this.raw = this.format()
+    if (this.build.length) {
+      this.raw += `+${this.build.join('.')}`
+    }
+    return this
+  }
+}
+
+module.exports = SemVer
diff --git a/functions/clean.js b/functions/clean.js
new file mode 100644
index 00000000..811fe6b8
--- /dev/null
+++ b/functions/clean.js
@@ -0,0 +1,6 @@
+const parse = require('./parse')
+const clean = (version, options) => {
+  const s = parse(version.trim().replace(/^[=v]+/, ''), options)
+  return s ? s.version : null
+}
+module.exports = clean
diff --git a/functions/cmp.js b/functions/cmp.js
new file mode 100644
index 00000000..40119094
--- /dev/null
+++ b/functions/cmp.js
@@ -0,0 +1,52 @@
+const eq = require('./eq')
+const neq = require('./neq')
+const gt = require('./gt')
+const gte = require('./gte')
+const lt = require('./lt')
+const lte = require('./lte')
+
+const cmp = (a, op, b, loose) => {
+  switch (op) {
+    case '===':
+      if (typeof a === 'object') {
+        a = a.version
+      }
+      if (typeof b === 'object') {
+        b = b.version
+      }
+      return a === b
+
+    case '!==':
+      if (typeof a === 'object') {
+        a = a.version
+      }
+      if (typeof b === 'object') {
+        b = b.version
+      }
+      return a !== b
+
+    case '':
+    case '=':
+    case '==':
+      return eq(a, b, loose)
+
+    case '!=':
+      return neq(a, b, loose)
+
+    case '>':
+      return gt(a, b, loose)
+
+    case '>=':
+      return gte(a, b, loose)
+
+    case '<':
+      return lt(a, b, loose)
+
+    case '<=':
+      return lte(a, b, loose)
+
+    default:
+      throw new TypeError(`Invalid operator: ${op}`)
+  }
+}
+module.exports = cmp
diff --git a/functions/coerce.js b/functions/coerce.js
new file mode 100644
index 00000000..b378dcea
--- /dev/null
+++ b/functions/coerce.js
@@ -0,0 +1,60 @@
+const SemVer = require('../classes/semver')
+const parse = require('./parse')
+const { safeRe: re, t } = require('../internal/re')
+
+const coerce = (version, options) => {
+  if (version instanceof SemVer) {
+    return version
+  }
+
+  if (typeof version === 'number') {
+    version = String(version)
+  }
+
+  if (typeof version !== 'string') {
+    return null
+  }
+
+  options = options || {}
+
+  let match = null
+  if (!options.rtl) {
+    match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE])
+  } else {
+    // Find the right-most coercible string that does not share
+    // a terminus with a more left-ward coercible string.
+    // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'
+    // With includePrerelease option set, '1.2.3.4-rc' wants to coerce '2.3.4-rc', not '2.3.4'
+    //
+    // Walk through the string checking with a /g regexp
+    // Manually set the index so as to pick up overlapping matches.
+    // Stop when we get a match that ends at the string end, since no
+    // coercible string can be more right-ward without the same terminus.
+    const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL]
+    let next
+    while ((next = coerceRtlRegex.exec(version)) &&
+        (!match || match.index + match[0].length !== version.length)
+    ) {
+      if (!match ||
+            next.index + next[0].length !== match.index + match[0].length) {
+        match = next
+      }
+      coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length
+    }
+    // leave it in a clean state
+    coerceRtlRegex.lastIndex = -1
+  }
+
+  if (match === null) {
+    return null
+  }
+
+  const major = match[2]
+  const minor = match[3] || '0'
+  const patch = match[4] || '0'
+  const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : ''
+  const build = options.includePrerelease && match[6] ? `+${match[6]}` : ''
+
+  return parse(`${major}.${minor}.${patch}${prerelease}${build}`, options)
+}
+module.exports = coerce
diff --git a/functions/compare-build.js b/functions/compare-build.js
new file mode 100644
index 00000000..9eb881be
--- /dev/null
+++ b/functions/compare-build.js
@@ -0,0 +1,7 @@
+const SemVer = require('../classes/semver')
+const compareBuild = (a, b, loose) => {
+  const versionA = new SemVer(a, loose)
+  const versionB = new SemVer(b, loose)
+  return versionA.compare(versionB) || versionA.compareBuild(versionB)
+}
+module.exports = compareBuild
diff --git a/functions/compare-loose.js b/functions/compare-loose.js
new file mode 100644
index 00000000..4881fbe0
--- /dev/null
+++ b/functions/compare-loose.js
@@ -0,0 +1,3 @@
+const compare = require('./compare')
+const compareLoose = (a, b) => compare(a, b, true)
+module.exports = compareLoose
diff --git a/functions/compare.js b/functions/compare.js
new file mode 100644
index 00000000..748b7afa
--- /dev/null
+++ b/functions/compare.js
@@ -0,0 +1,5 @@
+const SemVer = require('../classes/semver')
+const compare = (a, b, loose) =>
+  new SemVer(a, loose).compare(new SemVer(b, loose))
+
+module.exports = compare
diff --git a/functions/diff.js b/functions/diff.js
new file mode 100644
index 00000000..fc224e30
--- /dev/null
+++ b/functions/diff.js
@@ -0,0 +1,65 @@
+const parse = require('./parse.js')
+
+const diff = (version1, version2) => {
+  const v1 = parse(version1, null, true)
+  const v2 = parse(version2, null, true)
+  const comparison = v1.compare(v2)
+
+  if (comparison === 0) {
+    return null
+  }
+
+  const v1Higher = comparison > 0
+  const highVersion = v1Higher ? v1 : v2
+  const lowVersion = v1Higher ? v2 : v1
+  const highHasPre = !!highVersion.prerelease.length
+  const lowHasPre = !!lowVersion.prerelease.length
+
+  if (lowHasPre && !highHasPre) {
+    // Going from prerelease -> no prerelease requires some special casing
+
+    // If the low version has only a major, then it will always be a major
+    // Some examples:
+    // 1.0.0-1 -> 1.0.0
+    // 1.0.0-1 -> 1.1.1
+    // 1.0.0-1 -> 2.0.0
+    if (!lowVersion.patch && !lowVersion.minor) {
+      return 'major'
+    }
+
+    // Otherwise it can be determined by checking the high version
+
+    if (highVersion.patch) {
+      // anything higher than a patch bump would result in the wrong version
+      return 'patch'
+    }
+
+    if (highVersion.minor) {
+      // anything higher than a minor bump would result in the wrong version
+      return 'minor'
+    }
+
+    // bumping major/minor/patch all have same result
+    return 'major'
+  }
+
+  // add the `pre` prefix if we are going to a prerelease version
+  const prefix = highHasPre ? 'pre' : ''
+
+  if (v1.major !== v2.major) {
+    return prefix + 'major'
+  }
+
+  if (v1.minor !== v2.minor) {
+    return prefix + 'minor'
+  }
+
+  if (v1.patch !== v2.patch) {
+    return prefix + 'patch'
+  }
+
+  // high and low are preleases
+  return 'prerelease'
+}
+
+module.exports = diff
diff --git a/functions/eq.js b/functions/eq.js
new file mode 100644
index 00000000..271fed97
--- /dev/null
+++ b/functions/eq.js
@@ -0,0 +1,3 @@
+const compare = require('./compare')
+const eq = (a, b, loose) => compare(a, b, loose) === 0
+module.exports = eq
diff --git a/functions/gt.js b/functions/gt.js
new file mode 100644
index 00000000..d9b2156d
--- /dev/null
+++ b/functions/gt.js
@@ -0,0 +1,3 @@
+const compare = require('./compare')
+const gt = (a, b, loose) => compare(a, b, loose) > 0
+module.exports = gt
diff --git a/functions/gte.js b/functions/gte.js
new file mode 100644
index 00000000..5aeaa634
--- /dev/null
+++ b/functions/gte.js
@@ -0,0 +1,3 @@
+const compare = require('./compare')
+const gte = (a, b, loose) => compare(a, b, loose) >= 0
+module.exports = gte
diff --git a/functions/inc.js b/functions/inc.js
new file mode 100644
index 00000000..7670b1be
--- /dev/null
+++ b/functions/inc.js
@@ -0,0 +1,19 @@
+const SemVer = require('../classes/semver')
+
+const inc = (version, release, options, identifier, identifierBase) => {
+  if (typeof (options) === 'string') {
+    identifierBase = identifier
+    identifier = options
+    options = undefined
+  }
+
+  try {
+    return new SemVer(
+      version instanceof SemVer ? version.version : version,
+      options
+    ).inc(release, identifier, identifierBase).version
+  } catch (er) {
+    return null
+  }
+}
+module.exports = inc
diff --git a/functions/lt.js b/functions/lt.js
new file mode 100644
index 00000000..b440ab7d
--- /dev/null
+++ b/functions/lt.js
@@ -0,0 +1,3 @@
+const compare = require('./compare')
+const lt = (a, b, loose) => compare(a, b, loose) < 0
+module.exports = lt
diff --git a/functions/lte.js b/functions/lte.js
new file mode 100644
index 00000000..6dcc9565
--- /dev/null
+++ b/functions/lte.js
@@ -0,0 +1,3 @@
+const compare = require('./compare')
+const lte = (a, b, loose) => compare(a, b, loose) <= 0
+module.exports = lte
diff --git a/functions/major.js b/functions/major.js
new file mode 100644
index 00000000..4283165e
--- /dev/null
+++ b/functions/major.js
@@ -0,0 +1,3 @@
+const SemVer = require('../classes/semver')
+const major = (a, loose) => new SemVer(a, loose).major
+module.exports = major
diff --git a/functions/minor.js b/functions/minor.js
new file mode 100644
index 00000000..57b3455f
--- /dev/null
+++ b/functions/minor.js
@@ -0,0 +1,3 @@
+const SemVer = require('../classes/semver')
+const minor = (a, loose) => new SemVer(a, loose).minor
+module.exports = minor
diff --git a/functions/neq.js b/functions/neq.js
new file mode 100644
index 00000000..f944c015
--- /dev/null
+++ b/functions/neq.js
@@ -0,0 +1,3 @@
+const compare = require('./compare')
+const neq = (a, b, loose) => compare(a, b, loose) !== 0
+module.exports = neq
diff --git a/functions/parse.js b/functions/parse.js
new file mode 100644
index 00000000..459b3b17
--- /dev/null
+++ b/functions/parse.js
@@ -0,0 +1,16 @@
+const SemVer = require('../classes/semver')
+const parse = (version, options, throwErrors = false) => {
+  if (version instanceof SemVer) {
+    return version
+  }
+  try {
+    return new SemVer(version, options)
+  } catch (er) {
+    if (!throwErrors) {
+      return null
+    }
+    throw er
+  }
+}
+
+module.exports = parse
diff --git a/functions/patch.js b/functions/patch.js
new file mode 100644
index 00000000..63afca25
--- /dev/null
+++ b/functions/patch.js
@@ -0,0 +1,3 @@
+const SemVer = require('../classes/semver')
+const patch = (a, loose) => new SemVer(a, loose).patch
+module.exports = patch
diff --git a/functions/prerelease.js b/functions/prerelease.js
new file mode 100644
index 00000000..06aa1324
--- /dev/null
+++ b/functions/prerelease.js
@@ -0,0 +1,6 @@
+const parse = require('./parse')
+const prerelease = (version, options) => {
+  const parsed = parse(version, options)
+  return (parsed && parsed.prerelease.length) ? parsed.prerelease : null
+}
+module.exports = prerelease
diff --git a/functions/rcompare.js b/functions/rcompare.js
new file mode 100644
index 00000000..0ac509e7
--- /dev/null
+++ b/functions/rcompare.js
@@ -0,0 +1,3 @@
+const compare = require('./compare')
+const rcompare = (a, b, loose) => compare(b, a, loose)
+module.exports = rcompare
diff --git a/functions/rsort.js b/functions/rsort.js
new file mode 100644
index 00000000..82404c5c
--- /dev/null
+++ b/functions/rsort.js
@@ -0,0 +1,3 @@
+const compareBuild = require('./compare-build')
+const rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose))
+module.exports = rsort
diff --git a/functions/satisfies.js b/functions/satisfies.js
new file mode 100644
index 00000000..50af1c19
--- /dev/null
+++ b/functions/satisfies.js
@@ -0,0 +1,10 @@
+const Range = require('../classes/range')
+const satisfies = (version, range, options) => {
+  try {
+    range = new Range(range, options)
+  } catch (er) {
+    return false
+  }
+  return range.test(version)
+}
+module.exports = satisfies
diff --git a/functions/sort.js b/functions/sort.js
new file mode 100644
index 00000000..4d10917a
--- /dev/null
+++ b/functions/sort.js
@@ -0,0 +1,3 @@
+const compareBuild = require('./compare-build')
+const sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose))
+module.exports = sort
diff --git a/functions/valid.js b/functions/valid.js
new file mode 100644
index 00000000..f27bae10
--- /dev/null
+++ b/functions/valid.js
@@ -0,0 +1,6 @@
+const parse = require('./parse')
+const valid = (version, options) => {
+  const v = parse(version, options)
+  return v ? v.version : null
+}
+module.exports = valid
diff --git a/index.js b/index.js
new file mode 100644
index 00000000..86d42ac1
--- /dev/null
+++ b/index.js
@@ -0,0 +1,89 @@
+// just pre-load all the stuff that index.js lazily exports
+const internalRe = require('./internal/re')
+const constants = require('./internal/constants')
+const SemVer = require('./classes/semver')
+const identifiers = require('./internal/identifiers')
+const parse = require('./functions/parse')
+const valid = require('./functions/valid')
+const clean = require('./functions/clean')
+const inc = require('./functions/inc')
+const diff = require('./functions/diff')
+const major = require('./functions/major')
+const minor = require('./functions/minor')
+const patch = require('./functions/patch')
+const prerelease = require('./functions/prerelease')
+const compare = require('./functions/compare')
+const rcompare = require('./functions/rcompare')
+const compareLoose = require('./functions/compare-loose')
+const compareBuild = require('./functions/compare-build')
+const sort = require('./functions/sort')
+const rsort = require('./functions/rsort')
+const gt = require('./functions/gt')
+const lt = require('./functions/lt')
+const eq = require('./functions/eq')
+const neq = require('./functions/neq')
+const gte = require('./functions/gte')
+const lte = require('./functions/lte')
+const cmp = require('./functions/cmp')
+const coerce = require('./functions/coerce')
+const Comparator = require('./classes/comparator')
+const Range = require('./classes/range')
+const satisfies = require('./functions/satisfies')
+const toComparators = require('./ranges/to-comparators')
+const maxSatisfying = require('./ranges/max-satisfying')
+const minSatisfying = require('./ranges/min-satisfying')
+const minVersion = require('./ranges/min-version')
+const validRange = require('./ranges/valid')
+const outside = require('./ranges/outside')
+const gtr = require('./ranges/gtr')
+const ltr = require('./ranges/ltr')
+const intersects = require('./ranges/intersects')
+const simplifyRange = require('./ranges/simplify')
+const subset = require('./ranges/subset')
+module.exports = {
+  parse,
+  valid,
+  clean,
+  inc,
+  diff,
+  major,
+  minor,
+  patch,
+  prerelease,
+  compare,
+  rcompare,
+  compareLoose,
+  compareBuild,
+  sort,
+  rsort,
+  gt,
+  lt,
+  eq,
+  neq,
+  gte,
+  lte,
+  cmp,
+  coerce,
+  Comparator,
+  Range,
+  satisfies,
+  toComparators,
+  maxSatisfying,
+  minSatisfying,
+  minVersion,
+  validRange,
+  outside,
+  gtr,
+  ltr,
+  intersects,
+  simplifyRange,
+  subset,
+  SemVer,
+  re: internalRe.re,
+  src: internalRe.src,
+  tokens: internalRe.t,
+  SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
+  RELEASE_TYPES: constants.RELEASE_TYPES,
+  compareIdentifiers: identifiers.compareIdentifiers,
+  rcompareIdentifiers: identifiers.rcompareIdentifiers,
+}
diff --git a/internal/constants.js b/internal/constants.js
new file mode 100644
index 00000000..94be1c57
--- /dev/null
+++ b/internal/constants.js
@@ -0,0 +1,35 @@
+// Note: this is the semver.org version of the spec that it implements
+// Not necessarily the package version of this code.
+const SEMVER_SPEC_VERSION = '2.0.0'
+
+const MAX_LENGTH = 256
+const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||
+/* istanbul ignore next */ 9007199254740991
+
+// Max safe segment length for coercion.
+const MAX_SAFE_COMPONENT_LENGTH = 16
+
+// Max safe length for a build identifier. The max length minus 6 characters for
+// the shortest version with a build 0.0.0+BUILD.
+const MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6
+
+const RELEASE_TYPES = [
+  'major',
+  'premajor',
+  'minor',
+  'preminor',
+  'patch',
+  'prepatch',
+  'prerelease',
+]
+
+module.exports = {
+  MAX_LENGTH,
+  MAX_SAFE_COMPONENT_LENGTH,
+  MAX_SAFE_BUILD_LENGTH,
+  MAX_SAFE_INTEGER,
+  RELEASE_TYPES,
+  SEMVER_SPEC_VERSION,
+  FLAG_INCLUDE_PRERELEASE: 0b001,
+  FLAG_LOOSE: 0b010,
+}
diff --git a/internal/debug.js b/internal/debug.js
new file mode 100644
index 00000000..1c00e136
--- /dev/null
+++ b/internal/debug.js
@@ -0,0 +1,9 @@
+const debug = (
+  typeof process === 'object' &&
+  process.env &&
+  process.env.NODE_DEBUG &&
+  /\bsemver\b/i.test(process.env.NODE_DEBUG)
+) ? (...args) => console.error('SEMVER', ...args)
+  : () => {}
+
+module.exports = debug
diff --git a/internal/identifiers.js b/internal/identifiers.js
new file mode 100644
index 00000000..e612d0a3
--- /dev/null
+++ b/internal/identifiers.js
@@ -0,0 +1,23 @@
+const numeric = /^[0-9]+$/
+const compareIdentifiers = (a, b) => {
+  const anum = numeric.test(a)
+  const bnum = numeric.test(b)
+
+  if (anum && bnum) {
+    a = +a
+    b = +b
+  }
+
+  return a === b ? 0
+    : (anum && !bnum) ? -1
+    : (bnum && !anum) ? 1
+    : a < b ? -1
+    : 1
+}
+
+const rcompareIdentifiers = (a, b) => compareIdentifiers(b, a)
+
+module.exports = {
+  compareIdentifiers,
+  rcompareIdentifiers,
+}
diff --git a/internal/parse-options.js b/internal/parse-options.js
new file mode 100644
index 00000000..10d64ce0
--- /dev/null
+++ b/internal/parse-options.js
@@ -0,0 +1,15 @@
+// parse out just the options we care about
+const looseOption = Object.freeze({ loose: true })
+const emptyOpts = Object.freeze({ })
+const parseOptions = options => {
+  if (!options) {
+    return emptyOpts
+  }
+
+  if (typeof options !== 'object') {
+    return looseOption
+  }
+
+  return options
+}
+module.exports = parseOptions
diff --git a/internal/re.js b/internal/re.js
new file mode 100644
index 00000000..fd8920e7
--- /dev/null
+++ b/internal/re.js
@@ -0,0 +1,217 @@
+const {
+  MAX_SAFE_COMPONENT_LENGTH,
+  MAX_SAFE_BUILD_LENGTH,
+  MAX_LENGTH,
+} = require('./constants')
+const debug = require('./debug')
+exports = module.exports = {}
+
+// The actual regexps go on exports.re
+const re = exports.re = []
+const safeRe = exports.safeRe = []
+const src = exports.src = []
+const t = exports.t = {}
+let R = 0
+
+const LETTERDASHNUMBER = '[a-zA-Z0-9-]'
+
+// Replace some greedy regex tokens to prevent regex dos issues. These regex are
+// used internally via the safeRe object since all inputs in this library get
+// normalized first to trim and collapse all extra whitespace. The original
+// regexes are exported for userland consumption and lower level usage. A
+// future breaking change could export the safer regex only with a note that
+// all input should have extra whitespace removed.
+const safeRegexReplacements = [
+  ['\\s', 1],
+  ['\\d', MAX_LENGTH],
+  [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH],
+]
+
+const makeSafeRegex = (value) => {
+  for (const [token, max] of safeRegexReplacements) {
+    value = value
+      .split(`${token}*`).join(`${token}{0,${max}}`)
+      .split(`${token}+`).join(`${token}{1,${max}}`)
+  }
+  return value
+}
+
+const createToken = (name, value, isGlobal) => {
+  const safe = makeSafeRegex(value)
+  const index = R++
+  debug(name, index, value)
+  t[name] = index
+  src[index] = value
+  re[index] = new RegExp(value, isGlobal ? 'g' : undefined)
+  safeRe[index] = new RegExp(safe, isGlobal ? 'g' : undefined)
+}
+
+// The following Regular Expressions can be used for tokenizing,
+// validating, and parsing SemVer version strings.
+
+// ## Numeric Identifier
+// A single `0`, or a non-zero digit followed by zero or more digits.
+
+createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*')
+createToken('NUMERICIDENTIFIERLOOSE', '\\d+')
+
+// ## Non-numeric Identifier
+// Zero or more digits, followed by a letter or hyphen, and then zero or
+// more letters, digits, or hyphens.
+
+createToken('NONNUMERICIDENTIFIER', `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`)
+
+// ## Main Version
+// Three dot-separated numeric identifiers.
+
+createToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\.` +
+                   `(${src[t.NUMERICIDENTIFIER]})\\.` +
+                   `(${src[t.NUMERICIDENTIFIER]})`)
+
+createToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
+                        `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
+                        `(${src[t.NUMERICIDENTIFIERLOOSE]})`)
+
+// ## Pre-release Version Identifier
+// A numeric identifier, or a non-numeric identifier.
+
+createToken('PRERELEASEIDENTIFIER', `(?:${src[t.NUMERICIDENTIFIER]
+}|${src[t.NONNUMERICIDENTIFIER]})`)
+
+createToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NUMERICIDENTIFIERLOOSE]
+}|${src[t.NONNUMERICIDENTIFIER]})`)
+
+// ## Pre-release Version
+// Hyphen, followed by one or more dot-separated pre-release version
+// identifiers.
+
+createToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER]
+}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`)
+
+createToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]
+}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`)
+
+// ## Build Metadata Identifier
+// Any combination of digits, letters, or hyphens.
+
+createToken('BUILDIDENTIFIER', `${LETTERDASHNUMBER}+`)
+
+// ## Build Metadata
+// Plus sign, followed by one or more period-separated build metadata
+// identifiers.
+
+createToken('BUILD', `(?:\\+(${src[t.BUILDIDENTIFIER]
+}(?:\\.${src[t.BUILDIDENTIFIER]})*))`)
+
+// ## Full Version String
+// A main version, followed optionally by a pre-release version and
+// build metadata.
+
+// Note that the only major, minor, patch, and pre-release sections of
+// the version string are capturing groups.  The build metadata is not a
+// capturing group, because it should not ever be used in version
+// comparison.
+
+createToken('FULLPLAIN', `v?${src[t.MAINVERSION]
+}${src[t.PRERELEASE]}?${
+  src[t.BUILD]}?`)
+
+createToken('FULL', `^${src[t.FULLPLAIN]}$`)
+
+// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
+// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
+// common in the npm registry.
+createToken('LOOSEPLAIN', `[v=\\s]*${src[t.MAINVERSIONLOOSE]
+}${src[t.PRERELEASELOOSE]}?${
+  src[t.BUILD]}?`)
+
+createToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`)
+
+createToken('GTLT', '((?:<|>)?=?)')
+
+// Something like "2.*" or "1.2.x".
+// Note that "x.x" is a valid xRange identifer, meaning "any version"
+// Only the first item is strictly required.
+createToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`)
+createToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`)
+
+createToken('XRANGEPLAIN', `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})` +
+                   `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
+                   `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
+                   `(?:${src[t.PRERELEASE]})?${
+                     src[t.BUILD]}?` +
+                   `)?)?`)
+
+createToken('XRANGEPLAINLOOSE', `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` +
+                        `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
+                        `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
+                        `(?:${src[t.PRERELEASELOOSE]})?${
+                          src[t.BUILD]}?` +
+                        `)?)?`)
+
+createToken('XRANGE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`)
+createToken('XRANGELOOSE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`)
+
+// Coercion.
+// Extract anything that could conceivably be a part of a valid semver
+createToken('COERCEPLAIN', `${'(^|[^\\d])' +
+              '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` +
+              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
+              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`)
+createToken('COERCE', `${src[t.COERCEPLAIN]}(?:$|[^\\d])`)
+createToken('COERCEFULL', src[t.COERCEPLAIN] +
+              `(?:${src[t.PRERELEASE]})?` +
+              `(?:${src[t.BUILD]})?` +
+              `(?:$|[^\\d])`)
+createToken('COERCERTL', src[t.COERCE], true)
+createToken('COERCERTLFULL', src[t.COERCEFULL], true)
+
+// Tilde ranges.
+// Meaning is "reasonably at or greater than"
+createToken('LONETILDE', '(?:~>?)')
+
+createToken('TILDETRIM', `(\\s*)${src[t.LONETILDE]}\\s+`, true)
+exports.tildeTrimReplace = '$1~'
+
+createToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`)
+createToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`)
+
+// Caret ranges.
+// Meaning is "at least and backwards compatible with"
+createToken('LONECARET', '(?:\\^)')
+
+createToken('CARETTRIM', `(\\s*)${src[t.LONECARET]}\\s+`, true)
+exports.caretTrimReplace = '$1^'
+
+createToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`)
+createToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`)
+
+// A simple gt/lt/eq thing, or just "" to indicate "any version"
+createToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`)
+createToken('COMPARATOR', `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`)
+
+// An expression to strip any whitespace between the gtlt and the thing
+// it modifies, so that `> 1.2.3` ==> `>1.2.3`
+createToken('COMPARATORTRIM', `(\\s*)${src[t.GTLT]
+}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true)
+exports.comparatorTrimReplace = '$1$2$3'
+
+// Something like `1.2.3 - 1.2.4`
+// Note that these all use the loose form, because they'll be
+// checked against either the strict or loose comparator form
+// later.
+createToken('HYPHENRANGE', `^\\s*(${src[t.XRANGEPLAIN]})` +
+                   `\\s+-\\s+` +
+                   `(${src[t.XRANGEPLAIN]})` +
+                   `\\s*$`)
+
+createToken('HYPHENRANGELOOSE', `^\\s*(${src[t.XRANGEPLAINLOOSE]})` +
+                        `\\s+-\\s+` +
+                        `(${src[t.XRANGEPLAINLOOSE]})` +
+                        `\\s*$`)
+
+// Star ranges basically just allow anything at all.
+createToken('STAR', '(<|>)?=?\\s*\\*')
+// >=0.0.0 is like a star
+createToken('GTE0', '^\\s*>=\\s*0\\.0\\.0\\s*$')
+createToken('GTE0PRE', '^\\s*>=\\s*0\\.0\\.0-0\\s*$')
diff --git a/map.js b/map.js
new file mode 100644
index 00000000..293f6b01
--- /dev/null
+++ b/map.js
@@ -0,0 +1 @@
+module.exports = testFile => testFile.replace(/test\//, '')
diff --git a/package-lock.json b/package-lock.json
deleted file mode 100644
index 5574a86f..00000000
--- a/package-lock.json
+++ /dev/null
@@ -1,3318 +0,0 @@
-{
-  "name": "semver",
-  "version": "5.7.0",
-  "lockfileVersion": 1,
-  "requires": true,
-  "dependencies": {
-    "@babel/code-frame": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.0.0.tgz",
-      "integrity": "sha512-OfC2uemaknXr87bdLUkWog7nYuliM9Ij5HUcajsVcMCpQrcLmtxRbVFTIqmcSkSeYRBFBRxs2FiUqFJDLdiebA==",
-      "dev": true,
-      "requires": {
-        "@babel/highlight": "^7.0.0"
-      }
-    },
-    "@babel/generator": {
-      "version": "7.4.0",
-      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.4.0.tgz",
-      "integrity": "sha512-/v5I+a1jhGSKLgZDcmAUZ4K/VePi43eRkUs3yePW1HB1iANOD5tqJXwGSG4BZhSksP8J9ejSlwGeTiiOFZOrXQ==",
-      "dev": true,
-      "requires": {
-        "@babel/types": "^7.4.0",
-        "jsesc": "^2.5.1",
-        "lodash": "^4.17.11",
-        "source-map": "^0.5.0",
-        "trim-right": "^1.0.1"
-      },
-      "dependencies": {
-        "jsesc": {
-          "version": "2.5.2",
-          "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-2.5.2.tgz",
-          "integrity": "sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==",
-          "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/helper-function-name": {
-      "version": "7.1.0",
-      "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.1.0.tgz",
-      "integrity": "sha512-A95XEoCpb3TO+KZzJ4S/5uW5fNe26DjBGqf1o9ucyLyCmi1dXq/B3c8iaWTfBk3VvetUxl16e8tIrd5teOCfGw==",
-      "dev": true,
-      "requires": {
-        "@babel/helper-get-function-arity": "^7.0.0",
-        "@babel/template": "^7.1.0",
-        "@babel/types": "^7.0.0"
-      }
-    },
-    "@babel/helper-get-function-arity": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/@babel/helper-get-function-arity/-/helper-get-function-arity-7.0.0.tgz",
-      "integrity": "sha512-r2DbJeg4svYvt3HOS74U4eWKsUAMRH01Z1ds1zx8KNTPtpTL5JAsdFv8BNyOpVqdFhHkkRDIg5B4AsxmkjAlmQ==",
-      "dev": true,
-      "requires": {
-        "@babel/types": "^7.0.0"
-      }
-    },
-    "@babel/helper-split-export-declaration": {
-      "version": "7.4.0",
-      "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.4.0.tgz",
-      "integrity": "sha512-7Cuc6JZiYShaZnybDmfwhY4UYHzI6rlqhWjaIqbsJGsIqPimEYy5uh3akSRLMg65LSdSEnJ8a8/bWQN6u2oMGw==",
-      "dev": true,
-      "requires": {
-        "@babel/types": "^7.4.0"
-      }
-    },
-    "@babel/highlight": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.0.0.tgz",
-      "integrity": "sha512-UFMC4ZeFC48Tpvj7C8UgLvtkaUuovQX+5xNWrsIoMG8o2z+XFKjKaN9iVmS84dPwVN00W4wPmqvYoZF3EGAsfw==",
-      "dev": true,
-      "requires": {
-        "chalk": "^2.0.0",
-        "esutils": "^2.0.2",
-        "js-tokens": "^4.0.0"
-      },
-      "dependencies": {
-        "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
-        }
-      }
-    },
-    "@babel/parser": {
-      "version": "7.4.2",
-      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.4.2.tgz",
-      "integrity": "sha512-9fJTDipQFvlfSVdD/JBtkiY0br9BtfvW2R8wo6CX/Ej2eMuV0gWPk1M67Mt3eggQvBqYW1FCEk8BN7WvGm/g5g==",
-      "dev": true
-    },
-    "@babel/runtime": {
-      "version": "7.4.2",
-      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.4.2.tgz",
-      "integrity": "sha512-7Bl2rALb7HpvXFL7TETNzKSAeBVCPHELzc0C//9FCxN8nsiueWSJBqaF+2oIJScyILStASR/Cx5WMkXGYTiJFA==",
-      "dev": true,
-      "requires": {
-        "regenerator-runtime": "^0.13.2"
-      },
-      "dependencies": {
-        "regenerator-runtime": {
-          "version": "0.13.2",
-          "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.13.2.tgz",
-          "integrity": "sha512-S/TQAZJO+D3m9xeN1WTI8dLKBBiRgXBlTJvbWjCThHWZj9EvHK70Ff50/tYj2J/fvBY6JtFVwRuazHN2E7M9BA==",
-          "dev": true
-        }
-      }
-    },
-    "@babel/template": {
-      "version": "7.4.0",
-      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.4.0.tgz",
-      "integrity": "sha512-SOWwxxClTTh5NdbbYZ0BmaBVzxzTh2tO/TeLTbF6MO6EzVhHTnff8CdBXx3mEtazFBoysmEM6GU/wF+SuSx4Fw==",
-      "dev": true,
-      "requires": {
-        "@babel/code-frame": "^7.0.0",
-        "@babel/parser": "^7.4.0",
-        "@babel/types": "^7.4.0"
-      }
-    },
-    "@babel/traverse": {
-      "version": "7.4.0",
-      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.4.0.tgz",
-      "integrity": "sha512-/DtIHKfyg2bBKnIN+BItaIlEg5pjAnzHOIQe5w+rHAw/rg9g0V7T4rqPX8BJPfW11kt3koyjAnTNwCzb28Y1PA==",
-      "dev": true,
-      "requires": {
-        "@babel/code-frame": "^7.0.0",
-        "@babel/generator": "^7.4.0",
-        "@babel/helper-function-name": "^7.1.0",
-        "@babel/helper-split-export-declaration": "^7.4.0",
-        "@babel/parser": "^7.4.0",
-        "@babel/types": "^7.4.0",
-        "debug": "^4.1.0",
-        "globals": "^11.1.0",
-        "lodash": "^4.17.11"
-      },
-      "dependencies": {
-        "debug": {
-          "version": "4.1.1",
-          "resolved": "https://registry.npmjs.org/debug/-/debug-4.1.1.tgz",
-          "integrity": "sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw==",
-          "dev": true,
-          "requires": {
-            "ms": "^2.1.1"
-          }
-        },
-        "ms": {
-          "version": "2.1.1",
-          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.1.tgz",
-          "integrity": "sha512-tgp+dl5cGk28utYktBsrFqA7HKgrhgPsg6Z/EfhWI4gl1Hwq8B/GmY/0oXZ6nF8hDVesS/FpnYaD/kOWhYQvyg==",
-          "dev": true
-        }
-      }
-    },
-    "@babel/types": {
-      "version": "7.4.0",
-      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.4.0.tgz",
-      "integrity": "sha512-aPvkXyU2SPOnztlgo8n9cEiXW755mgyvueUPcpStqdzoSPm0fjO0vQBjLkt3JKJW7ufikfcnMTTPsN1xaTsBPA==",
-      "dev": true,
-      "requires": {
-        "esutils": "^2.0.2",
-        "lodash": "^4.17.11",
-        "to-fast-properties": "^2.0.0"
-      },
-      "dependencies": {
-        "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
-        }
-      }
-    },
-    "@types/prop-types": {
-      "version": "15.7.0",
-      "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.0.tgz",
-      "integrity": "sha512-eItQyV43bj4rR3JPV0Skpl1SncRCdziTEK9/v8VwXmV6d/qOUO8/EuWeHBbCZcsfSHfzI5UyMJLCSXtxxznyZg==",
-      "dev": true
-    },
-    "@types/react": {
-      "version": "16.8.8",
-      "resolved": "https://registry.npmjs.org/@types/react/-/react-16.8.8.tgz",
-      "integrity": "sha512-xwEvyet96u7WnB96kqY0yY7qxx/pEpU51QeACkKFtrgjjXITQn0oO1iwPEraXVgh10ZFPix7gs1R4OJXF7P5sg==",
-      "dev": true,
-      "requires": {
-        "@types/prop-types": "*",
-        "csstype": "^2.2.0"
-      }
-    },
-    "ajv": {
-      "version": "6.10.0",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.10.0.tgz",
-      "integrity": "sha512-nffhOpkymDECQyR0mnsUtoCE8RlX38G0rYP+wgLWFyZuUyuuojSSvi/+euOiQBIn63whYwYVIIH1TvE3tu4OEg==",
-      "dev": true,
-      "requires": {
-        "fast-deep-equal": "^2.0.1",
-        "fast-json-stable-stringify": "^2.0.0",
-        "json-schema-traverse": "^0.4.1",
-        "uri-js": "^4.2.2"
-      }
-    },
-    "ansi-regex": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz",
-      "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=",
-      "dev": true
-    },
-    "ansi-styles": {
-      "version": "2.2.1",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-2.2.1.tgz",
-      "integrity": "sha1-tDLdM1i2NM914eRmQ2gkBTPB3b4=",
-      "dev": true
-    },
-    "ansicolors": {
-      "version": "0.3.2",
-      "resolved": "https://registry.npmjs.org/ansicolors/-/ansicolors-0.3.2.tgz",
-      "integrity": "sha1-ZlWX3oap/+Oqm/vmyuXG6kJrSXk=",
-      "dev": true
-    },
-    "arg": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/arg/-/arg-4.1.0.tgz",
-      "integrity": "sha512-ZWc51jO3qegGkVh8Hwpv636EkbesNV5ZNQPCtRa+0qytRYPEs9IYT9qITY9buezqUH5uqyzlWLcufrzU2rffdg==",
-      "dev": true
-    },
-    "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"
-      }
-    },
-    "arrify": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/arrify/-/arrify-1.0.1.tgz",
-      "integrity": "sha1-iYUI2iIm84DfkEcoRWhJwVAaSw0=",
-      "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
-    },
-    "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
-    },
-    "async-hook-domain": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/async-hook-domain/-/async-hook-domain-1.1.0.tgz",
-      "integrity": "sha512-NH7V97d1yCbIanu2oDLyPT2GFNct0esPeJyRfkk8J5hTztHVSQp4UiNfL2O42sCA9XZPU8OgHvzOmt9ewBhVqA==",
-      "dev": true,
-      "requires": {
-        "source-map-support": "^0.5.11"
-      }
-    },
-    "asynckit": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
-      "integrity": "sha1-x57Zf380y48robyXkLzDZkdLS3k=",
-      "dev": true
-    },
-    "auto-bind": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/auto-bind/-/auto-bind-2.0.0.tgz",
-      "integrity": "sha512-rvRBv0/O7iriUMqSzTDhAfyAD1vVnElAEruo5rMSFeYLA0iKDEzLPSJiwMnL86+IPpTlhfOIAzjoKZ9TaySYdA==",
-      "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.8.0",
-      "resolved": "https://registry.npmjs.org/aws4/-/aws4-1.8.0.tgz",
-      "integrity": "sha512-ReZxvNHIOv88FlT7rxcXIIC0fPt4KZqZbOlivyWtXLt8ESx84zd3kMC6iK5jVeS2qt+g7ftS7ye4fi06X5rtRQ==",
-      "dev": true
-    },
-    "babel-code-frame": {
-      "version": "6.26.0",
-      "resolved": "https://registry.npmjs.org/babel-code-frame/-/babel-code-frame-6.26.0.tgz",
-      "integrity": "sha1-Y/1D99weO7fONZR9uP42mj9Yx0s=",
-      "dev": true,
-      "requires": {
-        "chalk": "^1.1.3",
-        "esutils": "^2.0.2",
-        "js-tokens": "^3.0.2"
-      },
-      "dependencies": {
-        "chalk": {
-          "version": "1.1.3",
-          "resolved": "http://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz",
-          "integrity": "sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=",
-          "dev": true,
-          "requires": {
-            "ansi-styles": "^2.2.1",
-            "escape-string-regexp": "^1.0.2",
-            "has-ansi": "^2.0.0",
-            "strip-ansi": "^3.0.0",
-            "supports-color": "^2.0.0"
-          }
-        }
-      }
-    },
-    "babel-core": {
-      "version": "6.26.3",
-      "resolved": "https://registry.npmjs.org/babel-core/-/babel-core-6.26.3.tgz",
-      "integrity": "sha512-6jyFLuDmeidKmUEb3NM+/yawG0M2bDZ9Z1qbZP59cyHLz8kYGKYwpJP0UwUKKUiTRNvxfLesJnTedqczP7cTDA==",
-      "dev": true,
-      "requires": {
-        "babel-code-frame": "^6.26.0",
-        "babel-generator": "^6.26.0",
-        "babel-helpers": "^6.24.1",
-        "babel-messages": "^6.23.0",
-        "babel-register": "^6.26.0",
-        "babel-runtime": "^6.26.0",
-        "babel-template": "^6.26.0",
-        "babel-traverse": "^6.26.0",
-        "babel-types": "^6.26.0",
-        "babylon": "^6.18.0",
-        "convert-source-map": "^1.5.1",
-        "debug": "^2.6.9",
-        "json5": "^0.5.1",
-        "lodash": "^4.17.4",
-        "minimatch": "^3.0.4",
-        "path-is-absolute": "^1.0.1",
-        "private": "^0.1.8",
-        "slash": "^1.0.0",
-        "source-map": "^0.5.7"
-      },
-      "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-generator": {
-      "version": "6.26.1",
-      "resolved": "https://registry.npmjs.org/babel-generator/-/babel-generator-6.26.1.tgz",
-      "integrity": "sha512-HyfwY6ApZj7BYTcJURpM5tznulaBvyio7/0d4zFOeMPUmfxkCjHocCuoLa2SAGzBI8AREcH3eP3758F672DppA==",
-      "dev": true,
-      "requires": {
-        "babel-messages": "^6.23.0",
-        "babel-runtime": "^6.26.0",
-        "babel-types": "^6.26.0",
-        "detect-indent": "^4.0.0",
-        "jsesc": "^1.3.0",
-        "lodash": "^4.17.4",
-        "source-map": "^0.5.7",
-        "trim-right": "^1.0.1"
-      },
-      "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-builder-react-jsx": {
-      "version": "6.26.0",
-      "resolved": "https://registry.npmjs.org/babel-helper-builder-react-jsx/-/babel-helper-builder-react-jsx-6.26.0.tgz",
-      "integrity": "sha1-Of+DE7dci2Xc7/HzHTg+D/KkCKA=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.26.0",
-        "babel-types": "^6.26.0",
-        "esutils": "^2.0.2"
-      }
-    },
-    "babel-helpers": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-helpers/-/babel-helpers-6.24.1.tgz",
-      "integrity": "sha1-NHHenK7DiOXIUOWX5Yom3fN2ArI=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.22.0",
-        "babel-template": "^6.24.1"
-      }
-    },
-    "babel-messages": {
-      "version": "6.23.0",
-      "resolved": "https://registry.npmjs.org/babel-messages/-/babel-messages-6.23.0.tgz",
-      "integrity": "sha1-8830cDhYA1sqKVHG7F7fbGLyYw4=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.22.0"
-      }
-    },
-    "babel-plugin-syntax-jsx": {
-      "version": "6.18.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-syntax-jsx/-/babel-plugin-syntax-jsx-6.18.0.tgz",
-      "integrity": "sha1-CvMqmm4Tyno/1QaeYtew9Y0NiUY=",
-      "dev": true
-    },
-    "babel-plugin-syntax-object-rest-spread": {
-      "version": "6.13.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-syntax-object-rest-spread/-/babel-plugin-syntax-object-rest-spread-6.13.0.tgz",
-      "integrity": "sha1-/WU28rzhODb/o6VFjEkDpZe7O/U=",
-      "dev": true
-    },
-    "babel-plugin-transform-es2015-destructuring": {
-      "version": "6.23.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-destructuring/-/babel-plugin-transform-es2015-destructuring-6.23.0.tgz",
-      "integrity": "sha1-mXux8auWf2gtKwh2/jWNYOdlxW0=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.22.0"
-      }
-    },
-    "babel-plugin-transform-object-rest-spread": {
-      "version": "6.26.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-object-rest-spread/-/babel-plugin-transform-object-rest-spread-6.26.0.tgz",
-      "integrity": "sha1-DzZpLVD+9rfi1LOsFHgTepY7ewY=",
-      "dev": true,
-      "requires": {
-        "babel-plugin-syntax-object-rest-spread": "^6.8.0",
-        "babel-runtime": "^6.26.0"
-      }
-    },
-    "babel-plugin-transform-react-jsx": {
-      "version": "6.24.1",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-react-jsx/-/babel-plugin-transform-react-jsx-6.24.1.tgz",
-      "integrity": "sha1-hAoCjn30YN/DotKfDA2R9jduZqM=",
-      "dev": true,
-      "requires": {
-        "babel-helper-builder-react-jsx": "^6.24.1",
-        "babel-plugin-syntax-jsx": "^6.8.0",
-        "babel-runtime": "^6.22.0"
-      }
-    },
-    "babel-register": {
-      "version": "6.26.0",
-      "resolved": "https://registry.npmjs.org/babel-register/-/babel-register-6.26.0.tgz",
-      "integrity": "sha1-btAhFz4vy0htestFxgCahW9kcHE=",
-      "dev": true,
-      "requires": {
-        "babel-core": "^6.26.0",
-        "babel-runtime": "^6.26.0",
-        "core-js": "^2.5.0",
-        "home-or-tmp": "^2.0.0",
-        "lodash": "^4.17.4",
-        "mkdirp": "^0.5.1",
-        "source-map-support": "^0.4.15"
-      },
-      "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
-        },
-        "source-map-support": {
-          "version": "0.4.18",
-          "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.4.18.tgz",
-          "integrity": "sha512-try0/JqxPLF9nOjvSta7tVondkP5dwgyLDjVoyMDlmjugT2lRZ1OfsrYTkCd2hkDnJTKRbO/Rl3orm8vlsUzbA==",
-          "dev": true,
-          "requires": {
-            "source-map": "^0.5.6"
-          }
-        }
-      }
-    },
-    "babel-runtime": {
-      "version": "6.26.0",
-      "resolved": "https://registry.npmjs.org/babel-runtime/-/babel-runtime-6.26.0.tgz",
-      "integrity": "sha1-llxwWGaOgrVde/4E/yM3vItWR/4=",
-      "dev": true,
-      "requires": {
-        "core-js": "^2.4.0",
-        "regenerator-runtime": "^0.11.0"
-      }
-    },
-    "babel-template": {
-      "version": "6.26.0",
-      "resolved": "https://registry.npmjs.org/babel-template/-/babel-template-6.26.0.tgz",
-      "integrity": "sha1-3gPi0WOWsGn0bdn/+FIfsaDjXgI=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.26.0",
-        "babel-traverse": "^6.26.0",
-        "babel-types": "^6.26.0",
-        "babylon": "^6.18.0",
-        "lodash": "^4.17.4"
-      }
-    },
-    "babel-traverse": {
-      "version": "6.26.0",
-      "resolved": "https://registry.npmjs.org/babel-traverse/-/babel-traverse-6.26.0.tgz",
-      "integrity": "sha1-RqnL1+3MYsjlwGTi0tjQ9ANXZu4=",
-      "dev": true,
-      "requires": {
-        "babel-code-frame": "^6.26.0",
-        "babel-messages": "^6.23.0",
-        "babel-runtime": "^6.26.0",
-        "babel-types": "^6.26.0",
-        "babylon": "^6.18.0",
-        "debug": "^2.6.8",
-        "globals": "^9.18.0",
-        "invariant": "^2.2.2",
-        "lodash": "^4.17.4"
-      },
-      "dependencies": {
-        "globals": {
-          "version": "9.18.0",
-          "resolved": "https://registry.npmjs.org/globals/-/globals-9.18.0.tgz",
-          "integrity": "sha512-S0nG3CLEQiY/ILxqtztTWH/3iRRdyBLw6KMDxnKMchrtbj2OFmehVh0WUCfW3DUrIgx/qFrJPICrq4Z4sTR9UQ==",
-          "dev": true
-        }
-      }
-    },
-    "babel-types": {
-      "version": "6.26.0",
-      "resolved": "https://registry.npmjs.org/babel-types/-/babel-types-6.26.0.tgz",
-      "integrity": "sha1-o7Bz+Uq0nrb6Vc1lInozQ4BjJJc=",
-      "dev": true,
-      "requires": {
-        "babel-runtime": "^6.26.0",
-        "esutils": "^2.0.2",
-        "lodash": "^4.17.4",
-        "to-fast-properties": "^1.0.3"
-      }
-    },
-    "babylon": {
-      "version": "6.18.0",
-      "resolved": "https://registry.npmjs.org/babylon/-/babylon-6.18.0.tgz",
-      "integrity": "sha512-q/UEjfGJ2Cm3oKV71DJz9d25TPnq5rhBVL2Q4fA5wcC3jcrdn7+SssEybFIxwAvvP+YCsCYNKughoF33GxgycQ==",
-      "dev": true
-    },
-    "balanced-match": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz",
-      "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=",
-      "dev": true
-    },
-    "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"
-      }
-    },
-    "bind-obj-methods": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/bind-obj-methods/-/bind-obj-methods-2.0.0.tgz",
-      "integrity": "sha512-3/qRXczDi2Cdbz6jE+W3IflJOutRVica8frpBn14de1mBOkzDo+6tY33kNhvkw54Kn3PzRRD2VnGbGPcTAk4sw==",
-      "dev": true
-    },
-    "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"
-      }
-    },
-    "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
-    },
-    "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
-    },
-    "caller-callsite": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/caller-callsite/-/caller-callsite-2.0.0.tgz",
-      "integrity": "sha1-hH4PzgoiN1CpoCfFSzNzGtMVQTQ=",
-      "dev": true,
-      "requires": {
-        "callsites": "^2.0.0"
-      },
-      "dependencies": {
-        "callsites": {
-          "version": "2.0.0",
-          "resolved": "https://registry.npmjs.org/callsites/-/callsites-2.0.0.tgz",
-          "integrity": "sha1-BuuE8A7qQT2oav/vrL/7Ngk7PFA=",
-          "dev": true
-        }
-      }
-    },
-    "capture-stack-trace": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/capture-stack-trace/-/capture-stack-trace-1.0.1.tgz",
-      "integrity": "sha512-mYQLZnx5Qt1JgB1WEiMCf2647plpGeQ2NMR/5L0HNZzGQo4fuSPnK+wjfPnKZV0aiJDgzmWqqkV/g7JD+DW0qw==",
-      "dev": true
-    },
-    "cardinal": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/cardinal/-/cardinal-2.1.1.tgz",
-      "integrity": "sha1-fMEFXYItISlU0HsIXeolHMe8VQU=",
-      "dev": true,
-      "requires": {
-        "ansicolors": "~0.3.2",
-        "redeyed": "~2.1.0"
-      }
-    },
-    "caseless": {
-      "version": "0.12.0",
-      "resolved": "https://registry.npmjs.org/caseless/-/caseless-0.12.0.tgz",
-      "integrity": "sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw=",
-      "dev": true
-    },
-    "chalk": {
-      "version": "2.4.1",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.1.tgz",
-      "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==",
-      "dev": true,
-      "requires": {
-        "ansi-styles": "^3.2.1",
-        "escape-string-regexp": "^1.0.5",
-        "supports-color": "^5.3.0"
-      },
-      "dependencies": {
-        "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"
-          }
-        },
-        "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"
-          }
-        }
-      }
-    },
-    "cli-cursor": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-2.1.0.tgz",
-      "integrity": "sha1-s12sN2R5+sw+lHR9QdDQ9SOP/LU=",
-      "dev": true,
-      "requires": {
-        "restore-cursor": "^2.0.0"
-      }
-    },
-    "cliui": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/cliui/-/cliui-4.1.0.tgz",
-      "integrity": "sha512-4FG+RSG9DL7uEwRUZXZn3SS34DiDPfzP0VOiEwtUWlE+AR2EIg+hSyvrIgUUfhdgR/UkAeW2QHgeP+hWrXs7jQ==",
-      "dev": true,
-      "requires": {
-        "string-width": "^2.1.1",
-        "strip-ansi": "^4.0.0",
-        "wrap-ansi": "^2.0.0"
-      },
-      "dependencies": {
-        "ansi-regex": {
-          "version": "3.0.0",
-          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz",
-          "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=",
-          "dev": true
-        },
-        "strip-ansi": {
-          "version": "4.0.0",
-          "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz",
-          "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=",
-          "dev": true,
-          "requires": {
-            "ansi-regex": "^3.0.0"
-          }
-        }
-      }
-    },
-    "code-point-at": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/code-point-at/-/code-point-at-1.1.0.tgz",
-      "integrity": "sha1-DQcLTQQ6W+ozovGkDi7bPZpMz3c=",
-      "dev": true
-    },
-    "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
-    },
-    "color-support": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/color-support/-/color-support-1.1.3.tgz",
-      "integrity": "sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==",
-      "dev": true
-    },
-    "combined-stream": {
-      "version": "1.0.7",
-      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.7.tgz",
-      "integrity": "sha512-brWl9y6vOB1xYPZcpZde3N9zDByXTosAeMDo4p1wzo6UMOX4vumB+TP1RZ76sfE6Md68Q0NJSrE/gbezd4Ul+w==",
-      "dev": true,
-      "requires": {
-        "delayed-stream": "~1.0.0"
-      }
-    },
-    "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.6.0",
-      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.6.0.tgz",
-      "integrity": "sha512-eFu7XigvxdZ1ETfbgPBohgyQ/Z++C0eEhTor0qRwBw9unw+L0/6V8wkSuGgzdThkiS5lSpdptOQPD8Ak40a+7A==",
-      "dev": true,
-      "requires": {
-        "safe-buffer": "~5.1.1"
-      }
-    },
-    "core-js": {
-      "version": "2.6.5",
-      "resolved": "https://registry.npmjs.org/core-js/-/core-js-2.6.5.tgz",
-      "integrity": "sha512-klh/kDpwX8hryYL14M9w/xei6vrv6sE8gTHDG7/T/+SEovB/G4ejwcfE/CBzO6Edsu+OETZMZ3wcX/EjUkrl5A==",
-      "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
-    },
-    "coveralls": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/coveralls/-/coveralls-3.0.3.tgz",
-      "integrity": "sha512-viNfeGlda2zJr8Gj1zqXpDMRjw9uM54p7wzZdvLRyOgnAfCe974Dq4veZkjJdxQXbmdppu6flEajFYseHYaUhg==",
-      "dev": true,
-      "requires": {
-        "growl": "~> 1.10.0",
-        "js-yaml": "^3.11.0",
-        "lcov-parse": "^0.0.10",
-        "log-driver": "^1.2.7",
-        "minimist": "^1.2.0",
-        "request": "^2.86.0"
-      }
-    },
-    "cross-spawn": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-4.0.2.tgz",
-      "integrity": "sha1-e5JHYhwjrf3ThWAEqCPL45dCTUE=",
-      "dev": true,
-      "requires": {
-        "lru-cache": "^4.0.1",
-        "which": "^1.2.9"
-      }
-    },
-    "csstype": {
-      "version": "2.6.3",
-      "resolved": "https://registry.npmjs.org/csstype/-/csstype-2.6.3.tgz",
-      "integrity": "sha512-rINUZXOkcBmoHWEyu7JdHu5JMzkGRoMX4ov9830WNgxf5UYxcBUO0QTKAqeJ5EZfSdlrcJYkC8WwfVW7JYi4yg==",
-      "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"
-      }
-    },
-    "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"
-      }
-    },
-    "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-indent": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/detect-indent/-/detect-indent-4.0.0.tgz",
-      "integrity": "sha1-920GQ1LN9Docts5hnE7jqUdd4gg=",
-      "dev": true,
-      "requires": {
-        "repeating": "^2.0.0"
-      }
-    },
-    "diff": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/diff/-/diff-1.4.0.tgz",
-      "integrity": "sha1-fyjS657nsVqX79ic5j3P2qPMur8=",
-      "dev": true
-    },
-    "domain-browser": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/domain-browser/-/domain-browser-1.2.0.tgz",
-      "integrity": "sha512-jnjyiM6eRyZl2H+W8Q/zLMA481hzi0eszAaBUzIVnmYVDBbnLxVNnfu1HgEBvCbL+71FrxMl3E6lpKH7Ge3OXA==",
-      "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"
-      }
-    },
-    "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
-    },
-    "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
-    },
-    "esm": {
-      "version": "3.2.20",
-      "resolved": "https://registry.npmjs.org/esm/-/esm-3.2.20.tgz",
-      "integrity": "sha512-NA92qDA8C/qGX/xMinDGa3+cSPs4wQoFxskRrSnDo/9UloifhONFm4sl4G+JsyCqM007z2K+BfQlH5rMta4K1Q==",
-      "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
-    },
-    "esutils": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.2.tgz",
-      "integrity": "sha1-Cr9PHKpbyx96nYrMbepPqqBLrJs=",
-      "dev": true
-    },
-    "events-to-array": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/events-to-array/-/events-to-array-1.1.2.tgz",
-      "integrity": "sha1-LUH1Y+H+QA7Uli/hpNXGp1Od9/Y=",
-      "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
-    },
-    "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": "2.0.1",
-      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-2.0.1.tgz",
-      "integrity": "sha1-ewUhjd+WZ79/Nwv3/bLLFf3Qqkk=",
-      "dev": true
-    },
-    "fast-json-stable-stringify": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.0.0.tgz",
-      "integrity": "sha1-1RQsDK7msRifh9OnYREGT4bIu/I=",
-      "dev": true
-    },
-    "findit": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/findit/-/findit-2.0.0.tgz",
-      "integrity": "sha1-ZQnwEmr0wXhVHPqZOU4DLhOk1W4=",
-      "dev": true
-    },
-    "foreground-child": {
-      "version": "1.5.6",
-      "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-1.5.6.tgz",
-      "integrity": "sha1-T9ca0t/elnibmApcCilZN8svXOk=",
-      "dev": true,
-      "requires": {
-        "cross-spawn": "^4",
-        "signal-exit": "^3.0.0"
-      }
-    },
-    "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"
-      }
-    },
-    "fs-exists-cached": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/fs-exists-cached/-/fs-exists-cached-1.0.0.tgz",
-      "integrity": "sha1-zyVVTKBQ3EmuZla0HeQiWJidy84=",
-      "dev": true
-    },
-    "fs.realpath": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
-      "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=",
-      "dev": true
-    },
-    "function-loop": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/function-loop/-/function-loop-1.0.1.tgz",
-      "integrity": "sha1-gHa7MF6OajzO7ikgdl8zDRkPNAw=",
-      "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.2",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.2.tgz",
-      "integrity": "sha512-MJTUg1kjuLeQCJ+ccE4Vpa6kKVXkPYJ2mOCQyUuKLcLQsdrMCpBPUi8qVE6+YuaJkozeA9NusTAw3hLr8Xe5EQ==",
-      "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"
-      }
-    },
-    "globals": {
-      "version": "11.8.0",
-      "resolved": "https://registry.npmjs.org/globals/-/globals-11.8.0.tgz",
-      "integrity": "sha512-io6LkyPVuzCHBSQV9fmOwxZkUk6nIaGmxheLDgmuFv89j0fm2aqDbIXKAGfzCMHqz3HLF2Zf8WSG6VqMh2qFmA==",
-      "dev": true
-    },
-    "graceful-fs": {
-      "version": "4.1.11",
-      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.1.11.tgz",
-      "integrity": "sha1-Dovf5NHduIVNZOBOp8AOKgJuVlg=",
-      "dev": true
-    },
-    "growl": {
-      "version": "1.10.5",
-      "resolved": "https://registry.npmjs.org/growl/-/growl-1.10.5.tgz",
-      "integrity": "sha512-qBr4OuELkhPenW6goKVXiv47US3clb3/IbuWF9KNKEijAy9oeHxU9IgzjvJhHkUzhaj7rOUD7+YGWqUjLp5oSA==",
-      "dev": 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.3",
-      "resolved": "https://registry.npmjs.org/har-validator/-/har-validator-5.1.3.tgz",
-      "integrity": "sha512-sNvOCzEQNr/qrvJgc3UG/kD4QtlHycrzwS+6mfTrrSq97BvaYcPZZI1ZSqGSPR73Cxn4LKTD4PttRwfU7jWq5g==",
-      "dev": true,
-      "requires": {
-        "ajv": "^6.5.5",
-        "har-schema": "^2.0.0"
-      }
-    },
-    "has-ansi": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/has-ansi/-/has-ansi-2.0.0.tgz",
-      "integrity": "sha1-NPUEnOHs3ysGSa8+8k5F7TVBbZE=",
-      "dev": true,
-      "requires": {
-        "ansi-regex": "^2.0.0"
-      }
-    },
-    "has-flag": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
-      "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=",
-      "dev": true
-    },
-    "home-or-tmp": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/home-or-tmp/-/home-or-tmp-2.0.0.tgz",
-      "integrity": "sha1-42w/LSyufXRqhX440Y1fMqeILbg=",
-      "dev": true,
-      "requires": {
-        "os-homedir": "^1.0.0",
-        "os-tmpdir": "^1.0.1"
-      }
-    },
-    "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"
-      }
-    },
-    "import-jsx": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/import-jsx/-/import-jsx-2.0.0.tgz",
-      "integrity": "sha512-xmrgtiRnAdjIaRzKwsHut54FA8nx59WqN4MpQvPFr/8yD6BamavkmKHrA5dotAlnIiF4uqMzg/lA5yhPdpIXsA==",
-      "dev": true,
-      "requires": {
-        "babel-core": "^6.25.0",
-        "babel-plugin-transform-es2015-destructuring": "^6.23.0",
-        "babel-plugin-transform-object-rest-spread": "^6.23.0",
-        "babel-plugin-transform-react-jsx": "^6.24.1",
-        "caller-path": "^2.0.0",
-        "resolve-from": "^3.0.0"
-      },
-      "dependencies": {
-        "caller-path": {
-          "version": "2.0.0",
-          "resolved": "https://registry.npmjs.org/caller-path/-/caller-path-2.0.0.tgz",
-          "integrity": "sha1-Ro+DBE42mrIBD6xfBs7uFbsssfQ=",
-          "dev": true,
-          "requires": {
-            "caller-callsite": "^2.0.0"
-          }
-        },
-        "resolve-from": {
-          "version": "3.0.0",
-          "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-3.0.0.tgz",
-          "integrity": "sha1-six699nWiBvItuZTM17rywoYh0g=",
-          "dev": true
-        }
-      }
-    },
-    "imurmurhash": {
-      "version": "0.1.4",
-      "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
-      "integrity": "sha1-khi5srkoojixPcT7a21XbyMUU+o=",
-      "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.3",
-      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
-      "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=",
-      "dev": true
-    },
-    "ink": {
-      "version": "2.0.6",
-      "resolved": "https://registry.npmjs.org/ink/-/ink-2.0.6.tgz",
-      "integrity": "sha512-FGsR0tlVkeQJQDzOff/rIENgVWmQ7jZN1F4pXrE1WLjAaMl1th6lsj5+QhnlL28TMA+RAKo6Y7vKc7WZrbpj5Q==",
-      "dev": true,
-      "requires": {
-        "@types/react": "^16.8.6",
-        "arrify": "^1.0.1",
-        "auto-bind": "^2.0.0",
-        "chalk": "^2.4.1",
-        "cli-cursor": "^2.1.0",
-        "lodash.throttle": "^4.1.1",
-        "log-update": "^3.0.0",
-        "prop-types": "^15.6.2",
-        "react-reconciler": "^0.20.0",
-        "scheduler": "^0.13.2",
-        "slice-ansi": "^1.0.0",
-        "string-length": "^2.0.0",
-        "widest-line": "^2.0.0",
-        "yoga-layout-prebuilt": "^1.9.3"
-      }
-    },
-    "invariant": {
-      "version": "2.2.4",
-      "resolved": "https://registry.npmjs.org/invariant/-/invariant-2.2.4.tgz",
-      "integrity": "sha512-phJfQVBuaJM5raOpJjSfkiD6BpbCE4Ns//LaXl6wGYtUBY83nWS6Rf9tXm2e8VaK60JEjYldbPif/A2B1C2gNA==",
-      "dev": true,
-      "requires": {
-        "loose-envify": "^1.0.0"
-      }
-    },
-    "is-finite": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/is-finite/-/is-finite-1.0.2.tgz",
-      "integrity": "sha1-zGZ3aVYCvlUO8R6LSqYwU0K20Ko=",
-      "dev": true,
-      "requires": {
-        "number-is-nan": "^1.0.0"
-      }
-    },
-    "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-typedarray": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz",
-      "integrity": "sha1-5HnICFjfDBsR3dppQPlgEfzaSpo=",
-      "dev": true
-    },
-    "isarray": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
-      "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=",
-      "dev": true,
-      "optional": true
-    },
-    "isexe": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
-      "integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=",
-      "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": "2.0.3",
-      "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.3.tgz",
-      "integrity": "sha512-dKWuzRGCs4G+67VfW9pBFFz2Jpi4vSp/k7zBcJ888ofV5Mi1g5CUML5GvMvV6u9Cjybftu+E8Cgp+k0dI1E5lw==",
-      "dev": true
-    },
-    "istanbul-lib-instrument": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/istanbul-lib-instrument/-/istanbul-lib-instrument-3.1.0.tgz",
-      "integrity": "sha512-ooVllVGT38HIk8MxDj/OIHXSYvH+1tq/Vb38s8ixt9GoJadXska4WkGY+0wkmtYCZNYtaARniH/DixUGGLZ0uA==",
-      "dev": true,
-      "requires": {
-        "@babel/generator": "^7.0.0",
-        "@babel/parser": "^7.0.0",
-        "@babel/template": "^7.0.0",
-        "@babel/traverse": "^7.0.0",
-        "@babel/types": "^7.0.0",
-        "istanbul-lib-coverage": "^2.0.3",
-        "semver": "^5.5.0"
-      }
-    },
-    "jackspeak": {
-      "version": "1.3.4",
-      "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-1.3.4.tgz",
-      "integrity": "sha512-OlbyvDruQiLcHXewlMi0hq0bI3F6FnPZf2LG8ShE0MlmRpqBo7VoLz4tCrrykABnVik+ai32/PQNqmOh8IcPeg==",
-      "dev": true,
-      "requires": {
-        "cliui": "^4.1.0"
-      }
-    },
-    "js-tokens": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-3.0.2.tgz",
-      "integrity": "sha1-mGbfOVECEw449/mWvOtlRDIJwls=",
-      "dev": true
-    },
-    "js-yaml": {
-      "version": "3.13.0",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.13.0.tgz",
-      "integrity": "sha512-pZZoSxcCYco+DIKBTimr67J6Hy+EYGZDY/HCWC+iAEA9h1ByhMXAIVUXMcMFpOCxQ/xjXmPI2MkDL5HRm5eFrQ==",
-      "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
-    },
-    "jsesc": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-1.3.0.tgz",
-      "integrity": "sha1-RsP+yMGJKxKwgz25vHYiF226s0s=",
-      "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-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": "0.5.1",
-      "resolved": "https://registry.npmjs.org/json5/-/json5-0.5.1.tgz",
-      "integrity": "sha1-Hq3nrMASA0rYTiOWdn6tn6VJWCE=",
-      "dev": true
-    },
-    "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"
-      }
-    },
-    "lcov-parse": {
-      "version": "0.0.10",
-      "resolved": "https://registry.npmjs.org/lcov-parse/-/lcov-parse-0.0.10.tgz",
-      "integrity": "sha1-GwuP+ayceIklBYK3C3ExXZ2m2aM=",
-      "dev": true
-    },
-    "lodash": {
-      "version": "4.17.11",
-      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.11.tgz",
-      "integrity": "sha512-cQKh8igo5QUhZ7lg38DYWAxMvjSAKG0A8wGSVimP07SIUEK2UO+arSRKbRZWtelMtN5V0Hkwh5ryOto/SshYIg==",
-      "dev": true
-    },
-    "lodash.throttle": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/lodash.throttle/-/lodash.throttle-4.1.1.tgz",
-      "integrity": "sha1-wj6RtxAkKscMN/HhzaknTMOb8vQ=",
-      "dev": true
-    },
-    "log-driver": {
-      "version": "1.2.7",
-      "resolved": "https://registry.npmjs.org/log-driver/-/log-driver-1.2.7.tgz",
-      "integrity": "sha512-U7KCmLdqsGHBLeWqYlFA0V0Sl6P08EE1ZrmA9cxjUE0WVqT9qnyVDPz1kzpFEP0jdJuFnasWIfSd7fsaNXkpbg==",
-      "dev": true
-    },
-    "log-update": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/log-update/-/log-update-3.1.0.tgz",
-      "integrity": "sha512-7ttbZj4w165ZemmS9YngKbBh4/UEiW1gS+SPpfQQHIMYcPMybTDM6UDlmQLrjJ8+j23On173OFB+pXKfPRJP3A==",
-      "dev": true,
-      "requires": {
-        "ansi-escapes": "^3.2.0",
-        "cli-cursor": "^2.1.0",
-        "wrap-ansi": "^5.0.0"
-      },
-      "dependencies": {
-        "ansi-escapes": {
-          "version": "3.2.0",
-          "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-3.2.0.tgz",
-          "integrity": "sha512-cBhpre4ma+U0T1oM5fXg7Dy1Jw7zzwv7lt/GoCpr+hDQJoYnKVPLL4dCvSEFMmQurOQvSrwT7SL/DAlhBI97RQ==",
-          "dev": true
-        },
-        "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
-        },
-        "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"
-          }
-        },
-        "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"
-          }
-        },
-        "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"
-          }
-        },
-        "wrap-ansi": {
-          "version": "5.0.0",
-          "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-5.0.0.tgz",
-          "integrity": "sha512-3ThemJUfTTju0SKG2gjGExzGRHxT5l/KEM5sff3TQReaVWe/bFTiF1GEr8DKr/j0LxGt8qPzx0yhd2RLyqgy2Q==",
-          "dev": true,
-          "requires": {
-            "ansi-styles": "^3.2.0",
-            "string-width": "^3.0.0",
-            "strip-ansi": "^5.0.0"
-          }
-        }
-      }
-    },
-    "loose-envify": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
-      "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
-      "dev": true,
-      "requires": {
-        "js-tokens": "^3.0.0 || ^4.0.0"
-      }
-    },
-    "lru-cache": {
-      "version": "4.1.5",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-4.1.5.tgz",
-      "integrity": "sha512-sWZlbEP2OsHNkXrMl5GYk/jKk70MBng6UU4YI/qGDYbgf6YbP4EvmqISbXCoJiRKs+1bSpFHVgQxvJ17F2li5g==",
-      "dev": true,
-      "requires": {
-        "pseudomap": "^1.0.2",
-        "yallist": "^2.1.2"
-      }
-    },
-    "make-error": {
-      "version": "1.3.5",
-      "resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.5.tgz",
-      "integrity": "sha512-c3sIjNUow0+8swNwVpqoH4YCShKNFkMaw6oH1mNS2haDZQqkeZFlHS3dhoeEbKKmJB4vXpJucU6oH75aDYeE9g==",
-      "dev": true
-    },
-    "mime-db": {
-      "version": "1.38.0",
-      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.38.0.tgz",
-      "integrity": "sha512-bqVioMFFzc2awcdJZIzR3HjZFX20QhilVS7hytkKrv7xFAn8bM1gzc/FOX2awLISvWe0PV8ptFKcon+wZ5qYkg==",
-      "dev": true
-    },
-    "mime-types": {
-      "version": "2.1.22",
-      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.22.tgz",
-      "integrity": "sha512-aGl6TZGnhm/li6F7yx82bJiBZwgiEa4Hf6CNr8YO+r5UHr53tSTYZb102zyU50DOWWKeOv0uQLRL0/9EiKWCog==",
-      "dev": true,
-      "requires": {
-        "mime-db": "~1.38.0"
-      }
-    },
-    "mimic-fn": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-1.2.0.tgz",
-      "integrity": "sha512-jf84uxzwiuiIVKiOLpfYk7N46TSy8ubTonmneY9vrpHNAnp0QBt2BxWV9dO3/j+BoVAb+a5G6YDPW3M5HOdMWQ==",
-      "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.0",
-      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz",
-      "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=",
-      "dev": true
-    },
-    "minipass": {
-      "version": "2.3.5",
-      "resolved": "https://registry.npmjs.org/minipass/-/minipass-2.3.5.tgz",
-      "integrity": "sha512-Gi1W4k059gyRbyVUZQ4mEqLm0YIUiGYfvxhF6SIlk3ui1WVxMTGfGdQ2SInh3PDrRTVvPKgULkpJtT4RH10+VA==",
-      "dev": true,
-      "requires": {
-        "safe-buffer": "^5.1.2",
-        "yallist": "^3.0.0"
-      },
-      "dependencies": {
-        "yallist": {
-          "version": "3.0.3",
-          "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.0.3.tgz",
-          "integrity": "sha512-S+Zk8DEWE6oKpV+vI3qWkaK+jSbIK86pCwe2IF/xwIpQ8jEuxpw9NyaGjmp9+BoJv5FV2piqCDcoCtStppiq2A==",
-          "dev": true
-        }
-      }
-    },
-    "mkdirp": {
-      "version": "0.5.1",
-      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz",
-      "integrity": "sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=",
-      "dev": true,
-      "requires": {
-        "minimist": "0.0.8"
-      },
-      "dependencies": {
-        "minimist": {
-          "version": "0.0.8",
-          "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz",
-          "integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=",
-          "dev": true
-        }
-      }
-    },
-    "ms": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
-      "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=",
-      "dev": true
-    },
-    "number-is-nan": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/number-is-nan/-/number-is-nan-1.0.1.tgz",
-      "integrity": "sha1-CXtgK1NCKlIsGvuHkDGDNpQaAR0=",
-      "dev": true
-    },
-    "nyc": {
-      "version": "13.3.0",
-      "resolved": "https://registry.npmjs.org/nyc/-/nyc-13.3.0.tgz",
-      "integrity": "sha512-P+FwIuro2aFG6B0Esd9ZDWUd51uZrAEoGutqZxzrVmYl3qSfkLgcQpBPBjtDFsUQLFY1dvTQJPOyeqr8S9GF8w==",
-      "dev": true,
-      "requires": {
-        "archy": "^1.0.0",
-        "arrify": "^1.0.1",
-        "caching-transform": "^3.0.1",
-        "convert-source-map": "^1.6.0",
-        "find-cache-dir": "^2.0.0",
-        "find-up": "^3.0.0",
-        "foreground-child": "^1.5.6",
-        "glob": "^7.1.3",
-        "istanbul-lib-coverage": "^2.0.3",
-        "istanbul-lib-hook": "^2.0.3",
-        "istanbul-lib-instrument": "^3.1.0",
-        "istanbul-lib-report": "^2.0.4",
-        "istanbul-lib-source-maps": "^3.0.2",
-        "istanbul-reports": "^2.1.1",
-        "make-dir": "^1.3.0",
-        "merge-source-map": "^1.1.0",
-        "resolve-from": "^4.0.0",
-        "rimraf": "^2.6.3",
-        "signal-exit": "^3.0.2",
-        "spawn-wrap": "^1.4.2",
-        "test-exclude": "^5.1.0",
-        "uuid": "^3.3.2",
-        "yargs": "^12.0.5",
-        "yargs-parser": "^11.1.1"
-      },
-      "dependencies": {
-        "ansi-regex": {
-          "version": "3.0.0",
-          "bundled": true,
-          "dev": true
-        },
-        "append-transform": {
-          "version": "1.0.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "default-require-extensions": "^2.0.0"
-          }
-        },
-        "archy": {
-          "version": "1.0.0",
-          "bundled": true,
-          "dev": true
-        },
-        "arrify": {
-          "version": "1.0.1",
-          "bundled": true,
-          "dev": true
-        },
-        "async": {
-          "version": "2.6.2",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "lodash": "^4.17.11"
-          }
-        },
-        "balanced-match": {
-          "version": "1.0.0",
-          "bundled": true,
-          "dev": true
-        },
-        "brace-expansion": {
-          "version": "1.1.11",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "balanced-match": "^1.0.0",
-            "concat-map": "0.0.1"
-          }
-        },
-        "caching-transform": {
-          "version": "3.0.1",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "hasha": "^3.0.0",
-            "make-dir": "^1.3.0",
-            "package-hash": "^3.0.0",
-            "write-file-atomic": "^2.3.0"
-          }
-        },
-        "camelcase": {
-          "version": "5.0.0",
-          "bundled": true,
-          "dev": true
-        },
-        "cliui": {
-          "version": "4.1.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "string-width": "^2.1.1",
-            "strip-ansi": "^4.0.0",
-            "wrap-ansi": "^2.0.0"
-          }
-        },
-        "code-point-at": {
-          "version": "1.1.0",
-          "bundled": true,
-          "dev": true
-        },
-        "commander": {
-          "version": "2.17.1",
-          "bundled": true,
-          "dev": true,
-          "optional": true
-        },
-        "commondir": {
-          "version": "1.0.1",
-          "bundled": true,
-          "dev": true
-        },
-        "concat-map": {
-          "version": "0.0.1",
-          "bundled": true,
-          "dev": true
-        },
-        "convert-source-map": {
-          "version": "1.6.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "safe-buffer": "~5.1.1"
-          }
-        },
-        "cross-spawn": {
-          "version": "4.0.2",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "lru-cache": "^4.0.1",
-            "which": "^1.2.9"
-          }
-        },
-        "debug": {
-          "version": "4.1.1",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "ms": "^2.1.1"
-          }
-        },
-        "decamelize": {
-          "version": "1.2.0",
-          "bundled": true,
-          "dev": true
-        },
-        "default-require-extensions": {
-          "version": "2.0.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "strip-bom": "^3.0.0"
-          }
-        },
-        "end-of-stream": {
-          "version": "1.4.1",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "once": "^1.4.0"
-          }
-        },
-        "error-ex": {
-          "version": "1.3.2",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "is-arrayish": "^0.2.1"
-          }
-        },
-        "es6-error": {
-          "version": "4.1.1",
-          "bundled": true,
-          "dev": true
-        },
-        "execa": {
-          "version": "1.0.0",
-          "bundled": true,
-          "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",
-              "bundled": true,
-              "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"
-              }
-            }
-          }
-        },
-        "find-cache-dir": {
-          "version": "2.0.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "commondir": "^1.0.1",
-            "make-dir": "^1.0.0",
-            "pkg-dir": "^3.0.0"
-          }
-        },
-        "find-up": {
-          "version": "3.0.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "locate-path": "^3.0.0"
-          }
-        },
-        "foreground-child": {
-          "version": "1.5.6",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "cross-spawn": "^4",
-            "signal-exit": "^3.0.0"
-          }
-        },
-        "fs.realpath": {
-          "version": "1.0.0",
-          "bundled": true,
-          "dev": true
-        },
-        "get-caller-file": {
-          "version": "1.0.3",
-          "bundled": true,
-          "dev": true
-        },
-        "get-stream": {
-          "version": "4.1.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "pump": "^3.0.0"
-          }
-        },
-        "glob": {
-          "version": "7.1.3",
-          "bundled": true,
-          "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"
-          }
-        },
-        "graceful-fs": {
-          "version": "4.1.15",
-          "bundled": true,
-          "dev": true
-        },
-        "handlebars": {
-          "version": "4.1.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "async": "^2.5.0",
-            "optimist": "^0.6.1",
-            "source-map": "^0.6.1",
-            "uglify-js": "^3.1.4"
-          },
-          "dependencies": {
-            "source-map": {
-              "version": "0.6.1",
-              "bundled": true,
-              "dev": true
-            }
-          }
-        },
-        "has-flag": {
-          "version": "3.0.0",
-          "bundled": true,
-          "dev": true
-        },
-        "hasha": {
-          "version": "3.0.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "is-stream": "^1.0.1"
-          }
-        },
-        "hosted-git-info": {
-          "version": "2.7.1",
-          "bundled": true,
-          "dev": true
-        },
-        "imurmurhash": {
-          "version": "0.1.4",
-          "bundled": true,
-          "dev": true
-        },
-        "inflight": {
-          "version": "1.0.6",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "once": "^1.3.0",
-            "wrappy": "1"
-          }
-        },
-        "inherits": {
-          "version": "2.0.3",
-          "bundled": true,
-          "dev": true
-        },
-        "invert-kv": {
-          "version": "2.0.0",
-          "bundled": true,
-          "dev": true
-        },
-        "is-arrayish": {
-          "version": "0.2.1",
-          "bundled": true,
-          "dev": true
-        },
-        "is-fullwidth-code-point": {
-          "version": "2.0.0",
-          "bundled": true,
-          "dev": true
-        },
-        "is-stream": {
-          "version": "1.1.0",
-          "bundled": true,
-          "dev": true
-        },
-        "isexe": {
-          "version": "2.0.0",
-          "bundled": true,
-          "dev": true
-        },
-        "istanbul-lib-coverage": {
-          "version": "2.0.3",
-          "bundled": true,
-          "dev": true
-        },
-        "istanbul-lib-hook": {
-          "version": "2.0.3",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "append-transform": "^1.0.0"
-          }
-        },
-        "istanbul-lib-report": {
-          "version": "2.0.4",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "istanbul-lib-coverage": "^2.0.3",
-            "make-dir": "^1.3.0",
-            "supports-color": "^6.0.0"
-          },
-          "dependencies": {
-            "supports-color": {
-              "version": "6.1.0",
-              "bundled": true,
-              "dev": true,
-              "requires": {
-                "has-flag": "^3.0.0"
-              }
-            }
-          }
-        },
-        "istanbul-lib-source-maps": {
-          "version": "3.0.2",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "debug": "^4.1.1",
-            "istanbul-lib-coverage": "^2.0.3",
-            "make-dir": "^1.3.0",
-            "rimraf": "^2.6.2",
-            "source-map": "^0.6.1"
-          },
-          "dependencies": {
-            "source-map": {
-              "version": "0.6.1",
-              "bundled": true,
-              "dev": true
-            }
-          }
-        },
-        "istanbul-reports": {
-          "version": "2.1.1",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "handlebars": "^4.1.0"
-          }
-        },
-        "json-parse-better-errors": {
-          "version": "1.0.2",
-          "bundled": true,
-          "dev": true
-        },
-        "lcid": {
-          "version": "2.0.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "invert-kv": "^2.0.0"
-          }
-        },
-        "load-json-file": {
-          "version": "4.0.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "graceful-fs": "^4.1.2",
-            "parse-json": "^4.0.0",
-            "pify": "^3.0.0",
-            "strip-bom": "^3.0.0"
-          }
-        },
-        "locate-path": {
-          "version": "3.0.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "p-locate": "^3.0.0",
-            "path-exists": "^3.0.0"
-          }
-        },
-        "lodash": {
-          "version": "4.17.11",
-          "bundled": true,
-          "dev": true
-        },
-        "lodash.flattendeep": {
-          "version": "4.4.0",
-          "bundled": true,
-          "dev": true
-        },
-        "lru-cache": {
-          "version": "4.1.5",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "pseudomap": "^1.0.2",
-            "yallist": "^2.1.2"
-          }
-        },
-        "make-dir": {
-          "version": "1.3.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "pify": "^3.0.0"
-          }
-        },
-        "map-age-cleaner": {
-          "version": "0.1.3",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "p-defer": "^1.0.0"
-          }
-        },
-        "mem": {
-          "version": "4.1.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "map-age-cleaner": "^0.1.1",
-            "mimic-fn": "^1.0.0",
-            "p-is-promise": "^2.0.0"
-          }
-        },
-        "merge-source-map": {
-          "version": "1.1.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "source-map": "^0.6.1"
-          },
-          "dependencies": {
-            "source-map": {
-              "version": "0.6.1",
-              "bundled": true,
-              "dev": true
-            }
-          }
-        },
-        "mimic-fn": {
-          "version": "1.2.0",
-          "bundled": true,
-          "dev": true
-        },
-        "minimatch": {
-          "version": "3.0.4",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "brace-expansion": "^1.1.7"
-          }
-        },
-        "minimist": {
-          "version": "0.0.10",
-          "bundled": true,
-          "dev": true
-        },
-        "mkdirp": {
-          "version": "0.5.1",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "minimist": "0.0.8"
-          },
-          "dependencies": {
-            "minimist": {
-              "version": "0.0.8",
-              "bundled": true,
-              "dev": true
-            }
-          }
-        },
-        "ms": {
-          "version": "2.1.1",
-          "bundled": true,
-          "dev": true
-        },
-        "nice-try": {
-          "version": "1.0.5",
-          "bundled": true,
-          "dev": true
-        },
-        "normalize-package-data": {
-          "version": "2.5.0",
-          "bundled": true,
-          "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"
-          }
-        },
-        "npm-run-path": {
-          "version": "2.0.2",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "path-key": "^2.0.0"
-          }
-        },
-        "number-is-nan": {
-          "version": "1.0.1",
-          "bundled": true,
-          "dev": true
-        },
-        "once": {
-          "version": "1.4.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "wrappy": "1"
-          }
-        },
-        "optimist": {
-          "version": "0.6.1",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "minimist": "~0.0.1",
-            "wordwrap": "~0.0.2"
-          }
-        },
-        "os-homedir": {
-          "version": "1.0.2",
-          "bundled": true,
-          "dev": true
-        },
-        "os-locale": {
-          "version": "3.1.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "execa": "^1.0.0",
-            "lcid": "^2.0.0",
-            "mem": "^4.0.0"
-          }
-        },
-        "p-defer": {
-          "version": "1.0.0",
-          "bundled": true,
-          "dev": true
-        },
-        "p-finally": {
-          "version": "1.0.0",
-          "bundled": true,
-          "dev": true
-        },
-        "p-is-promise": {
-          "version": "2.0.0",
-          "bundled": true,
-          "dev": true
-        },
-        "p-limit": {
-          "version": "2.1.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "p-try": "^2.0.0"
-          }
-        },
-        "p-locate": {
-          "version": "3.0.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "p-limit": "^2.0.0"
-          }
-        },
-        "p-try": {
-          "version": "2.0.0",
-          "bundled": true,
-          "dev": true
-        },
-        "package-hash": {
-          "version": "3.0.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "graceful-fs": "^4.1.15",
-            "hasha": "^3.0.0",
-            "lodash.flattendeep": "^4.4.0",
-            "release-zalgo": "^1.0.0"
-          }
-        },
-        "parse-json": {
-          "version": "4.0.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "error-ex": "^1.3.1",
-            "json-parse-better-errors": "^1.0.1"
-          }
-        },
-        "path-exists": {
-          "version": "3.0.0",
-          "bundled": true,
-          "dev": true
-        },
-        "path-is-absolute": {
-          "version": "1.0.1",
-          "bundled": true,
-          "dev": true
-        },
-        "path-key": {
-          "version": "2.0.1",
-          "bundled": true,
-          "dev": true
-        },
-        "path-parse": {
-          "version": "1.0.6",
-          "bundled": true,
-          "dev": true
-        },
-        "path-type": {
-          "version": "3.0.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "pify": "^3.0.0"
-          }
-        },
-        "pify": {
-          "version": "3.0.0",
-          "bundled": true,
-          "dev": true
-        },
-        "pkg-dir": {
-          "version": "3.0.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "find-up": "^3.0.0"
-          }
-        },
-        "pseudomap": {
-          "version": "1.0.2",
-          "bundled": true,
-          "dev": true
-        },
-        "pump": {
-          "version": "3.0.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "end-of-stream": "^1.1.0",
-            "once": "^1.3.1"
-          }
-        },
-        "read-pkg": {
-          "version": "3.0.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "load-json-file": "^4.0.0",
-            "normalize-package-data": "^2.3.2",
-            "path-type": "^3.0.0"
-          }
-        },
-        "read-pkg-up": {
-          "version": "4.0.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "find-up": "^3.0.0",
-            "read-pkg": "^3.0.0"
-          }
-        },
-        "release-zalgo": {
-          "version": "1.0.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "es6-error": "^4.0.1"
-          }
-        },
-        "require-directory": {
-          "version": "2.1.1",
-          "bundled": true,
-          "dev": true
-        },
-        "require-main-filename": {
-          "version": "1.0.1",
-          "bundled": true,
-          "dev": true
-        },
-        "resolve": {
-          "version": "1.10.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "path-parse": "^1.0.6"
-          }
-        },
-        "resolve-from": {
-          "version": "4.0.0",
-          "bundled": true,
-          "dev": true
-        },
-        "rimraf": {
-          "version": "2.6.3",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "glob": "^7.1.3"
-          }
-        },
-        "safe-buffer": {
-          "version": "5.1.2",
-          "bundled": true,
-          "dev": true
-        },
-        "semver": {
-          "version": "5.6.0",
-          "bundled": true,
-          "dev": true
-        },
-        "set-blocking": {
-          "version": "2.0.0",
-          "bundled": true,
-          "dev": true
-        },
-        "shebang-command": {
-          "version": "1.2.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "shebang-regex": "^1.0.0"
-          }
-        },
-        "shebang-regex": {
-          "version": "1.0.0",
-          "bundled": true,
-          "dev": true
-        },
-        "signal-exit": {
-          "version": "3.0.2",
-          "bundled": true,
-          "dev": true
-        },
-        "spawn-wrap": {
-          "version": "1.4.2",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "foreground-child": "^1.5.6",
-            "mkdirp": "^0.5.0",
-            "os-homedir": "^1.0.1",
-            "rimraf": "^2.6.2",
-            "signal-exit": "^3.0.2",
-            "which": "^1.3.0"
-          }
-        },
-        "spdx-correct": {
-          "version": "3.1.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "spdx-expression-parse": "^3.0.0",
-            "spdx-license-ids": "^3.0.0"
-          }
-        },
-        "spdx-exceptions": {
-          "version": "2.2.0",
-          "bundled": true,
-          "dev": true
-        },
-        "spdx-expression-parse": {
-          "version": "3.0.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "spdx-exceptions": "^2.1.0",
-            "spdx-license-ids": "^3.0.0"
-          }
-        },
-        "spdx-license-ids": {
-          "version": "3.0.3",
-          "bundled": true,
-          "dev": true
-        },
-        "string-width": {
-          "version": "2.1.1",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "is-fullwidth-code-point": "^2.0.0",
-            "strip-ansi": "^4.0.0"
-          }
-        },
-        "strip-ansi": {
-          "version": "4.0.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "ansi-regex": "^3.0.0"
-          }
-        },
-        "strip-bom": {
-          "version": "3.0.0",
-          "bundled": true,
-          "dev": true
-        },
-        "strip-eof": {
-          "version": "1.0.0",
-          "bundled": true,
-          "dev": true
-        },
-        "test-exclude": {
-          "version": "5.1.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "arrify": "^1.0.1",
-            "minimatch": "^3.0.4",
-            "read-pkg-up": "^4.0.0",
-            "require-main-filename": "^1.0.1"
-          }
-        },
-        "uglify-js": {
-          "version": "3.4.9",
-          "bundled": true,
-          "dev": true,
-          "optional": true,
-          "requires": {
-            "commander": "~2.17.1",
-            "source-map": "~0.6.1"
-          },
-          "dependencies": {
-            "source-map": {
-              "version": "0.6.1",
-              "bundled": true,
-              "dev": true,
-              "optional": true
-            }
-          }
-        },
-        "uuid": {
-          "version": "3.3.2",
-          "bundled": true,
-          "dev": true
-        },
-        "validate-npm-package-license": {
-          "version": "3.0.4",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "spdx-correct": "^3.0.0",
-            "spdx-expression-parse": "^3.0.0"
-          }
-        },
-        "which": {
-          "version": "1.3.1",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "isexe": "^2.0.0"
-          }
-        },
-        "which-module": {
-          "version": "2.0.0",
-          "bundled": true,
-          "dev": true
-        },
-        "wordwrap": {
-          "version": "0.0.3",
-          "bundled": true,
-          "dev": true
-        },
-        "wrap-ansi": {
-          "version": "2.1.0",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "string-width": "^1.0.1",
-            "strip-ansi": "^3.0.1"
-          },
-          "dependencies": {
-            "ansi-regex": {
-              "version": "2.1.1",
-              "bundled": true,
-              "dev": true
-            },
-            "is-fullwidth-code-point": {
-              "version": "1.0.0",
-              "bundled": true,
-              "dev": true,
-              "requires": {
-                "number-is-nan": "^1.0.0"
-              }
-            },
-            "string-width": {
-              "version": "1.0.2",
-              "bundled": true,
-              "dev": true,
-              "requires": {
-                "code-point-at": "^1.0.0",
-                "is-fullwidth-code-point": "^1.0.0",
-                "strip-ansi": "^3.0.0"
-              }
-            },
-            "strip-ansi": {
-              "version": "3.0.1",
-              "bundled": true,
-              "dev": true,
-              "requires": {
-                "ansi-regex": "^2.0.0"
-              }
-            }
-          }
-        },
-        "wrappy": {
-          "version": "1.0.2",
-          "bundled": true,
-          "dev": true
-        },
-        "write-file-atomic": {
-          "version": "2.4.2",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "graceful-fs": "^4.1.11",
-            "imurmurhash": "^0.1.4",
-            "signal-exit": "^3.0.2"
-          }
-        },
-        "y18n": {
-          "version": "4.0.0",
-          "bundled": true,
-          "dev": true
-        },
-        "yallist": {
-          "version": "2.1.2",
-          "bundled": true,
-          "dev": true
-        },
-        "yargs": {
-          "version": "12.0.5",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "cliui": "^4.0.0",
-            "decamelize": "^1.2.0",
-            "find-up": "^3.0.0",
-            "get-caller-file": "^1.0.1",
-            "os-locale": "^3.0.0",
-            "require-directory": "^2.1.1",
-            "require-main-filename": "^1.0.1",
-            "set-blocking": "^2.0.0",
-            "string-width": "^2.0.0",
-            "which-module": "^2.0.0",
-            "y18n": "^3.2.1 || ^4.0.0",
-            "yargs-parser": "^11.1.1"
-          }
-        },
-        "yargs-parser": {
-          "version": "11.1.1",
-          "bundled": true,
-          "dev": true,
-          "requires": {
-            "camelcase": "^5.0.0",
-            "decamelize": "^1.2.0"
-          }
-        }
-      }
-    },
-    "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-assign": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
-      "integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=",
-      "dev": true
-    },
-    "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": "2.0.1",
-      "resolved": "https://registry.npmjs.org/onetime/-/onetime-2.0.1.tgz",
-      "integrity": "sha1-BnQoIw/WdEOyeUsiu6UotoZ5YtQ=",
-      "dev": true,
-      "requires": {
-        "mimic-fn": "^1.0.0"
-      }
-    },
-    "opener": {
-      "version": "1.5.1",
-      "resolved": "https://registry.npmjs.org/opener/-/opener-1.5.1.tgz",
-      "integrity": "sha512-goYSy5c2UXE4Ra1xixabeVh1guIX/ZV/YokJksb6q2lubWu6UbvPQ20p542/sFIll1nl8JnCyK9oBaOcCWXwvA==",
-      "dev": true
-    },
-    "os-homedir": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/os-homedir/-/os-homedir-1.0.2.tgz",
-      "integrity": "sha1-/7xJiDNuDoM94MFox+8VISGqf7M=",
-      "dev": true
-    },
-    "os-tmpdir": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz",
-      "integrity": "sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ=",
-      "dev": true
-    },
-    "own-or": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/own-or/-/own-or-1.0.0.tgz",
-      "integrity": "sha1-Tod/vtqaLsgAD7wLyuOWRe6L+Nw=",
-      "dev": true
-    },
-    "own-or-env": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/own-or-env/-/own-or-env-1.0.1.tgz",
-      "integrity": "sha512-y8qULRbRAlL6x2+M0vIe7jJbJx/kmUTzYonRAa2ayesR2qWLswninkVyeJe4x3IEXhdgoNodzjQRKAoEs6Fmrw==",
-      "dev": true,
-      "requires": {
-        "own-or": "^1.0.0"
-      }
-    },
-    "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
-    },
-    "performance-now": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz",
-      "integrity": "sha1-Ywn04OX6kT7BxpMHrjZLSzd8nns=",
-      "dev": true
-    },
-    "private": {
-      "version": "0.1.8",
-      "resolved": "https://registry.npmjs.org/private/-/private-0.1.8.tgz",
-      "integrity": "sha512-VvivMrbvd2nKkiG38qjULzlc+4Vx4wm/whI9pQD35YrARNnhxeiRktSOhSukRLFNlzg6Br/cJPet5J/u19r/mg==",
-      "dev": true
-    },
-    "process-nextick-args": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.0.tgz",
-      "integrity": "sha512-MtEC1TqN0EU5nephaJ4rAtThHtC86dNN9qCuEhtshvpVBkAW5ZO7BASN9REnF9eoXGcRub+pFuKEpOHE+HbEMw==",
-      "dev": true,
-      "optional": true
-    },
-    "prop-types": {
-      "version": "15.6.2",
-      "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.6.2.tgz",
-      "integrity": "sha512-3pboPvLiWD7dkI3qf3KbUe6hKFKa52w+AE0VCqECtf+QHAKgOL37tTaNCnuX1nAAQ4ZhyP+kYVKf8rLmJ/feDQ==",
-      "dev": true,
-      "requires": {
-        "loose-envify": "^1.3.1",
-        "object-assign": "^4.1.1"
-      }
-    },
-    "pseudomap": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/pseudomap/-/pseudomap-1.0.2.tgz",
-      "integrity": "sha1-8FKijacOYYkX7wqKw0wa5aaChrM=",
-      "dev": true
-    },
-    "psl": {
-      "version": "1.1.31",
-      "resolved": "https://registry.npmjs.org/psl/-/psl-1.1.31.tgz",
-      "integrity": "sha512-/6pt4+C+T+wZUieKR620OpzN/LlnNKuWjy1iFLQ/UG35JqHlR/89MP1d96dUfkf6Dne3TuLQzOYEYshJ+Hx8mw==",
-      "dev": true
-    },
-    "punycode": {
-      "version": "1.4.1",
-      "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz",
-      "integrity": "sha1-wNWmOycYgArY4esPpSachN1BhF4=",
-      "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": {
-      "version": "16.8.5",
-      "resolved": "https://registry.npmjs.org/react/-/react-16.8.5.tgz",
-      "integrity": "sha512-daCb9TD6FZGvJ3sg8da1tRAtIuw29PbKZW++NN4wqkbEvxL+bZpaaYb4xuftW/SpXmgacf1skXl/ddX6CdOlDw==",
-      "dev": true,
-      "requires": {
-        "loose-envify": "^1.1.0",
-        "object-assign": "^4.1.1",
-        "prop-types": "^15.6.2",
-        "scheduler": "^0.13.5"
-      }
-    },
-    "react-reconciler": {
-      "version": "0.20.3",
-      "resolved": "https://registry.npmjs.org/react-reconciler/-/react-reconciler-0.20.3.tgz",
-      "integrity": "sha512-kKowgno8ZRNhFSQcuQ2ja/Lrvav58qnwy4w7bVbA4x+WKlDrP1vU42AQwwi2fMltVRTprD6OVMuCumPFPrB9fQ==",
-      "dev": true,
-      "requires": {
-        "loose-envify": "^1.1.0",
-        "object-assign": "^4.1.1",
-        "prop-types": "^15.6.2",
-        "scheduler": "^0.13.5"
-      }
-    },
-    "readable-stream": {
-      "version": "2.3.6",
-      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz",
-      "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==",
-      "dev": true,
-      "optional": true,
-      "requires": {
-        "core-util-is": "~1.0.0",
-        "inherits": "~2.0.3",
-        "isarray": "~1.0.0",
-        "process-nextick-args": "~2.0.0",
-        "safe-buffer": "~5.1.1",
-        "string_decoder": "~1.1.1",
-        "util-deprecate": "~1.0.1"
-      }
-    },
-    "redeyed": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/redeyed/-/redeyed-2.1.1.tgz",
-      "integrity": "sha1-iYS1gV2ZyyIEacme7v/jiRPmzAs=",
-      "dev": true,
-      "requires": {
-        "esprima": "~4.0.0"
-      }
-    },
-    "regenerator-runtime": {
-      "version": "0.11.1",
-      "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.11.1.tgz",
-      "integrity": "sha512-MguG95oij0fC3QV3URf4V2SDYGJhJnJGqvIIgdECeODCT98wSWDAJ94SSuVpYQUoTcGUIL6L4yNB7j1DFFHSBg==",
-      "dev": true
-    },
-    "repeating": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/repeating/-/repeating-2.0.1.tgz",
-      "integrity": "sha1-UhTFOpJtNVJwdSf7q0FdvAjQbdo=",
-      "dev": true,
-      "requires": {
-        "is-finite": "^1.0.0"
-      }
-    },
-    "request": {
-      "version": "2.88.0",
-      "resolved": "https://registry.npmjs.org/request/-/request-2.88.0.tgz",
-      "integrity": "sha512-NAqBSrijGLZdM0WZNsInLJpkJokL72XYjUpnB0iwsRgxh7dB6COrHnTBNwN0E+lHDAJzu7kLAkDeY08z2/A0hg==",
-      "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.0",
-        "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.4.3",
-        "tunnel-agent": "^0.6.0",
-        "uuid": "^3.3.2"
-      }
-    },
-    "restore-cursor": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-2.0.0.tgz",
-      "integrity": "sha1-n37ih/gv0ybU/RYpI9YhKe7g368=",
-      "dev": true,
-      "requires": {
-        "onetime": "^2.0.0",
-        "signal-exit": "^3.0.2"
-      }
-    },
-    "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
-    },
-    "safer-buffer": {
-      "version": "2.1.2",
-      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
-      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
-      "dev": true
-    },
-    "scheduler": {
-      "version": "0.13.5",
-      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.13.5.tgz",
-      "integrity": "sha512-K98vjkQX9OIt/riLhp6F+XtDPtMQhqNcf045vsh+pcuvHq+PHy1xCrH3pq1P40m6yR46lpVvVhKdEOtnimuUJw==",
-      "dev": true,
-      "requires": {
-        "loose-envify": "^1.1.0",
-        "object-assign": "^4.1.1"
-      }
-    },
-    "semver": {
-      "version": "5.6.0",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-5.6.0.tgz",
-      "integrity": "sha512-RS9R6R35NYgQn++fkDWaOmqGoj4Ek9gGs+DPxNUZKuwE183xjJroKvyo1IzVFeXvUrvmALy6FWD5xrdJT25gMg==",
-      "dev": true
-    },
-    "signal-exit": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.2.tgz",
-      "integrity": "sha1-tf3AjxKH6hF4Yo5BXiUTK3NkbG0=",
-      "dev": true
-    },
-    "slash": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/slash/-/slash-1.0.0.tgz",
-      "integrity": "sha1-xB8vbDn8FtHNF61LXYlhFK5HDVU=",
-      "dev": true
-    },
-    "slice-ansi": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-1.0.0.tgz",
-      "integrity": "sha512-POqxBK6Lb3q6s047D/XsDVNPnF9Dl8JSaqe9h9lURl0OdNqy/ujDrOiIHtsqXMGbWWTIomRzAMaTyawAU//Reg==",
-      "dev": true,
-      "requires": {
-        "is-fullwidth-code-point": "^2.0.0"
-      }
-    },
-    "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-support": {
-      "version": "0.5.11",
-      "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.11.tgz",
-      "integrity": "sha512-//sajEx/fGL3iw6fltKMdPvy8kL3kJ2O3iuYlRoT3k9Kb4BjOoZ+BZzaNHeuaruSt+Kf3Zk9tnfAQg9/AJqUVQ==",
-      "dev": true,
-      "requires": {
-        "buffer-from": "^1.0.0",
-        "source-map": "^0.6.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": "1.0.2",
-      "resolved": "https://registry.npmjs.org/stack-utils/-/stack-utils-1.0.2.tgz",
-      "integrity": "sha512-MTX+MeG5U994cazkjd/9KNAapsHnibjMLnfXodlkXw76JEea0UiNzrqidzo1emMwk7w5Qhc9jd4Bn9TBb1MFwA==",
-      "dev": true
-    },
-    "string-length": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/string-length/-/string-length-2.0.0.tgz",
-      "integrity": "sha1-1A27aGo6zpYMHP/KVivyxF+DY+0=",
-      "dev": true,
-      "requires": {
-        "astral-regex": "^1.0.0",
-        "strip-ansi": "^4.0.0"
-      },
-      "dependencies": {
-        "ansi-regex": {
-          "version": "3.0.0",
-          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz",
-          "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=",
-          "dev": true
-        },
-        "strip-ansi": {
-          "version": "4.0.0",
-          "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz",
-          "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=",
-          "dev": true,
-          "requires": {
-            "ansi-regex": "^3.0.0"
-          }
-        }
-      }
-    },
-    "string-width": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz",
-      "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==",
-      "dev": true,
-      "requires": {
-        "is-fullwidth-code-point": "^2.0.0",
-        "strip-ansi": "^4.0.0"
-      },
-      "dependencies": {
-        "ansi-regex": {
-          "version": "3.0.0",
-          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz",
-          "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=",
-          "dev": true
-        },
-        "strip-ansi": {
-          "version": "4.0.0",
-          "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz",
-          "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=",
-          "dev": true,
-          "requires": {
-            "ansi-regex": "^3.0.0"
-          }
-        }
-      }
-    },
-    "string_decoder": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
-      "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
-      "dev": true,
-      "optional": true,
-      "requires": {
-        "safe-buffer": "~5.1.0"
-      }
-    },
-    "strip-ansi": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz",
-      "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=",
-      "dev": true,
-      "requires": {
-        "ansi-regex": "^2.0.0"
-      }
-    },
-    "supports-color": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-2.0.0.tgz",
-      "integrity": "sha1-U10EXOa2Nj+kARcIRimZXp3zJMc=",
-      "dev": true
-    },
-    "tap": {
-      "version": "13.0.0-rc.18",
-      "resolved": "https://registry.npmjs.org/tap/-/tap-13.0.0-rc.18.tgz",
-      "integrity": "sha512-wW2O0oJYAbebAkncPdam25j6256enAAljRs7o2qiNs4C49srHZ/gz8Ge+hnrUrCqxGNHIf7oWhP8NFrQEBv6Sg==",
-      "dev": true,
-      "requires": {
-        "async-hook-domain": "^1.1.0",
-        "bind-obj-methods": "^2.0.0",
-        "browser-process-hrtime": "^1.0.0",
-        "capture-stack-trace": "^1.0.0",
-        "color-support": "^1.1.0",
-        "coveralls": "^3.0.3",
-        "domain-browser": "^1.2.0",
-        "esm": "^3.2.20",
-        "findit": "^2.0.0",
-        "foreground-child": "^1.3.3",
-        "fs-exists-cached": "^1.0.0",
-        "function-loop": "^1.0.1",
-        "glob": "^7.1.3",
-        "import-jsx": "^2.0.0",
-        "isexe": "^2.0.0",
-        "jackspeak": "^1.3.4",
-        "minipass": "^2.3.5",
-        "mkdirp": "^0.5.1",
-        "nyc": "^13.3.0",
-        "opener": "^1.5.1",
-        "own-or": "^1.0.0",
-        "own-or-env": "^1.0.1",
-        "rimraf": "^2.6.3",
-        "signal-exit": "^3.0.0",
-        "source-map-support": "^0.5.11",
-        "stack-utils": "^1.0.2",
-        "tap-mocha-reporter": "^4.0.1",
-        "tap-parser": "^9.3.1",
-        "tap-yaml": "0 || 1",
-        "tcompare": "^2.1.0",
-        "treport": "0.0.3",
-        "trivial-deferred": "^1.0.1",
-        "ts-node": "^8.0.3",
-        "typescript": "^3.3.4000",
-        "write-file-atomic": "^2.4.2",
-        "yapool": "^1.0.0"
-      },
-      "dependencies": {
-        "glob": {
-          "version": "7.1.3",
-          "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.3.tgz",
-          "integrity": "sha512-vcfuiIxogLV4DlGBHIUOwI0IbrJ8HWPc4MU7HzviGeNho/UJDfi6B5p3sHeWIQ0KGIU0Jpxi5ZHxemQfLkkAwQ==",
-          "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"
-          }
-        },
-        "rimraf": {
-          "version": "2.6.3",
-          "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.3.tgz",
-          "integrity": "sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==",
-          "dev": true,
-          "requires": {
-            "glob": "^7.1.3"
-          }
-        }
-      }
-    },
-    "tap-mocha-reporter": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/tap-mocha-reporter/-/tap-mocha-reporter-4.0.1.tgz",
-      "integrity": "sha512-/KfXaaYeSPn8qBi5Be8WSIP3iKV83s2uj2vzImJAXmjNu22kzqZ+1Dv1riYWa53sPCiyo1R1w1jbJrftF8SpcQ==",
-      "dev": true,
-      "requires": {
-        "color-support": "^1.1.0",
-        "debug": "^2.1.3",
-        "diff": "^1.3.2",
-        "escape-string-regexp": "^1.0.3",
-        "glob": "^7.0.5",
-        "readable-stream": "^2.1.5",
-        "tap-parser": "^8.0.0",
-        "tap-yaml": "0 || 1",
-        "unicode-length": "^1.0.0"
-      },
-      "dependencies": {
-        "tap-parser": {
-          "version": "8.1.0",
-          "resolved": "https://registry.npmjs.org/tap-parser/-/tap-parser-8.1.0.tgz",
-          "integrity": "sha512-GgOzgDwThYLxhVR83RbS1JUR1TxcT+jfZsrETgPAvFdr12lUOnuvrHOBaUQgpkAp6ZyeW6r2Nwd91t88M0ru3w==",
-          "dev": true,
-          "requires": {
-            "events-to-array": "^1.0.1",
-            "minipass": "^2.2.0",
-            "tap-yaml": "0 || 1"
-          }
-        }
-      }
-    },
-    "tap-parser": {
-      "version": "9.3.1",
-      "resolved": "https://registry.npmjs.org/tap-parser/-/tap-parser-9.3.1.tgz",
-      "integrity": "sha512-Y0805CxU7qWPeHGhx4xsYs8/IIJCSHxqXbKV3HRwKEYFNgfGgAxnjqWf0aZnTt2j7JZUPI7nqp8j5z7LnrTvfw==",
-      "dev": true,
-      "requires": {
-        "events-to-array": "^1.0.1",
-        "minipass": "^2.2.0",
-        "tap-yaml": "0 || 1"
-      }
-    },
-    "tap-yaml": {
-      "version": "0.3.0",
-      "resolved": "https://registry.npmjs.org/tap-yaml/-/tap-yaml-0.3.0.tgz",
-      "integrity": "sha512-t9H7AbSNSKnd+//cZO2icbO3rbN3XVMDsMnzvfE4+ubsAd7Cl+872QMLt5z/6ci7r2fIjXQlXkM83X9cwJbaxQ==",
-      "dev": true,
-      "requires": {
-        "yaml": "github:isaacs/yaml#built"
-      }
-    },
-    "tcompare": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/tcompare/-/tcompare-2.1.0.tgz",
-      "integrity": "sha512-TZXUj9dTNfbMh/+39nzGFJ2p5/VQRRO3AcHnErBPzY3VYr93NHBbP+3Rb8WxuSNXLkxmrg6lwr4OMGc5e7Gf8Q==",
-      "dev": true
-    },
-    "to-fast-properties": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-1.0.3.tgz",
-      "integrity": "sha1-uDVx+k2MJbguIxsG46MFXeTKGkc=",
-      "dev": true
-    },
-    "tough-cookie": {
-      "version": "2.4.3",
-      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.4.3.tgz",
-      "integrity": "sha512-Q5srk/4vDM54WJsJio3XNn6K2sCG+CQ8G5Wz6bZhRZoAe/+TxjWB/GlFAnYEbkYVlON9FMk/fE3h2RLpPXo4lQ==",
-      "dev": true,
-      "requires": {
-        "psl": "^1.1.24",
-        "punycode": "^1.4.1"
-      }
-    },
-    "treport": {
-      "version": "0.0.3",
-      "resolved": "https://registry.npmjs.org/treport/-/treport-0.0.3.tgz",
-      "integrity": "sha512-f9Q6CtUqFc/nzhb/ubWBzLH5JqcrdgQKGR3Fn2XuySgtncHXMxJJyPwlB97uqRXmBQj6A5/PAmh3nY9D06Hezg==",
-      "dev": true,
-      "requires": {
-        "cardinal": "^2.1.1",
-        "chalk": "^2.4.2",
-        "import-jsx": "^2.0.0",
-        "ink": "^2.0.0",
-        "ms": "^2.1.1",
-        "react": "^16.8.2",
-        "string-length": "^2.0.0",
-        "tap-parser": "^9.0.0",
-        "unicode-length": "^2.0.1"
-      },
-      "dependencies": {
-        "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"
-          }
-        },
-        "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"
-          }
-        },
-        "ms": {
-          "version": "2.1.1",
-          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.1.tgz",
-          "integrity": "sha512-tgp+dl5cGk28utYktBsrFqA7HKgrhgPsg6Z/EfhWI4gl1Hwq8B/GmY/0oXZ6nF8hDVesS/FpnYaD/kOWhYQvyg==",
-          "dev": true
-        },
-        "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
-        },
-        "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"
-          }
-        },
-        "unicode-length": {
-          "version": "2.0.1",
-          "resolved": "https://registry.npmjs.org/unicode-length/-/unicode-length-2.0.1.tgz",
-          "integrity": "sha1-hN3DCcIyNjX2QuhtRI6ersCEwEo=",
-          "dev": true,
-          "requires": {
-            "punycode": "^2.0.0",
-            "strip-ansi": "^3.0.1"
-          }
-        }
-      }
-    },
-    "trim-right": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/trim-right/-/trim-right-1.0.1.tgz",
-      "integrity": "sha1-yy4SAwZ+DI3h9hQJS5/kVwTqYAM=",
-      "dev": true
-    },
-    "trivial-deferred": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/trivial-deferred/-/trivial-deferred-1.0.1.tgz",
-      "integrity": "sha1-N21NKdlR1jaKb3oK6FwvTV4GWPM=",
-      "dev": true
-    },
-    "ts-node": {
-      "version": "8.0.3",
-      "resolved": "https://registry.npmjs.org/ts-node/-/ts-node-8.0.3.tgz",
-      "integrity": "sha512-2qayBA4vdtVRuDo11DEFSsD/SFsBXQBRZZhbRGSIkmYmVkWjULn/GGMdG10KVqkaGndljfaTD8dKjWgcejO8YA==",
-      "dev": true,
-      "requires": {
-        "arg": "^4.1.0",
-        "diff": "^3.1.0",
-        "make-error": "^1.1.1",
-        "source-map-support": "^0.5.6",
-        "yn": "^3.0.0"
-      },
-      "dependencies": {
-        "diff": {
-          "version": "3.5.0",
-          "resolved": "https://registry.npmjs.org/diff/-/diff-3.5.0.tgz",
-          "integrity": "sha512-A46qtFgd+g7pDZinpnwiRJtxbC1hpgf0uzP3iG89scHk0AUC7A1TGxf5OiiOUv/JMZR8GOt8hL900hV0bOy5xA==",
-          "dev": true
-        }
-      }
-    },
-    "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
-    },
-    "typescript": {
-      "version": "3.3.4000",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.3.4000.tgz",
-      "integrity": "sha512-jjOcCZvpkl2+z7JFn0yBOoLQyLoIkNZAs/fYJkUG6VKy6zLPHJGfQJYFHzibB6GJaF/8QrcECtlQ5cpvRHSMEA==",
-      "dev": true
-    },
-    "unicode-length": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/unicode-length/-/unicode-length-1.0.3.tgz",
-      "integrity": "sha1-Wtp6f+1RhBpBijKM8UlHisg1irs=",
-      "dev": true,
-      "requires": {
-        "punycode": "^1.3.2",
-        "strip-ansi": "^3.0.1"
-      }
-    },
-    "uri-js": {
-      "version": "4.2.2",
-      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.2.2.tgz",
-      "integrity": "sha512-KY9Frmirql91X2Qgjry0Wd4Y+YTdrdZheS8TFwvkbLWf/G5KNJDCh6pKL5OZctEW4+0Baa5idK2ZQuELRwPznQ==",
-      "dev": true,
-      "requires": {
-        "punycode": "^2.1.0"
-      },
-      "dependencies": {
-        "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
-        }
-      }
-    },
-    "util-deprecate": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
-      "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=",
-      "dev": true,
-      "optional": true
-    },
-    "uuid": {
-      "version": "3.3.2",
-      "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.3.2.tgz",
-      "integrity": "sha512-yXJmeNaw3DnnKAOKJE51sL/ZaYfWJRl1pK9dr19YFCu0ObS231AB1/LbqTKRAQ5kw8A90rA6fr4riOUpTZvQZA==",
-      "dev": true
-    },
-    "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"
-      }
-    },
-    "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"
-      }
-    },
-    "widest-line": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/widest-line/-/widest-line-2.0.1.tgz",
-      "integrity": "sha512-Ba5m9/Fa4Xt9eb2ELXt77JxVDV8w7qQrH0zS/TWSJdLyAwQjWoOzpzj5lwVftDz6n/EOu3tNACS84v509qwnJA==",
-      "dev": true,
-      "requires": {
-        "string-width": "^2.1.1"
-      }
-    },
-    "wrap-ansi": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-2.1.0.tgz",
-      "integrity": "sha1-2Pw9KE3QV5T+hJc8rs3Rz4JP3YU=",
-      "dev": true,
-      "requires": {
-        "string-width": "^1.0.1",
-        "strip-ansi": "^3.0.1"
-      },
-      "dependencies": {
-        "is-fullwidth-code-point": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz",
-          "integrity": "sha1-754xOG8DGn8NZDr4L95QxFfvAMs=",
-          "dev": true,
-          "requires": {
-            "number-is-nan": "^1.0.0"
-          }
-        },
-        "string-width": {
-          "version": "1.0.2",
-          "resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz",
-          "integrity": "sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=",
-          "dev": true,
-          "requires": {
-            "code-point-at": "^1.0.0",
-            "is-fullwidth-code-point": "^1.0.0",
-            "strip-ansi": "^3.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": "2.4.2",
-      "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-2.4.2.tgz",
-      "integrity": "sha512-s0b6vB3xIVRLWywa6X9TOMA7k9zio0TMOsl9ZnDkliA/cfJlpHXAscj0gbHVJiTdIuAYpIyqS5GW91fqm6gG5g==",
-      "dev": true,
-      "requires": {
-        "graceful-fs": "^4.1.11",
-        "imurmurhash": "^0.1.4",
-        "signal-exit": "^3.0.2"
-      }
-    },
-    "yallist": {
-      "version": "2.1.2",
-      "resolved": "https://registry.npmjs.org/yallist/-/yallist-2.1.2.tgz",
-      "integrity": "sha1-HBH5IY8HYImkfdUS+TxmmaaoHVI=",
-      "dev": true
-    },
-    "yaml": {
-      "version": "github:isaacs/yaml#bd3a3116f21910ab79635b535494609f8794084a",
-      "from": "github:isaacs/yaml#built",
-      "dev": true,
-      "requires": {
-        "@babel/runtime": "^7.3.4"
-      }
-    },
-    "yapool": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/yapool/-/yapool-1.0.0.tgz",
-      "integrity": "sha1-9pPymjFbUNmp2iZGp6ZkXJaYW2o=",
-      "dev": true
-    },
-    "yn": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/yn/-/yn-3.0.0.tgz",
-      "integrity": "sha512-+Wo/p5VRfxUgBUGy2j/6KX2mj9AYJWOHuhMjMcbBFc3y54o9/4buK1ksBvuiK01C3kby8DH9lSmJdSxw+4G/2Q==",
-      "dev": true
-    },
-    "yoga-layout-prebuilt": {
-      "version": "1.9.3",
-      "resolved": "https://registry.npmjs.org/yoga-layout-prebuilt/-/yoga-layout-prebuilt-1.9.3.tgz",
-      "integrity": "sha512-9SNQpwuEh2NucU83i2KMZnONVudZ86YNcFk9tq74YaqrQfgJWO3yB9uzH1tAg8iqh5c9F5j0wuyJ2z72wcum2w==",
-      "dev": true
-    }
-  }
-}
diff --git a/package.json b/package.json
index f6c1663d..f00c6bdd 100644
--- a/package.json
+++ b/package.json
@@ -1,28 +1,78 @@
 {
   "name": "semver",
-  "version": "5.7.0",
+  "version": "7.6.0",
   "description": "The semantic version parser used by npm.",
-  "main": "semver.js",
+  "main": "index.js",
   "scripts": {
     "test": "tap",
-    "preversion": "npm test",
-    "postversion": "npm publish",
-    "postpublish": "git push origin --all; git push origin --tags"
+    "snap": "tap",
+    "lint": "eslint \"**/*.{js,cjs,ts,mjs,jsx,tsx}\"",
+    "postlint": "template-oss-check",
+    "lintfix": "npm run lint -- --fix",
+    "posttest": "npm run lint",
+    "template-oss-apply": "template-oss-apply --force"
   },
   "devDependencies": {
-    "tap": "^13.0.0-rc.18"
+    "@npmcli/eslint-config": "^4.0.0",
+    "@npmcli/template-oss": "4.21.3",
+    "tap": "^16.0.0"
   },
   "license": "ISC",
-  "repository": "https://github.com/npm/node-semver",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/npm/node-semver.git"
+  },
   "bin": {
-    "semver": "./bin/semver"
+    "semver": "bin/semver.js"
   },
   "files": [
-    "bin",
-    "range.bnf",
-    "semver.js"
+    "bin/",
+    "lib/",
+    "classes/",
+    "functions/",
+    "internal/",
+    "ranges/",
+    "index.js",
+    "preload.js",
+    "range.bnf"
   ],
   "tap": {
-    "check-coverage": true
+    "timeout": 30,
+    "coverage-map": "map.js",
+    "nyc-arg": [
+      "--exclude",
+      "tap-snapshots/**"
+    ]
+  },
+  "engines": {
+    "node": ">=10"
+  },
+  "dependencies": {
+    "lru-cache": "^6.0.0"
+  },
+  "author": "GitHub Inc.",
+  "templateOSS": {
+    "//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.",
+    "version": "4.21.3",
+    "engines": ">=10",
+    "distPaths": [
+      "classes/",
+      "functions/",
+      "internal/",
+      "ranges/",
+      "index.js",
+      "preload.js",
+      "range.bnf"
+    ],
+    "allowPaths": [
+      "/classes/",
+      "/functions/",
+      "/internal/",
+      "/ranges/",
+      "/index.js",
+      "/preload.js",
+      "/range.bnf"
+    ],
+    "publish": "true"
   }
 }
diff --git a/preload.js b/preload.js
new file mode 100644
index 00000000..947cd4f7
--- /dev/null
+++ b/preload.js
@@ -0,0 +1,2 @@
+// XXX remove in v8 or beyond
+module.exports = require('./index.js')
diff --git a/ranges/gtr.js b/ranges/gtr.js
new file mode 100644
index 00000000..db7e3559
--- /dev/null
+++ b/ranges/gtr.js
@@ -0,0 +1,4 @@
+// Determine if version is greater than all the versions possible in the range.
+const outside = require('./outside')
+const gtr = (version, range, options) => outside(version, range, '>', options)
+module.exports = gtr
diff --git a/ranges/intersects.js b/ranges/intersects.js
new file mode 100644
index 00000000..e0e9b7ce
--- /dev/null
+++ b/ranges/intersects.js
@@ -0,0 +1,7 @@
+const Range = require('../classes/range')
+const intersects = (r1, r2, options) => {
+  r1 = new Range(r1, options)
+  r2 = new Range(r2, options)
+  return r1.intersects(r2, options)
+}
+module.exports = intersects
diff --git a/ranges/ltr.js b/ranges/ltr.js
new file mode 100644
index 00000000..528a885e
--- /dev/null
+++ b/ranges/ltr.js
@@ -0,0 +1,4 @@
+const outside = require('./outside')
+// Determine if version is less than all the versions possible in the range
+const ltr = (version, range, options) => outside(version, range, '<', options)
+module.exports = ltr
diff --git a/ranges/max-satisfying.js b/ranges/max-satisfying.js
new file mode 100644
index 00000000..6e3d993c
--- /dev/null
+++ b/ranges/max-satisfying.js
@@ -0,0 +1,25 @@
+const SemVer = require('../classes/semver')
+const Range = require('../classes/range')
+
+const maxSatisfying = (versions, range, options) => {
+  let max = null
+  let maxSV = null
+  let rangeObj = null
+  try {
+    rangeObj = new Range(range, options)
+  } catch (er) {
+    return null
+  }
+  versions.forEach((v) => {
+    if (rangeObj.test(v)) {
+      // satisfies(v, range, options)
+      if (!max || maxSV.compare(v) === -1) {
+        // compare(max, v, true)
+        max = v
+        maxSV = new SemVer(max, options)
+      }
+    }
+  })
+  return max
+}
+module.exports = maxSatisfying
diff --git a/ranges/min-satisfying.js b/ranges/min-satisfying.js
new file mode 100644
index 00000000..9b60974e
--- /dev/null
+++ b/ranges/min-satisfying.js
@@ -0,0 +1,24 @@
+const SemVer = require('../classes/semver')
+const Range = require('../classes/range')
+const minSatisfying = (versions, range, options) => {
+  let min = null
+  let minSV = null
+  let rangeObj = null
+  try {
+    rangeObj = new Range(range, options)
+  } catch (er) {
+    return null
+  }
+  versions.forEach((v) => {
+    if (rangeObj.test(v)) {
+      // satisfies(v, range, options)
+      if (!min || minSV.compare(v) === 1) {
+        // compare(min, v, true)
+        min = v
+        minSV = new SemVer(min, options)
+      }
+    }
+  })
+  return min
+}
+module.exports = minSatisfying
diff --git a/ranges/min-version.js b/ranges/min-version.js
new file mode 100644
index 00000000..350e1f78
--- /dev/null
+++ b/ranges/min-version.js
@@ -0,0 +1,61 @@
+const SemVer = require('../classes/semver')
+const Range = require('../classes/range')
+const gt = require('../functions/gt')
+
+const minVersion = (range, loose) => {
+  range = new Range(range, loose)
+
+  let minver = new SemVer('0.0.0')
+  if (range.test(minver)) {
+    return minver
+  }
+
+  minver = new SemVer('0.0.0-0')
+  if (range.test(minver)) {
+    return minver
+  }
+
+  minver = null
+  for (let i = 0; i < range.set.length; ++i) {
+    const comparators = range.set[i]
+
+    let setMin = null
+    comparators.forEach((comparator) => {
+      // Clone to avoid manipulating the comparator's semver object.
+      const compver = new SemVer(comparator.semver.version)
+      switch (comparator.operator) {
+        case '>':
+          if (compver.prerelease.length === 0) {
+            compver.patch++
+          } else {
+            compver.prerelease.push(0)
+          }
+          compver.raw = compver.format()
+          /* fallthrough */
+        case '':
+        case '>=':
+          if (!setMin || gt(compver, setMin)) {
+            setMin = compver
+          }
+          break
+        case '<':
+        case '<=':
+          /* Ignore maximum versions */
+          break
+        /* istanbul ignore next */
+        default:
+          throw new Error(`Unexpected operation: ${comparator.operator}`)
+      }
+    })
+    if (setMin && (!minver || gt(minver, setMin))) {
+      minver = setMin
+    }
+  }
+
+  if (minver && range.test(minver)) {
+    return minver
+  }
+
+  return null
+}
+module.exports = minVersion
diff --git a/ranges/outside.js b/ranges/outside.js
new file mode 100644
index 00000000..ae99b10a
--- /dev/null
+++ b/ranges/outside.js
@@ -0,0 +1,80 @@
+const SemVer = require('../classes/semver')
+const Comparator = require('../classes/comparator')
+const { ANY } = Comparator
+const Range = require('../classes/range')
+const satisfies = require('../functions/satisfies')
+const gt = require('../functions/gt')
+const lt = require('../functions/lt')
+const lte = require('../functions/lte')
+const gte = require('../functions/gte')
+
+const outside = (version, range, hilo, options) => {
+  version = new SemVer(version, options)
+  range = new Range(range, options)
+
+  let gtfn, ltefn, ltfn, comp, ecomp
+  switch (hilo) {
+    case '>':
+      gtfn = gt
+      ltefn = lte
+      ltfn = lt
+      comp = '>'
+      ecomp = '>='
+      break
+    case '<':
+      gtfn = lt
+      ltefn = gte
+      ltfn = gt
+      comp = '<'
+      ecomp = '<='
+      break
+    default:
+      throw new TypeError('Must provide a hilo val of "<" or ">"')
+  }
+
+  // If it satisfies the range it is not outside
+  if (satisfies(version, range, options)) {
+    return false
+  }
+
+  // From now on, variable terms are as if we're in "gtr" mode.
+  // but note that everything is flipped for the "ltr" function.
+
+  for (let i = 0; i < range.set.length; ++i) {
+    const comparators = range.set[i]
+
+    let high = null
+    let low = null
+
+    comparators.forEach((comparator) => {
+      if (comparator.semver === ANY) {
+        comparator = new Comparator('>=0.0.0')
+      }
+      high = high || comparator
+      low = low || comparator
+      if (gtfn(comparator.semver, high.semver, options)) {
+        high = comparator
+      } else if (ltfn(comparator.semver, low.semver, options)) {
+        low = comparator
+      }
+    })
+
+    // If the edge version comparator has a operator then our version
+    // isn't outside it
+    if (high.operator === comp || high.operator === ecomp) {
+      return false
+    }
+
+    // If the lowest version comparator has an operator and our version
+    // is less than it then it isn't higher than the range
+    if ((!low.operator || low.operator === comp) &&
+        ltefn(version, low.semver)) {
+      return false
+    } else if (low.operator === ecomp && ltfn(version, low.semver)) {
+      return false
+    }
+  }
+  return true
+}
+
+module.exports = outside
diff --git a/ranges/simplify.js b/ranges/simplify.js
new file mode 100644
index 00000000..618d5b62
--- /dev/null
+++ b/ranges/simplify.js
@@ -0,0 +1,47 @@
+// given a set of versions and a range, create a "simplified" range
+// that includes the same versions that the original range does
+// If the original range is shorter than the simplified one, return that.
+const satisfies = require('../functions/satisfies.js')
+const compare = require('../functions/compare.js')
+module.exports = (versions, range, options) => {
+  const set = []
+  let first = null
+  let prev = null
+  const v = versions.sort((a, b) => compare(a, b, options))
+  for (const version of v) {
+    const included = satisfies(version, range, options)
+    if (included) {
+      prev = version
+      if (!first) {
+        first = version
+      }
+    } else {
+      if (prev) {
+        set.push([first, prev])
+      }
+      prev = null
+      first = null
+    }
+  }
+  if (first) {
+    set.push([first, null])
+  }
+
+  const ranges = []
+  for (const [min, max] of set) {
+    if (min === max) {
+      ranges.push(min)
+    } else if (!max && min === v[0]) {
+      ranges.push('*')
+    } else if (!max) {
+      ranges.push(`>=${min}`)
+    } else if (min === v[0]) {
+      ranges.push(`<=${max}`)
+    } else {
+      ranges.push(`${min} - ${max}`)
+    }
+  }
+  const simplified = ranges.join(' || ')
+  const original = typeof range.raw === 'string' ? range.raw : String(range)
+  return simplified.length < original.length ? simplified : range
+}
diff --git a/ranges/subset.js b/ranges/subset.js
new file mode 100644
index 00000000..1e5c2683
--- /dev/null
+++ b/ranges/subset.js
@@ -0,0 +1,247 @@
+const Range = require('../classes/range.js')
+const Comparator = require('../classes/comparator.js')
+const { ANY } = Comparator
+const satisfies = require('../functions/satisfies.js')
+const compare = require('../functions/compare.js')
+
+// Complex range `r1 || r2 || ...` is a subset of `R1 || R2 || ...` iff:
+// - Every simple range `r1, r2, ...` is a null set, OR
+// - Every simple range `r1, r2, ...` which is not a null set is a subset of
+//   some `R1, R2, ...`
+//
+// Simple range `c1 c2 ...` is a subset of simple range `C1 C2 ...` iff:
+// - If c is only the ANY comparator
+//   - If C is only the ANY comparator, return true
+//   - Else if in prerelease mode, return false
+//   - else replace c with `[>=0.0.0]`
+// - If C is only the ANY comparator
+//   - if in prerelease mode, return true
+//   - else replace C with `[>=0.0.0]`
+// - Let EQ be the set of = comparators in c
+// - If EQ is more than one, return true (null set)
+// - Let GT be the highest > or >= comparator in c
+// - Let LT be the lowest < or <= comparator in c
+// - If GT and LT, and GT.semver > LT.semver, return true (null set)
+// - If any C is a = range, and GT or LT are set, return false
+// - If EQ
+//   - If GT, and EQ does not satisfy GT, return true (null set)
+//   - If LT, and EQ does not satisfy LT, return true (null set)
+//   - If EQ satisfies every C, return true
+//   - Else return false
+// - If GT
+//   - If GT.semver is lower than any > or >= comp in C, return false
+//   - If GT is >=, and GT.semver does not satisfy every C, return false
+//   - If GT.semver has a prerelease, and not in prerelease mode
+//     - If no C has a prerelease and the GT.semver tuple, return false
+// - If LT
+//   - If LT.semver is greater than any < or <= comp in C, return false
+//   - If LT is <=, and LT.semver does not satisfy every C, return false
+//   - If GT.semver has a prerelease, and not in prerelease mode
+//     - If no C has a prerelease and the LT.semver tuple, return false
+// - Else return true
+
+const subset = (sub, dom, options = {}) => {
+  if (sub === dom) {
+    return true
+  }
+
+  sub = new Range(sub, options)
+  dom = new Range(dom, options)
+  let sawNonNull = false
+
+  OUTER: for (const simpleSub of sub.set) {
+    for (const simpleDom of dom.set) {
+      const isSub = simpleSubset(simpleSub, simpleDom, options)
+      sawNonNull = sawNonNull || isSub !== null
+      if (isSub) {
+        continue OUTER
+      }
+    }
+    // the null set is a subset of everything, but null simple ranges in
+    // a complex range should be ignored.  so if we saw a non-null range,
+    // then we know this isn't a subset, but if EVERY simple range was null,
+    // then it is a subset.
+    if (sawNonNull) {
+      return false
+    }
+  }
+  return true
+}
+
+const minimumVersionWithPreRelease = [new Comparator('>=0.0.0-0')]
+const minimumVersion = [new Comparator('>=0.0.0')]
+
+const simpleSubset = (sub, dom, options) => {
+  if (sub === dom) {
+    return true
+  }
+
+  if (sub.length === 1 && sub[0].semver === ANY) {
+    if (dom.length === 1 && dom[0].semver === ANY) {
+      return true
+    } else if (options.includePrerelease) {
+      sub = minimumVersionWithPreRelease
+    } else {
+      sub = minimumVersion
+    }
+  }
+
+  if (dom.length === 1 && dom[0].semver === ANY) {
+    if (options.includePrerelease) {
+      return true
+    } else {
+      dom = minimumVersion
+    }
+  }
+
+  const eqSet = new Set()
+  let gt, lt
+  for (const c of sub) {
+    if (c.operator === '>' || c.operator === '>=') {
+      gt = higherGT(gt, c, options)
+    } else if (c.operator === '<' || c.operator === '<=') {
+      lt = lowerLT(lt, c, options)
+    } else {
+      eqSet.add(c.semver)
+    }
+  }
+
+  if (eqSet.size > 1) {
+    return null
+  }
+
+  let gtltComp
+  if (gt && lt) {
+    gtltComp = compare(gt.semver, lt.semver, options)
+    if (gtltComp > 0) {
+      return null
+    } else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<=')) {
+      return null
+    }
+  }
+
+  // will iterate one or zero times
+  for (const eq of eqSet) {
+    if (gt && !satisfies(eq, String(gt), options)) {
+      return null
+    }
+
+    if (lt && !satisfies(eq, String(lt), options)) {
+      return null
+    }
+
+    for (const c of dom) {
+      if (!satisfies(eq, String(c), options)) {
+        return false
+      }
+    }
+
+    return true
+  }
+
+  let higher, lower
+  let hasDomLT, hasDomGT
+  // if the subset has a prerelease, we need a comparator in the superset
+  // with the same tuple and a prerelease, or it's not a subset
+  let needDomLTPre = lt &&
+    !options.includePrerelease &&
+    lt.semver.prerelease.length ? lt.semver : false
+  let needDomGTPre = gt &&
+    !options.includePrerelease &&
+    gt.semver.prerelease.length ? gt.semver : false
+  // exception: <1.2.3-0 is the same as <1.2.3
+  if (needDomLTPre && needDomLTPre.prerelease.length === 1 &&
+      lt.operator === '<' && needDomLTPre.prerelease[0] === 0) {
+    needDomLTPre = false
+  }
+
+  for (const c of dom) {
+    hasDomGT = hasDomGT || c.operator === '>' || c.operator === '>='
+    hasDomLT = hasDomLT || c.operator === '<' || c.operator === '<='
+    if (gt) {
+      if (needDomGTPre) {
+        if (c.semver.prerelease && c.semver.prerelease.length &&
+            c.semver.major === needDomGTPre.major &&
+            c.semver.minor === needDomGTPre.minor &&
+            c.semver.patch === needDomGTPre.patch) {
+          needDomGTPre = false
+        }
+      }
+      if (c.operator === '>' || c.operator === '>=') {
+        higher = higherGT(gt, c, options)
+        if (higher === c && higher !== gt) {
+          return false
+        }
+      } else if (gt.operator === '>=' && !satisfies(gt.semver, String(c), options)) {
+        return false
+      }
+    }
+    if (lt) {
+      if (needDomLTPre) {
+        if (c.semver.prerelease && c.semver.prerelease.length &&
+            c.semver.major === needDomLTPre.major &&
+            c.semver.minor === needDomLTPre.minor &&
+            c.semver.patch === needDomLTPre.patch) {
+          needDomLTPre = false
+        }
+      }
+      if (c.operator === '<' || c.operator === '<=') {
+        lower = lowerLT(lt, c, options)
+        if (lower === c && lower !== lt) {
+          return false
+        }
+      } else if (lt.operator === '<=' && !satisfies(lt.semver, String(c), options)) {
+        return false
+      }
+    }
+    if (!c.operator && (lt || gt) && gtltComp !== 0) {
+      return false
+    }
+  }
+
+  // if there was a < or >, and nothing in the dom, then must be false
+  // UNLESS it was limited by another range in the other direction.
+  // Eg, >1.0.0 <1.0.1 is still a subset of <2.0.0
+  if (gt && hasDomLT && !lt && gtltComp !== 0) {
+    return false
+  }
+
+  if (lt && hasDomGT && !gt && gtltComp !== 0) {
+    return false
+  }
+
+  // we needed a prerelease range in a specific tuple, but didn't get one
+  // then this isn't a subset.  eg >=1.2.3-pre is not a subset of >=1.0.0,
+  // because it includes prereleases in the 1.2.3 tuple
+  if (needDomGTPre || needDomLTPre) {
+    return false
+  }
+
+  return true
+}
+
+// >=1.2.3 is lower than >1.2.3
+const higherGT = (a, b, options) => {
+  if (!a) {
+    return b
+  }
+  const comp = compare(a.semver, b.semver, options)
+  return comp > 0 ? a
+    : comp < 0 ? b
+    : b.operator === '>' && a.operator === '>=' ? b
+    : a
+}
+
+// <=1.2.3 is higher than <1.2.3
+const lowerLT = (a, b, options) => {
+  if (!a) {
+    return b
+  }
+  const comp = compare(a.semver, b.semver, options)
+  return comp < 0 ? a
+    : comp > 0 ? b
+    : b.operator === '<' && a.operator === '<=' ? b
+    : a
+}
+
+module.exports = subset
diff --git a/ranges/to-comparators.js b/ranges/to-comparators.js
new file mode 100644
index 00000000..6c8bc7e6
--- /dev/null
+++ b/ranges/to-comparators.js
@@ -0,0 +1,8 @@
+const Range = require('../classes/range')
+
+// Mostly just for testing and legacy API reasons
+const toComparators = (range, options) =>
+  new Range(range, options).set
+    .map(comp => comp.map(c => c.value).join(' ').trim().split(' '))
+
+module.exports = toComparators
diff --git a/ranges/valid.js b/ranges/valid.js
new file mode 100644
index 00000000..365f3568
--- /dev/null
+++ b/ranges/valid.js
@@ -0,0 +1,11 @@
+const Range = require('../classes/range')
+const validRange = (range, options) => {
+  try {
+    // Return '*' instead of '' so that truthiness works.
+    // This will throw if it's invalid anyway
+    return new Range(range, options).range || '*'
+  } catch (er) {
+    return null
+  }
+}
+module.exports = validRange
diff --git a/release-please-config.json b/release-please-config.json
new file mode 100644
index 00000000..559ef7d8
--- /dev/null
+++ b/release-please-config.json
@@ -0,0 +1,42 @@
+{
+  "group-pull-request-title-pattern": "chore: release ${version}",
+  "pull-request-title-pattern": "chore: release${component} ${version}",
+  "changelog-sections": [
+    {
+      "type": "feat",
+      "section": "Features",
+      "hidden": false,
+      "collapse": false
+    },
+    {
+      "type": "fix",
+      "section": "Bug Fixes",
+      "hidden": false,
+      "collapse": false
+    },
+    {
+      "type": "docs",
+      "section": "Documentation",
+      "hidden": false,
+      "collapse": false
+    },
+    {
+      "type": "deps",
+      "section": "Dependencies",
+      "hidden": false,
+      "collapse": false
+    },
+    {
+      "type": "chore",
+      "section": "Chores",
+      "hidden": false,
+      "collapse": false
+    }
+  ],
+  "packages": {
+    ".": {
+      "package-name": ""
+    }
+  },
+  "prerelease-type": "pre"
+}
diff --git a/semver.js b/semver.js
deleted file mode 100644
index d315d5d6..00000000
--- a/semver.js
+++ /dev/null
@@ -1,1483 +0,0 @@
-exports = module.exports = SemVer
-
-var debug
-/* istanbul ignore next */
-if (typeof process === 'object' &&
-    process.env &&
-    process.env.NODE_DEBUG &&
-    /\bsemver\b/i.test(process.env.NODE_DEBUG)) {
-  debug = function () {
-    var args = Array.prototype.slice.call(arguments, 0)
-    args.unshift('SEMVER')
-    console.log.apply(console, args)
-  }
-} else {
-  debug = function () {}
-}
-
-// Note: this is the semver.org version of the spec that it implements
-// Not necessarily the package version of this code.
-exports.SEMVER_SPEC_VERSION = '2.0.0'
-
-var MAX_LENGTH = 256
-var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||
-  /* istanbul ignore next */ 9007199254740991
-
-// Max safe segment length for coercion.
-var MAX_SAFE_COMPONENT_LENGTH = 16
-
-// The actual regexps go on exports.re
-var re = exports.re = []
-var src = exports.src = []
-var R = 0
-
-// The following Regular Expressions can be used for tokenizing,
-// validating, and parsing SemVer version strings.
-
-// ## Numeric Identifier
-// A single `0`, or a non-zero digit followed by zero or more digits.
-
-var NUMERICIDENTIFIER = R++
-src[NUMERICIDENTIFIER] = '0|[1-9]\\d*'
-var NUMERICIDENTIFIERLOOSE = R++
-src[NUMERICIDENTIFIERLOOSE] = '[0-9]+'
-
-// ## Non-numeric Identifier
-// Zero or more digits, followed by a letter or hyphen, and then zero or
-// more letters, digits, or hyphens.
-
-var NONNUMERICIDENTIFIER = R++
-src[NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*'
-
-// ## Main Version
-// Three dot-separated numeric identifiers.
-
-var MAINVERSION = R++
-src[MAINVERSION] = '(' + src[NUMERICIDENTIFIER] + ')\\.' +
-                   '(' + src[NUMERICIDENTIFIER] + ')\\.' +
-                   '(' + src[NUMERICIDENTIFIER] + ')'
-
-var MAINVERSIONLOOSE = R++
-src[MAINVERSIONLOOSE] = '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +
-                        '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +
-                        '(' + src[NUMERICIDENTIFIERLOOSE] + ')'
-
-// ## Pre-release Version Identifier
-// A numeric identifier, or a non-numeric identifier.
-
-var PRERELEASEIDENTIFIER = R++
-src[PRERELEASEIDENTIFIER] = '(?:' + src[NUMERICIDENTIFIER] +
-                            '|' + src[NONNUMERICIDENTIFIER] + ')'
-
-var PRERELEASEIDENTIFIERLOOSE = R++
-src[PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[NUMERICIDENTIFIERLOOSE] +
-                                 '|' + src[NONNUMERICIDENTIFIER] + ')'
-
-// ## Pre-release Version
-// Hyphen, followed by one or more dot-separated pre-release version
-// identifiers.
-
-var PRERELEASE = R++
-src[PRERELEASE] = '(?:-(' + src[PRERELEASEIDENTIFIER] +
-                  '(?:\\.' + src[PRERELEASEIDENTIFIER] + ')*))'
-
-var PRERELEASELOOSE = R++
-src[PRERELEASELOOSE] = '(?:-?(' + src[PRERELEASEIDENTIFIERLOOSE] +
-                       '(?:\\.' + src[PRERELEASEIDENTIFIERLOOSE] + ')*))'
-
-// ## Build Metadata Identifier
-// Any combination of digits, letters, or hyphens.
-
-var BUILDIDENTIFIER = R++
-src[BUILDIDENTIFIER] = '[0-9A-Za-z-]+'
-
-// ## Build Metadata
-// Plus sign, followed by one or more period-separated build metadata
-// identifiers.
-
-var BUILD = R++
-src[BUILD] = '(?:\\+(' + src[BUILDIDENTIFIER] +
-             '(?:\\.' + src[BUILDIDENTIFIER] + ')*))'
-
-// ## Full Version String
-// A main version, followed optionally by a pre-release version and
-// build metadata.
-
-// Note that the only major, minor, patch, and pre-release sections of
-// the version string are capturing groups.  The build metadata is not a
-// capturing group, because it should not ever be used in version
-// comparison.
-
-var FULL = R++
-var FULLPLAIN = 'v?' + src[MAINVERSION] +
-                src[PRERELEASE] + '?' +
-                src[BUILD] + '?'
-
-src[FULL] = '^' + FULLPLAIN + '$'
-
-// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
-// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
-// common in the npm registry.
-var LOOSEPLAIN = '[v=\\s]*' + src[MAINVERSIONLOOSE] +
-                 src[PRERELEASELOOSE] + '?' +
-                 src[BUILD] + '?'
-
-var LOOSE = R++
-src[LOOSE] = '^' + LOOSEPLAIN + '$'
-
-var GTLT = R++
-src[GTLT] = '((?:<|>)?=?)'
-
-// Something like "2.*" or "1.2.x".
-// Note that "x.x" is a valid xRange identifer, meaning "any version"
-// Only the first item is strictly required.
-var XRANGEIDENTIFIERLOOSE = R++
-src[XRANGEIDENTIFIERLOOSE] = src[NUMERICIDENTIFIERLOOSE] + '|x|X|\\*'
-var XRANGEIDENTIFIER = R++
-src[XRANGEIDENTIFIER] = src[NUMERICIDENTIFIER] + '|x|X|\\*'
-
-var XRANGEPLAIN = R++
-src[XRANGEPLAIN] = '[v=\\s]*(' + src[XRANGEIDENTIFIER] + ')' +
-                   '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
-                   '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
-                   '(?:' + src[PRERELEASE] + ')?' +
-                   src[BUILD] + '?' +
-                   ')?)?'
-
-var XRANGEPLAINLOOSE = R++
-src[XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
-                        '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
-                        '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
-                        '(?:' + src[PRERELEASELOOSE] + ')?' +
-                        src[BUILD] + '?' +
-                        ')?)?'
-
-var XRANGE = R++
-src[XRANGE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAIN] + '$'
-var XRANGELOOSE = R++
-src[XRANGELOOSE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAINLOOSE] + '$'
-
-// Coercion.
-// Extract anything that could conceivably be a part of a valid semver
-var COERCE = R++
-src[COERCE] = '(?:^|[^\\d])' +
-              '(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' +
-              '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
-              '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
-              '(?:$|[^\\d])'
-
-// Tilde ranges.
-// Meaning is "reasonably at or greater than"
-var LONETILDE = R++
-src[LONETILDE] = '(?:~>?)'
-
-var TILDETRIM = R++
-src[TILDETRIM] = '(\\s*)' + src[LONETILDE] + '\\s+'
-re[TILDETRIM] = new RegExp(src[TILDETRIM], 'g')
-var tildeTrimReplace = '$1~'
-
-var TILDE = R++
-src[TILDE] = '^' + src[LONETILDE] + src[XRANGEPLAIN] + '$'
-var TILDELOOSE = R++
-src[TILDELOOSE] = '^' + src[LONETILDE] + src[XRANGEPLAINLOOSE] + '$'
-
-// Caret ranges.
-// Meaning is "at least and backwards compatible with"
-var LONECARET = R++
-src[LONECARET] = '(?:\\^)'
-
-var CARETTRIM = R++
-src[CARETTRIM] = '(\\s*)' + src[LONECARET] + '\\s+'
-re[CARETTRIM] = new RegExp(src[CARETTRIM], 'g')
-var caretTrimReplace = '$1^'
-
-var CARET = R++
-src[CARET] = '^' + src[LONECARET] + src[XRANGEPLAIN] + '$'
-var CARETLOOSE = R++
-src[CARETLOOSE] = '^' + src[LONECARET] + src[XRANGEPLAINLOOSE] + '$'
-
-// A simple gt/lt/eq thing, or just "" to indicate "any version"
-var COMPARATORLOOSE = R++
-src[COMPARATORLOOSE] = '^' + src[GTLT] + '\\s*(' + LOOSEPLAIN + ')$|^$'
-var COMPARATOR = R++
-src[COMPARATOR] = '^' + src[GTLT] + '\\s*(' + FULLPLAIN + ')$|^$'
-
-// An expression to strip any whitespace between the gtlt and the thing
-// it modifies, so that `> 1.2.3` ==> `>1.2.3`
-var COMPARATORTRIM = R++
-src[COMPARATORTRIM] = '(\\s*)' + src[GTLT] +
-                      '\\s*(' + LOOSEPLAIN + '|' + src[XRANGEPLAIN] + ')'
-
-// this one has to use the /g flag
-re[COMPARATORTRIM] = new RegExp(src[COMPARATORTRIM], 'g')
-var comparatorTrimReplace = '$1$2$3'
-
-// Something like `1.2.3 - 1.2.4`
-// Note that these all use the loose form, because they'll be
-// checked against either the strict or loose comparator form
-// later.
-var HYPHENRANGE = R++
-src[HYPHENRANGE] = '^\\s*(' + src[XRANGEPLAIN] + ')' +
-                   '\\s+-\\s+' +
-                   '(' + src[XRANGEPLAIN] + ')' +
-                   '\\s*$'
-
-var HYPHENRANGELOOSE = R++
-src[HYPHENRANGELOOSE] = '^\\s*(' + src[XRANGEPLAINLOOSE] + ')' +
-                        '\\s+-\\s+' +
-                        '(' + src[XRANGEPLAINLOOSE] + ')' +
-                        '\\s*$'
-
-// Star ranges basically just allow anything at all.
-var STAR = R++
-src[STAR] = '(<|>)?=?\\s*\\*'
-
-// Compile to actual regexp objects.
-// All are flag-free, unless they were created above with a flag.
-for (var i = 0; i < R; i++) {
-  debug(i, src[i])
-  if (!re[i]) {
-    re[i] = new RegExp(src[i])
-  }
-}
-
-exports.parse = parse
-function parse (version, options) {
-  if (!options || typeof options !== 'object') {
-    options = {
-      loose: !!options,
-      includePrerelease: false
-    }
-  }
-
-  if (version instanceof SemVer) {
-    return version
-  }
-
-  if (typeof version !== 'string') {
-    return null
-  }
-
-  if (version.length > MAX_LENGTH) {
-    return null
-  }
-
-  var r = options.loose ? re[LOOSE] : re[FULL]
-  if (!r.test(version)) {
-    return null
-  }
-
-  try {
-    return new SemVer(version, options)
-  } catch (er) {
-    return null
-  }
-}
-
-exports.valid = valid
-function valid (version, options) {
-  var v = parse(version, options)
-  return v ? v.version : null
-}
-
-exports.clean = clean
-function clean (version, options) {
-  var s = parse(version.trim().replace(/^[=v]+/, ''), options)
-  return s ? s.version : null
-}
-
-exports.SemVer = SemVer
-
-function SemVer (version, options) {
-  if (!options || typeof options !== 'object') {
-    options = {
-      loose: !!options,
-      includePrerelease: false
-    }
-  }
-  if (version instanceof SemVer) {
-    if (version.loose === options.loose) {
-      return version
-    } else {
-      version = version.version
-    }
-  } else if (typeof version !== 'string') {
-    throw new TypeError('Invalid Version: ' + version)
-  }
-
-  if (version.length > MAX_LENGTH) {
-    throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters')
-  }
-
-  if (!(this instanceof SemVer)) {
-    return new SemVer(version, options)
-  }
-
-  debug('SemVer', version, options)
-  this.options = options
-  this.loose = !!options.loose
-
-  var m = version.trim().match(options.loose ? re[LOOSE] : re[FULL])
-
-  if (!m) {
-    throw new TypeError('Invalid Version: ' + version)
-  }
-
-  this.raw = version
-
-  // these are actually numbers
-  this.major = +m[1]
-  this.minor = +m[2]
-  this.patch = +m[3]
-
-  if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
-    throw new TypeError('Invalid major version')
-  }
-
-  if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
-    throw new TypeError('Invalid minor version')
-  }
-
-  if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
-    throw new TypeError('Invalid patch version')
-  }
-
-  // numberify any prerelease numeric ids
-  if (!m[4]) {
-    this.prerelease = []
-  } else {
-    this.prerelease = m[4].split('.').map(function (id) {
-      if (/^[0-9]+$/.test(id)) {
-        var num = +id
-        if (num >= 0 && num < MAX_SAFE_INTEGER) {
-          return num
-        }
-      }
-      return id
-    })
-  }
-
-  this.build = m[5] ? m[5].split('.') : []
-  this.format()
-}
-
-SemVer.prototype.format = function () {
-  this.version = this.major + '.' + this.minor + '.' + this.patch
-  if (this.prerelease.length) {
-    this.version += '-' + this.prerelease.join('.')
-  }
-  return this.version
-}
-
-SemVer.prototype.toString = function () {
-  return this.version
-}
-
-SemVer.prototype.compare = function (other) {
-  debug('SemVer.compare', this.version, this.options, other)
-  if (!(other instanceof SemVer)) {
-    other = new SemVer(other, this.options)
-  }
-
-  return this.compareMain(other) || this.comparePre(other)
-}
-
-SemVer.prototype.compareMain = function (other) {
-  if (!(other instanceof SemVer)) {
-    other = new SemVer(other, this.options)
-  }
-
-  return compareIdentifiers(this.major, other.major) ||
-         compareIdentifiers(this.minor, other.minor) ||
-         compareIdentifiers(this.patch, other.patch)
-}
-
-SemVer.prototype.comparePre = function (other) {
-  if (!(other instanceof SemVer)) {
-    other = new SemVer(other, this.options)
-  }
-
-  // NOT having a prerelease is > having one
-  if (this.prerelease.length && !other.prerelease.length) {
-    return -1
-  } else if (!this.prerelease.length && other.prerelease.length) {
-    return 1
-  } else if (!this.prerelease.length && !other.prerelease.length) {
-    return 0
-  }
-
-  var i = 0
-  do {
-    var a = this.prerelease[i]
-    var b = other.prerelease[i]
-    debug('prerelease compare', i, a, b)
-    if (a === undefined && b === undefined) {
-      return 0
-    } else if (b === undefined) {
-      return 1
-    } else if (a === undefined) {
-      return -1
-    } else if (a === b) {
-      continue
-    } else {
-      return compareIdentifiers(a, b)
-    }
-  } while (++i)
-}
-
-// preminor will bump the version up to the next minor release, and immediately
-// down to pre-release. premajor and prepatch work the same way.
-SemVer.prototype.inc = function (release, identifier) {
-  switch (release) {
-    case 'premajor':
-      this.prerelease.length = 0
-      this.patch = 0
-      this.minor = 0
-      this.major++
-      this.inc('pre', identifier)
-      break
-    case 'preminor':
-      this.prerelease.length = 0
-      this.patch = 0
-      this.minor++
-      this.inc('pre', identifier)
-      break
-    case 'prepatch':
-      // If this is already a prerelease, it will bump to the next version
-      // drop any prereleases that might already exist, since they are not
-      // relevant at this point.
-      this.prerelease.length = 0
-      this.inc('patch', identifier)
-      this.inc('pre', identifier)
-      break
-    // If the input is a non-prerelease version, this acts the same as
-    // prepatch.
-    case 'prerelease':
-      if (this.prerelease.length === 0) {
-        this.inc('patch', identifier)
-      }
-      this.inc('pre', identifier)
-      break
-
-    case 'major':
-      // If this is a pre-major version, bump up to the same major version.
-      // Otherwise increment major.
-      // 1.0.0-5 bumps to 1.0.0
-      // 1.1.0 bumps to 2.0.0
-      if (this.minor !== 0 ||
-          this.patch !== 0 ||
-          this.prerelease.length === 0) {
-        this.major++
-      }
-      this.minor = 0
-      this.patch = 0
-      this.prerelease = []
-      break
-    case 'minor':
-      // If this is a pre-minor version, bump up to the same minor version.
-      // Otherwise increment minor.
-      // 1.2.0-5 bumps to 1.2.0
-      // 1.2.1 bumps to 1.3.0
-      if (this.patch !== 0 || this.prerelease.length === 0) {
-        this.minor++
-      }
-      this.patch = 0
-      this.prerelease = []
-      break
-    case 'patch':
-      // If this is not a pre-release version, it will increment the patch.
-      // If it is a pre-release it will bump up to the same patch version.
-      // 1.2.0-5 patches to 1.2.0
-      // 1.2.0 patches to 1.2.1
-      if (this.prerelease.length === 0) {
-        this.patch++
-      }
-      this.prerelease = []
-      break
-    // This probably shouldn't be used publicly.
-    // 1.0.0 "pre" would become 1.0.0-0 which is the wrong direction.
-    case 'pre':
-      if (this.prerelease.length === 0) {
-        this.prerelease = [0]
-      } else {
-        var i = this.prerelease.length
-        while (--i >= 0) {
-          if (typeof this.prerelease[i] === 'number') {
-            this.prerelease[i]++
-            i = -2
-          }
-        }
-        if (i === -1) {
-          // didn't increment anything
-          this.prerelease.push(0)
-        }
-      }
-      if (identifier) {
-        // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
-        // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
-        if (this.prerelease[0] === identifier) {
-          if (isNaN(this.prerelease[1])) {
-            this.prerelease = [identifier, 0]
-          }
-        } else {
-          this.prerelease = [identifier, 0]
-        }
-      }
-      break
-
-    default:
-      throw new Error('invalid increment argument: ' + release)
-  }
-  this.format()
-  this.raw = this.version
-  return this
-}
-
-exports.inc = inc
-function inc (version, release, loose, identifier) {
-  if (typeof (loose) === 'string') {
-    identifier = loose
-    loose = undefined
-  }
-
-  try {
-    return new SemVer(version, loose).inc(release, identifier).version
-  } catch (er) {
-    return null
-  }
-}
-
-exports.diff = diff
-function diff (version1, version2) {
-  if (eq(version1, version2)) {
-    return null
-  } else {
-    var v1 = parse(version1)
-    var v2 = parse(version2)
-    var prefix = ''
-    if (v1.prerelease.length || v2.prerelease.length) {
-      prefix = 'pre'
-      var defaultResult = 'prerelease'
-    }
-    for (var key in v1) {
-      if (key === 'major' || key === 'minor' || key === 'patch') {
-        if (v1[key] !== v2[key]) {
-          return prefix + key
-        }
-      }
-    }
-    return defaultResult // may be undefined
-  }
-}
-
-exports.compareIdentifiers = compareIdentifiers
-
-var numeric = /^[0-9]+$/
-function compareIdentifiers (a, b) {
-  var anum = numeric.test(a)
-  var bnum = numeric.test(b)
-
-  if (anum && bnum) {
-    a = +a
-    b = +b
-  }
-
-  return a === b ? 0
-    : (anum && !bnum) ? -1
-    : (bnum && !anum) ? 1
-    : a < b ? -1
-    : 1
-}
-
-exports.rcompareIdentifiers = rcompareIdentifiers
-function rcompareIdentifiers (a, b) {
-  return compareIdentifiers(b, a)
-}
-
-exports.major = major
-function major (a, loose) {
-  return new SemVer(a, loose).major
-}
-
-exports.minor = minor
-function minor (a, loose) {
-  return new SemVer(a, loose).minor
-}
-
-exports.patch = patch
-function patch (a, loose) {
-  return new SemVer(a, loose).patch
-}
-
-exports.compare = compare
-function compare (a, b, loose) {
-  return new SemVer(a, loose).compare(new SemVer(b, loose))
-}
-
-exports.compareLoose = compareLoose
-function compareLoose (a, b) {
-  return compare(a, b, true)
-}
-
-exports.rcompare = rcompare
-function rcompare (a, b, loose) {
-  return compare(b, a, loose)
-}
-
-exports.sort = sort
-function sort (list, loose) {
-  return list.sort(function (a, b) {
-    return exports.compare(a, b, loose)
-  })
-}
-
-exports.rsort = rsort
-function rsort (list, loose) {
-  return list.sort(function (a, b) {
-    return exports.rcompare(a, b, loose)
-  })
-}
-
-exports.gt = gt
-function gt (a, b, loose) {
-  return compare(a, b, loose) > 0
-}
-
-exports.lt = lt
-function lt (a, b, loose) {
-  return compare(a, b, loose) < 0
-}
-
-exports.eq = eq
-function eq (a, b, loose) {
-  return compare(a, b, loose) === 0
-}
-
-exports.neq = neq
-function neq (a, b, loose) {
-  return compare(a, b, loose) !== 0
-}
-
-exports.gte = gte
-function gte (a, b, loose) {
-  return compare(a, b, loose) >= 0
-}
-
-exports.lte = lte
-function lte (a, b, loose) {
-  return compare(a, b, loose) <= 0
-}
-
-exports.cmp = cmp
-function cmp (a, op, b, loose) {
-  switch (op) {
-    case '===':
-      if (typeof a === 'object')
-        a = a.version
-      if (typeof b === 'object')
-        b = b.version
-      return a === b
-
-    case '!==':
-      if (typeof a === 'object')
-        a = a.version
-      if (typeof b === 'object')
-        b = b.version
-      return a !== b
-
-    case '':
-    case '=':
-    case '==':
-      return eq(a, b, loose)
-
-    case '!=':
-      return neq(a, b, loose)
-
-    case '>':
-      return gt(a, b, loose)
-
-    case '>=':
-      return gte(a, b, loose)
-
-    case '<':
-      return lt(a, b, loose)
-
-    case '<=':
-      return lte(a, b, loose)
-
-    default:
-      throw new TypeError('Invalid operator: ' + op)
-  }
-}
-
-exports.Comparator = Comparator
-function Comparator (comp, options) {
-  if (!options || typeof options !== 'object') {
-    options = {
-      loose: !!options,
-      includePrerelease: false
-    }
-  }
-
-  if (comp instanceof Comparator) {
-    if (comp.loose === !!options.loose) {
-      return comp
-    } else {
-      comp = comp.value
-    }
-  }
-
-  if (!(this instanceof Comparator)) {
-    return new Comparator(comp, options)
-  }
-
-  debug('comparator', comp, options)
-  this.options = options
-  this.loose = !!options.loose
-  this.parse(comp)
-
-  if (this.semver === ANY) {
-    this.value = ''
-  } else {
-    this.value = this.operator + this.semver.version
-  }
-
-  debug('comp', this)
-}
-
-var ANY = {}
-Comparator.prototype.parse = function (comp) {
-  var r = this.options.loose ? re[COMPARATORLOOSE] : re[COMPARATOR]
-  var m = comp.match(r)
-
-  if (!m) {
-    throw new TypeError('Invalid comparator: ' + comp)
-  }
-
-  this.operator = m[1]
-  if (this.operator === '=') {
-    this.operator = ''
-  }
-
-  // if it literally is just '>' or '' then allow anything.
-  if (!m[2]) {
-    this.semver = ANY
-  } else {
-    this.semver = new SemVer(m[2], this.options.loose)
-  }
-}
-
-Comparator.prototype.toString = function () {
-  return this.value
-}
-
-Comparator.prototype.test = function (version) {
-  debug('Comparator.test', version, this.options.loose)
-
-  if (this.semver === ANY) {
-    return true
-  }
-
-  if (typeof version === 'string') {
-    version = new SemVer(version, this.options)
-  }
-
-  return cmp(version, this.operator, this.semver, this.options)
-}
-
-Comparator.prototype.intersects = function (comp, options) {
-  if (!(comp instanceof Comparator)) {
-    throw new TypeError('a Comparator is required')
-  }
-
-  if (!options || typeof options !== 'object') {
-    options = {
-      loose: !!options,
-      includePrerelease: false
-    }
-  }
-
-  var rangeTmp
-
-  if (this.operator === '') {
-    rangeTmp = new Range(comp.value, options)
-    return satisfies(this.value, rangeTmp, options)
-  } else if (comp.operator === '') {
-    rangeTmp = new Range(this.value, options)
-    return satisfies(comp.semver, rangeTmp, options)
-  }
-
-  var sameDirectionIncreasing =
-    (this.operator === '>=' || this.operator === '>') &&
-    (comp.operator === '>=' || comp.operator === '>')
-  var sameDirectionDecreasing =
-    (this.operator === '<=' || this.operator === '<') &&
-    (comp.operator === '<=' || comp.operator === '<')
-  var sameSemVer = this.semver.version === comp.semver.version
-  var differentDirectionsInclusive =
-    (this.operator === '>=' || this.operator === '<=') &&
-    (comp.operator === '>=' || comp.operator === '<=')
-  var oppositeDirectionsLessThan =
-    cmp(this.semver, '<', comp.semver, options) &&
-    ((this.operator === '>=' || this.operator === '>') &&
-    (comp.operator === '<=' || comp.operator === '<'))
-  var oppositeDirectionsGreaterThan =
-    cmp(this.semver, '>', comp.semver, options) &&
-    ((this.operator === '<=' || this.operator === '<') &&
-    (comp.operator === '>=' || comp.operator === '>'))
-
-  return sameDirectionIncreasing || sameDirectionDecreasing ||
-    (sameSemVer && differentDirectionsInclusive) ||
-    oppositeDirectionsLessThan || oppositeDirectionsGreaterThan
-}
-
-exports.Range = Range
-function Range (range, options) {
-  if (!options || typeof options !== 'object') {
-    options = {
-      loose: !!options,
-      includePrerelease: false
-    }
-  }
-
-  if (range instanceof Range) {
-    if (range.loose === !!options.loose &&
-        range.includePrerelease === !!options.includePrerelease) {
-      return range
-    } else {
-      return new Range(range.raw, options)
-    }
-  }
-
-  if (range instanceof Comparator) {
-    return new Range(range.value, options)
-  }
-
-  if (!(this instanceof Range)) {
-    return new Range(range, options)
-  }
-
-  this.options = options
-  this.loose = !!options.loose
-  this.includePrerelease = !!options.includePrerelease
-
-  // First, split based on boolean or ||
-  this.raw = range
-  this.set = range.split(/\s*\|\|\s*/).map(function (range) {
-    return this.parseRange(range.trim())
-  }, this).filter(function (c) {
-    // throw out any that are not relevant for whatever reason
-    return c.length
-  })
-
-  if (!this.set.length) {
-    throw new TypeError('Invalid SemVer Range: ' + range)
-  }
-
-  this.format()
-}
-
-Range.prototype.format = function () {
-  this.range = this.set.map(function (comps) {
-    return comps.join(' ').trim()
-  }).join('||').trim()
-  return this.range
-}
-
-Range.prototype.toString = function () {
-  return this.range
-}
-
-Range.prototype.parseRange = function (range) {
-  var loose = this.options.loose
-  range = range.trim()
-  // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
-  var hr = loose ? re[HYPHENRANGELOOSE] : re[HYPHENRANGE]
-  range = range.replace(hr, hyphenReplace)
-  debug('hyphen replace', range)
-  // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
-  range = range.replace(re[COMPARATORTRIM], comparatorTrimReplace)
-  debug('comparator trim', range, re[COMPARATORTRIM])
-
-  // `~ 1.2.3` => `~1.2.3`
-  range = range.replace(re[TILDETRIM], tildeTrimReplace)
-
-  // `^ 1.2.3` => `^1.2.3`
-  range = range.replace(re[CARETTRIM], caretTrimReplace)
-
-  // normalize spaces
-  range = range.split(/\s+/).join(' ')
-
-  // At this point, the range is completely trimmed and
-  // ready to be split into comparators.
-
-  var compRe = loose ? re[COMPARATORLOOSE] : re[COMPARATOR]
-  var set = range.split(' ').map(function (comp) {
-    return parseComparator(comp, this.options)
-  }, this).join(' ').split(/\s+/)
-  if (this.options.loose) {
-    // in loose mode, throw out any that are not valid comparators
-    set = set.filter(function (comp) {
-      return !!comp.match(compRe)
-    })
-  }
-  set = set.map(function (comp) {
-    return new Comparator(comp, this.options)
-  }, this)
-
-  return set
-}
-
-Range.prototype.intersects = function (range, options) {
-  if (!(range instanceof Range)) {
-    throw new TypeError('a Range is required')
-  }
-
-  return this.set.some(function (thisComparators) {
-    return thisComparators.every(function (thisComparator) {
-      return range.set.some(function (rangeComparators) {
-        return rangeComparators.every(function (rangeComparator) {
-          return thisComparator.intersects(rangeComparator, options)
-        })
-      })
-    })
-  })
-}
-
-// Mostly just for testing and legacy API reasons
-exports.toComparators = toComparators
-function toComparators (range, options) {
-  return new Range(range, options).set.map(function (comp) {
-    return comp.map(function (c) {
-      return c.value
-    }).join(' ').trim().split(' ')
-  })
-}
-
-// comprised of xranges, tildes, stars, and gtlt's at this point.
-// already replaced the hyphen ranges
-// turn into a set of JUST comparators.
-function parseComparator (comp, options) {
-  debug('comp', comp, options)
-  comp = replaceCarets(comp, options)
-  debug('caret', comp)
-  comp = replaceTildes(comp, options)
-  debug('tildes', comp)
-  comp = replaceXRanges(comp, options)
-  debug('xrange', comp)
-  comp = replaceStars(comp, options)
-  debug('stars', comp)
-  return comp
-}
-
-function isX (id) {
-  return !id || id.toLowerCase() === 'x' || id === '*'
-}
-
-// ~, ~> --> * (any, kinda silly)
-// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0
-// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0
-// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0
-// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0
-// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0
-function replaceTildes (comp, options) {
-  return comp.trim().split(/\s+/).map(function (comp) {
-    return replaceTilde(comp, options)
-  }).join(' ')
-}
-
-function replaceTilde (comp, options) {
-  var r = options.loose ? re[TILDELOOSE] : re[TILDE]
-  return comp.replace(r, function (_, M, m, p, pr) {
-    debug('tilde', comp, _, M, m, p, pr)
-    var ret
-
-    if (isX(M)) {
-      ret = ''
-    } else if (isX(m)) {
-      ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'
-    } else if (isX(p)) {
-      // ~1.2 == >=1.2.0 <1.3.0
-      ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'
-    } else if (pr) {
-      debug('replaceTilde pr', pr)
-      ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
-            ' <' + M + '.' + (+m + 1) + '.0'
-    } else {
-      // ~1.2.3 == >=1.2.3 <1.3.0
-      ret = '>=' + M + '.' + m + '.' + p +
-            ' <' + M + '.' + (+m + 1) + '.0'
-    }
-
-    debug('tilde return', ret)
-    return ret
-  })
-}
-
-// ^ --> * (any, kinda silly)
-// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0
-// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0
-// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0
-// ^1.2.3 --> >=1.2.3 <2.0.0
-// ^1.2.0 --> >=1.2.0 <2.0.0
-function replaceCarets (comp, options) {
-  return comp.trim().split(/\s+/).map(function (comp) {
-    return replaceCaret(comp, options)
-  }).join(' ')
-}
-
-function replaceCaret (comp, options) {
-  debug('caret', comp, options)
-  var r = options.loose ? re[CARETLOOSE] : re[CARET]
-  return comp.replace(r, function (_, M, m, p, pr) {
-    debug('caret', comp, _, M, m, p, pr)
-    var ret
-
-    if (isX(M)) {
-      ret = ''
-    } else if (isX(m)) {
-      ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'
-    } else if (isX(p)) {
-      if (M === '0') {
-        ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'
-      } else {
-        ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0'
-      }
-    } else if (pr) {
-      debug('replaceCaret pr', pr)
-      if (M === '0') {
-        if (m === '0') {
-          ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
-                ' <' + M + '.' + m + '.' + (+p + 1)
-        } else {
-          ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
-                ' <' + M + '.' + (+m + 1) + '.0'
-        }
-      } else {
-        ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
-              ' <' + (+M + 1) + '.0.0'
-      }
-    } else {
-      debug('no pr')
-      if (M === '0') {
-        if (m === '0') {
-          ret = '>=' + M + '.' + m + '.' + p +
-                ' <' + M + '.' + m + '.' + (+p + 1)
-        } else {
-          ret = '>=' + M + '.' + m + '.' + p +
-                ' <' + M + '.' + (+m + 1) + '.0'
-        }
-      } else {
-        ret = '>=' + M + '.' + m + '.' + p +
-              ' <' + (+M + 1) + '.0.0'
-      }
-    }
-
-    debug('caret return', ret)
-    return ret
-  })
-}
-
-function replaceXRanges (comp, options) {
-  debug('replaceXRanges', comp, options)
-  return comp.split(/\s+/).map(function (comp) {
-    return replaceXRange(comp, options)
-  }).join(' ')
-}
-
-function replaceXRange (comp, options) {
-  comp = comp.trim()
-  var r = options.loose ? re[XRANGELOOSE] : re[XRANGE]
-  return comp.replace(r, function (ret, gtlt, M, m, p, pr) {
-    debug('xRange', comp, ret, gtlt, M, m, p, pr)
-    var xM = isX(M)
-    var xm = xM || isX(m)
-    var xp = xm || isX(p)
-    var anyX = xp
-
-    if (gtlt === '=' && anyX) {
-      gtlt = ''
-    }
-
-    if (xM) {
-      if (gtlt === '>' || gtlt === '<') {
-        // nothing is allowed
-        ret = '<0.0.0'
-      } else {
-        // nothing is forbidden
-        ret = '*'
-      }
-    } else if (gtlt && anyX) {
-      // we know patch is an x, because we have any x at all.
-      // replace X with 0
-      if (xm) {
-        m = 0
-      }
-      p = 0
-
-      if (gtlt === '>') {
-        // >1 => >=2.0.0
-        // >1.2 => >=1.3.0
-        // >1.2.3 => >= 1.2.4
-        gtlt = '>='
-        if (xm) {
-          M = +M + 1
-          m = 0
-          p = 0
-        } else {
-          m = +m + 1
-          p = 0
-        }
-      } else if (gtlt === '<=') {
-        // <=0.7.x is actually <0.8.0, since any 0.7.x should
-        // pass.  Similarly, <=7.x is actually <8.0.0, etc.
-        gtlt = '<'
-        if (xm) {
-          M = +M + 1
-        } else {
-          m = +m + 1
-        }
-      }
-
-      ret = gtlt + M + '.' + m + '.' + p
-    } else if (xm) {
-      ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'
-    } else if (xp) {
-      ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'
-    }
-
-    debug('xRange return', ret)
-
-    return ret
-  })
-}
-
-// Because * is AND-ed with everything else in the comparator,
-// and '' means "any version", just remove the *s entirely.
-function replaceStars (comp, options) {
-  debug('replaceStars', comp, options)
-  // Looseness is ignored here.  star is always as loose as it gets!
-  return comp.trim().replace(re[STAR], '')
-}
-
-// This function is passed to string.replace(re[HYPHENRANGE])
-// M, m, patch, prerelease, build
-// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
-// 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do
-// 1.2 - 3.4 => >=1.2.0 <3.5.0
-function hyphenReplace ($0,
-  from, fM, fm, fp, fpr, fb,
-  to, tM, tm, tp, tpr, tb) {
-  if (isX(fM)) {
-    from = ''
-  } else if (isX(fm)) {
-    from = '>=' + fM + '.0.0'
-  } else if (isX(fp)) {
-    from = '>=' + fM + '.' + fm + '.0'
-  } else {
-    from = '>=' + from
-  }
-
-  if (isX(tM)) {
-    to = ''
-  } else if (isX(tm)) {
-    to = '<' + (+tM + 1) + '.0.0'
-  } else if (isX(tp)) {
-    to = '<' + tM + '.' + (+tm + 1) + '.0'
-  } else if (tpr) {
-    to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr
-  } else {
-    to = '<=' + to
-  }
-
-  return (from + ' ' + to).trim()
-}
-
-// if ANY of the sets match ALL of its comparators, then pass
-Range.prototype.test = function (version) {
-  if (!version) {
-    return false
-  }
-
-  if (typeof version === 'string') {
-    version = new SemVer(version, this.options)
-  }
-
-  for (var i = 0; i < this.set.length; i++) {
-    if (testSet(this.set[i], version, this.options)) {
-      return true
-    }
-  }
-  return false
-}
-
-function testSet (set, version, options) {
-  for (var i = 0; i < set.length; i++) {
-    if (!set[i].test(version)) {
-      return false
-    }
-  }
-
-  if (version.prerelease.length && !options.includePrerelease) {
-    // Find the set of versions that are allowed to have prereleases
-    // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
-    // That should allow `1.2.3-pr.2` to pass.
-    // However, `1.2.4-alpha.notready` should NOT be allowed,
-    // even though it's within the range set by the comparators.
-    for (i = 0; i < set.length; i++) {
-      debug(set[i].semver)
-      if (set[i].semver === ANY) {
-        continue
-      }
-
-      if (set[i].semver.prerelease.length > 0) {
-        var allowed = set[i].semver
-        if (allowed.major === version.major &&
-            allowed.minor === version.minor &&
-            allowed.patch === version.patch) {
-          return true
-        }
-      }
-    }
-
-    // Version has a -pre, but it's not one of the ones we like.
-    return false
-  }
-
-  return true
-}
-
-exports.satisfies = satisfies
-function satisfies (version, range, options) {
-  try {
-    range = new Range(range, options)
-  } catch (er) {
-    return false
-  }
-  return range.test(version)
-}
-
-exports.maxSatisfying = maxSatisfying
-function maxSatisfying (versions, range, options) {
-  var max = null
-  var maxSV = null
-  try {
-    var rangeObj = new Range(range, options)
-  } catch (er) {
-    return null
-  }
-  versions.forEach(function (v) {
-    if (rangeObj.test(v)) {
-      // satisfies(v, range, options)
-      if (!max || maxSV.compare(v) === -1) {
-        // compare(max, v, true)
-        max = v
-        maxSV = new SemVer(max, options)
-      }
-    }
-  })
-  return max
-}
-
-exports.minSatisfying = minSatisfying
-function minSatisfying (versions, range, options) {
-  var min = null
-  var minSV = null
-  try {
-    var rangeObj = new Range(range, options)
-  } catch (er) {
-    return null
-  }
-  versions.forEach(function (v) {
-    if (rangeObj.test(v)) {
-      // satisfies(v, range, options)
-      if (!min || minSV.compare(v) === 1) {
-        // compare(min, v, true)
-        min = v
-        minSV = new SemVer(min, options)
-      }
-    }
-  })
-  return min
-}
-
-exports.minVersion = minVersion
-function minVersion (range, loose) {
-  range = new Range(range, loose)
-
-  var minver = new SemVer('0.0.0')
-  if (range.test(minver)) {
-    return minver
-  }
-
-  minver = new SemVer('0.0.0-0')
-  if (range.test(minver)) {
-    return minver
-  }
-
-  minver = null
-  for (var i = 0; i < range.set.length; ++i) {
-    var comparators = range.set[i]
-
-    comparators.forEach(function (comparator) {
-      // Clone to avoid manipulating the comparator's semver object.
-      var compver = new SemVer(comparator.semver.version)
-      switch (comparator.operator) {
-        case '>':
-          if (compver.prerelease.length === 0) {
-            compver.patch++
-          } else {
-            compver.prerelease.push(0)
-          }
-          compver.raw = compver.format()
-          /* fallthrough */
-        case '':
-        case '>=':
-          if (!minver || gt(minver, compver)) {
-            minver = compver
-          }
-          break
-        case '<':
-        case '<=':
-          /* Ignore maximum versions */
-          break
-        /* istanbul ignore next */
-        default:
-          throw new Error('Unexpected operation: ' + comparator.operator)
-      }
-    })
-  }
-
-  if (minver && range.test(minver)) {
-    return minver
-  }
-
-  return null
-}
-
-exports.validRange = validRange
-function validRange (range, options) {
-  try {
-    // Return '*' instead of '' so that truthiness works.
-    // This will throw if it's invalid anyway
-    return new Range(range, options).range || '*'
-  } catch (er) {
-    return null
-  }
-}
-
-// Determine if version is less than all the versions possible in the range
-exports.ltr = ltr
-function ltr (version, range, options) {
-  return outside(version, range, '<', options)
-}
-
-// Determine if version is greater than all the versions possible in the range.
-exports.gtr = gtr
-function gtr (version, range, options) {
-  return outside(version, range, '>', options)
-}
-
-exports.outside = outside
-function outside (version, range, hilo, options) {
-  version = new SemVer(version, options)
-  range = new Range(range, options)
-
-  var gtfn, ltefn, ltfn, comp, ecomp
-  switch (hilo) {
-    case '>':
-      gtfn = gt
-      ltefn = lte
-      ltfn = lt
-      comp = '>'
-      ecomp = '>='
-      break
-    case '<':
-      gtfn = lt
-      ltefn = gte
-      ltfn = gt
-      comp = '<'
-      ecomp = '<='
-      break
-    default:
-      throw new TypeError('Must provide a hilo val of "<" or ">"')
-  }
-
-  // If it satisifes the range it is not outside
-  if (satisfies(version, range, options)) {
-    return false
-  }
-
-  // From now on, variable terms are as if we're in "gtr" mode.
-  // but note that everything is flipped for the "ltr" function.
-
-  for (var i = 0; i < range.set.length; ++i) {
-    var comparators = range.set[i]
-
-    var high = null
-    var low = null
-
-    comparators.forEach(function (comparator) {
-      if (comparator.semver === ANY) {
-        comparator = new Comparator('>=0.0.0')
-      }
-      high = high || comparator
-      low = low || comparator
-      if (gtfn(comparator.semver, high.semver, options)) {
-        high = comparator
-      } else if (ltfn(comparator.semver, low.semver, options)) {
-        low = comparator
-      }
-    })
-
-    // If the edge version comparator has a operator then our version
-    // isn't outside it
-    if (high.operator === comp || high.operator === ecomp) {
-      return false
-    }
-
-    // If the lowest version comparator has an operator and our version
-    // is less than it then it isn't higher than the range
-    if ((!low.operator || low.operator === comp) &&
-        ltefn(version, low.semver)) {
-      return false
-    } else if (low.operator === ecomp && ltfn(version, low.semver)) {
-      return false
-    }
-  }
-  return true
-}
-
-exports.prerelease = prerelease
-function prerelease (version, options) {
-  var parsed = parse(version, options)
-  return (parsed && parsed.prerelease.length) ? parsed.prerelease : null
-}
-
-exports.intersects = intersects
-function intersects (r1, r2, options) {
-  r1 = new Range(r1, options)
-  r2 = new Range(r2, options)
-  return r1.intersects(r2)
-}
-
-exports.coerce = coerce
-function coerce (version) {
-  if (version instanceof SemVer) {
-    return version
-  }
-
-  if (typeof version !== 'string') {
-    return null
-  }
-
-  var match = version.match(re[COERCE])
-
-  if (match == null) {
-    return null
-  }
-
-  return parse(match[1] +
-    '.' + (match[2] || '0') +
-    '.' + (match[3] || '0'))
-}
diff --git a/tap-snapshots/test/bin/semver.js.test.cjs b/tap-snapshots/test/bin/semver.js.test.cjs
new file mode 100644
index 00000000..e820ca47
--- /dev/null
+++ b/tap-snapshots/test/bin/semver.js.test.cjs
@@ -0,0 +1,477 @@
+/* IMPORTANT
+ * This snapshot file is auto-generated, but designed for humans.
+ * It should be checked into source control and tracked carefully.
+ * Re-generate by setting TAP_SNAPSHOT=1 and running tests.
+ * Make sure to inspect the output below.  Do not ignore changes!
+ */
+'use strict'
+exports[`test/bin/semver.js TAP coercing > 1.2.3.4.5.6 -c --rtl --ltr 1`] = `
+Object {
+  "code": 0,
+  "err": "",
+  "out": "1.2.3\\n",
+  "signal": null,
+}
+`
+
+exports[`test/bin/semver.js TAP coercing > 1.2.3.4.5.6 -c --rtl 1`] = `
+Object {
+  "code": 0,
+  "err": "",
+  "out": "4.5.6\\n",
+  "signal": null,
+}
+`
+
+exports[`test/bin/semver.js TAP coercing > 1.2.3.4.5.6 -c 1`] = `
+Object {
+  "code": 0,
+  "err": "",
+  "out": "1.2.3\\n",
+  "signal": null,
+}
+`
+
+exports[`test/bin/semver.js TAP coercing > not a version -c 1`] = `
+Object {
+  "code": 1,
+  "err": "",
+  "out": "",
+  "signal": null,
+}
+`
+
+exports[`test/bin/semver.js TAP coercing > not a version 1.2.3 -c 1`] = `
+Object {
+  "code": 0,
+  "err": "",
+  "out": "1.2.3\\n",
+  "signal": null,
+}
+`
+
+exports[`test/bin/semver.js TAP help output > (no args) 1`] = `
+Object {
+  "code": 0,
+  "err": "",
+  "out": String(
+    SemVer @@VERSION@@
+    
+    A JavaScript implementation of the https://semver.org/ specification
+    Copyright Isaac Z. Schlueter
+    
+    Usage: semver [options] <version> [<version> [...]]
+    Prints valid versions sorted by SemVer precedence
+    
+    Options:
+    -r --range <range>
+            Print versions that match the specified range.
+    
+    -i --increment [<level>]
+            Increment a version by the specified level.  Level can
+            be one of: major, minor, patch, premajor, preminor,
+            prepatch, or prerelease.  Default level is 'patch'.
+            Only one version may be specified.
+    
+    --preid <identifier>
+            Identifier to be used to prefix premajor, preminor,
+            prepatch or prerelease version increments.
+    
+    -l --loose
+            Interpret versions and ranges loosely
+    
+    -p --include-prerelease
+            Always include prerelease versions in range matching
+    
+    -c --coerce
+            Coerce a string into SemVer if possible
+            (does not imply --loose)
+    
+    --rtl
+            Coerce version strings right to left
+    
+    --ltr
+            Coerce version strings left to right (default)
+    
+    -n <base>
+            Base number to be used for the prerelease identifier.
+            Can be either 0 or 1, or false to omit the number altogether.
+            Defaults to 0.
+    
+    Program exits successfully if any valid version satisfies
+    all supplied ranges, and prints all satisfying versions.
+    
+    If no satisfying versions are found, then exits failure.
+    
+    Versions are printed in ascending order, so supplying
+    multiple versions to the utility will just sort them.
+    
+  ),
+  "signal": null,
+}
+`
+
+exports[`test/bin/semver.js TAP help output > --help 1`] = `
+Object {
+  "code": 0,
+  "err": "",
+  "out": String(
+    SemVer @@VERSION@@
+    
+    A JavaScript implementation of the https://semver.org/ specification
+    Copyright Isaac Z. Schlueter
+    
+    Usage: semver [options] <version> [<version> [...]]
+    Prints valid versions sorted by SemVer precedence
+    
+    Options:
+    -r --range <range>
+            Print versions that match the specified range.
+    
+    -i --increment [<level>]
+            Increment a version by the specified level.  Level can
+            be one of: major, minor, patch, premajor, preminor,
+            prepatch, or prerelease.  Default level is 'patch'.
+            Only one version may be specified.
+    
+    --preid <identifier>
+            Identifier to be used to prefix premajor, preminor,
+            prepatch or prerelease version increments.
+    
+    -l --loose
+            Interpret versions and ranges loosely
+    
+    -p --include-prerelease
+            Always include prerelease versions in range matching
+    
+    -c --coerce
+            Coerce a string into SemVer if possible
+            (does not imply --loose)
+    
+    --rtl
+            Coerce version strings right to left
+    
+    --ltr
+            Coerce version strings left to right (default)
+    
+    -n <base>
+            Base number to be used for the prerelease identifier.
+            Can be either 0 or 1, or false to omit the number altogether.
+            Defaults to 0.
+    
+    Program exits successfully if any valid version satisfies
+    all supplied ranges, and prints all satisfying versions.
+    
+    If no satisfying versions are found, then exits failure.
+    
+    Versions are printed in ascending order, so supplying
+    multiple versions to the utility will just sort them.
+    
+  ),
+  "signal": null,
+}
+`
+
+exports[`test/bin/semver.js TAP help output > -? 1`] = `
+Object {
+  "code": 0,
+  "err": "",
+  "out": String(
+    SemVer @@VERSION@@
+    
+    A JavaScript implementation of the https://semver.org/ specification
+    Copyright Isaac Z. Schlueter
+    
+    Usage: semver [options] <version> [<version> [...]]
+    Prints valid versions sorted by SemVer precedence
+    
+    Options:
+    -r --range <range>
+            Print versions that match the specified range.
+    
+    -i --increment [<level>]
+            Increment a version by the specified level.  Level can
+            be one of: major, minor, patch, premajor, preminor,
+            prepatch, or prerelease.  Default level is 'patch'.
+            Only one version may be specified.
+    
+    --preid <identifier>
+            Identifier to be used to prefix premajor, preminor,
+            prepatch or prerelease version increments.
+    
+    -l --loose
+            Interpret versions and ranges loosely
+    
+    -p --include-prerelease
+            Always include prerelease versions in range matching
+    
+    -c --coerce
+            Coerce a string into SemVer if possible
+            (does not imply --loose)
+    
+    --rtl
+            Coerce version strings right to left
+    
+    --ltr
+            Coerce version strings left to right (default)
+    
+    -n <base>
+            Base number to be used for the prerelease identifier.
+            Can be either 0 or 1, or false to omit the number altogether.
+            Defaults to 0.
+    
+    Program exits successfully if any valid version satisfies
+    all supplied ranges, and prints all satisfying versions.
+    
+    If no satisfying versions are found, then exits failure.
+    
+    Versions are printed in ascending order, so supplying
+    multiple versions to the utility will just sort them.
+    
+  ),
+  "signal": null,
+}
+`
+
+exports[`test/bin/semver.js TAP help output > -h 1`] = `
+Object {
+  "code": 0,
+  "err": "",
+  "out": String(
+    SemVer @@VERSION@@
+    
+    A JavaScript implementation of the https://semver.org/ specification
+    Copyright Isaac Z. Schlueter
+    
+    Usage: semver [options] <version> [<version> [...]]
+    Prints valid versions sorted by SemVer precedence
+    
+    Options:
+    -r --range <range>
+            Print versions that match the specified range.
+    
+    -i --increment [<level>]
+            Increment a version by the specified level.  Level can
+            be one of: major, minor, patch, premajor, preminor,
+            prepatch, or prerelease.  Default level is 'patch'.
+            Only one version may be specified.
+    
+    --preid <identifier>
+            Identifier to be used to prefix premajor, preminor,
+            prepatch or prerelease version increments.
+    
+    -l --loose
+            Interpret versions and ranges loosely
+    
+    -p --include-prerelease
+            Always include prerelease versions in range matching
+    
+    -c --coerce
+            Coerce a string into SemVer if possible
+            (does not imply --loose)
+    
+    --rtl
+            Coerce version strings right to left
+    
+    --ltr
+            Coerce version strings left to right (default)
+    
+    -n <base>
+            Base number to be used for the prerelease identifier.
+            Can be either 0 or 1, or false to omit the number altogether.
+            Defaults to 0.
+    
+    Program exits successfully if any valid version satisfies
+    all supplied ranges, and prints all satisfying versions.
+    
+    If no satisfying versions are found, then exits failure.
+    
+    Versions are printed in ascending order, so supplying
+    multiple versions to the utility will just sort them.
+    
+  ),
+  "signal": null,
+}
+`
+
+exports[`test/bin/semver.js TAP inc tests > -i 1.2.3 1`] = `
+Object {
+  "code": 0,
+  "err": "",
+  "out": "1.2.4\\n",
+  "signal": null,
+}
+`
+
+exports[`test/bin/semver.js TAP inc tests > -i major 1.0.0 1`] = `
+Object {
+  "code": 0,
+  "err": "",
+  "out": "2.0.0\\n",
+  "signal": null,
+}
+`
+
+exports[`test/bin/semver.js TAP inc tests > -i major 1.0.0 1.0.1 1`] = `
+Object {
+  "code": 1,
+  "err": "--inc can only be used on a single version with no range\\n",
+  "out": "",
+  "signal": null,
+}
+`
+
+exports[`test/bin/semver.js TAP inc tests > -i premajor 1.0.0 --preid=beta -n 1 1`] = `
+Object {
+  "code": 0,
+  "err": "",
+  "out": "2.0.0-beta.1\\n",
+  "signal": null,
+}
+`
+
+exports[`test/bin/semver.js TAP inc tests > -i premajor 1.0.0 --preid=beta -n false 1`] = `
+Object {
+  "code": 0,
+  "err": "",
+  "out": "2.0.0-beta\\n",
+  "signal": null,
+}
+`
+
+exports[`test/bin/semver.js TAP inc tests > -i premajor 1.0.0 --preid=beta 1`] = `
+Object {
+  "code": 0,
+  "err": "",
+  "out": "2.0.0-beta.0\\n",
+  "signal": null,
+}
+`
+
+exports[`test/bin/semver.js TAP sorting and filtering > 1.2.3 -v 3.2.1 --version 2.3.4 -rv 1`] = `
+Object {
+  "code": 0,
+  "err": "",
+  "out": String(
+    3.2.1
+    2.3.4
+    1.2.3
+    
+  ),
+  "signal": null,
+}
+`
+
+exports[`test/bin/semver.js TAP sorting and filtering > 1.2.3 -v 3.2.1 --version 2.3.4 1`] = `
+Object {
+  "code": 0,
+  "err": "",
+  "out": String(
+    1.2.3
+    2.3.4
+    3.2.1
+    
+  ),
+  "signal": null,
+}
+`
+
+exports[`test/bin/semver.js TAP sorting and filtering > 1.2.3 3.2.1 -r 2.x 1`] = `
+Object {
+  "code": 1,
+  "err": "",
+  "out": "",
+  "signal": null,
+}
+`
+
+exports[`test/bin/semver.js TAP sorting and filtering > 1.2.3 3.2.1 -r 2.x 2.3.4 1`] = `
+Object {
+  "code": 0,
+  "err": "",
+  "out": "2.3.4\\n",
+  "signal": null,
+}
+`
+
+exports[`test/bin/semver.js TAP sorting and filtering > 1.2.3 3.2.1 2.3.4 1`] = `
+Object {
+  "code": 0,
+  "err": "",
+  "out": String(
+    1.2.3
+    2.3.4
+    3.2.1
+    
+  ),
+  "signal": null,
+}
+`
+
+exports[`test/bin/semver.js TAP sorting and filtering > 1.2.3 3.2.1 2.3.4 2.3.4-beta 1`] = `
+Object {
+  "code": 0,
+  "err": "",
+  "out": String(
+    1.2.3
+    2.3.4-beta
+    2.3.4
+    3.2.1
+    
+  ),
+  "signal": null,
+}
+`
+
+exports[`test/bin/semver.js TAP sorting and filtering > 1.2.3 3.2.1 2.3.4 2.3.4-beta 2.0.0asdf -r 2.x -p 1`] = `
+Object {
+  "code": 0,
+  "err": "",
+  "out": String(
+    2.3.4-beta
+    2.3.4
+    
+  ),
+  "signal": null,
+}
+`
+
+exports[`test/bin/semver.js TAP sorting and filtering > 1.2.3 3.2.1 2.3.4 2.3.4-beta 2.0.0asdf -r 2.x 1`] = `
+Object {
+  "code": 0,
+  "err": "",
+  "out": "2.3.4\\n",
+  "signal": null,
+}
+`
+
+exports[`test/bin/semver.js TAP sorting and filtering > 1.2.3foo 1.2.3-bar -l 1`] = `
+Object {
+  "code": 0,
+  "err": "",
+  "out": "1.2.3-bar\\n",
+  "signal": null,
+}
+`
+
+exports[`test/bin/semver.js TAP sorting and filtering > 1.2.3foo 1.2.3-bar 1`] = `
+Object {
+  "code": 0,
+  "err": "",
+  "out": "1.2.3-bar\\n",
+  "signal": null,
+}
+`
+
+exports[`test/bin/semver.js TAP sorting and filtering > 3.2.1 2.3.4 2.3.4-beta 2.0.0asdf -r 2.x -p -l 1`] = `
+Object {
+  "code": 0,
+  "err": "",
+  "out": String(
+    2.3.4-beta
+    2.3.4
+    
+  ),
+  "signal": null,
+}
+`
diff --git a/test/big-numbers.js b/test/big-numbers.js
deleted file mode 100644
index 779d521b..00000000
--- a/test/big-numbers.js
+++ /dev/null
@@ -1,31 +0,0 @@
-var test = require('tap').test
-var semver = require('../')
-
-test('long version is too long', function (t) {
-  var v = '1.2.' + new Array(256).join('1')
-  t.throws(function () {
-    new semver.SemVer(v) // eslint-disable-line no-new
-  })
-  t.equal(semver.valid(v, false), null)
-  t.equal(semver.valid(v, true), null)
-  t.equal(semver.inc(v, 'patch'), null)
-  t.end()
-})
-
-test('big number is like too long version', function (t) {
-  var v = '1.2.' + new Array(100).join('1')
-  t.throws(function () {
-    new semver.SemVer(v) // eslint-disable-line no-new
-  })
-  t.equal(semver.valid(v, false), null)
-  t.equal(semver.valid(v, true), null)
-  t.equal(semver.inc(v, 'patch'), null)
-  t.end()
-})
-
-test('parsing null does not throw', function (t) {
-  t.equal(semver.parse(null), null)
-  t.equal(semver.parse({}), null)
-  t.equal(semver.parse(new semver.SemVer('1.2.3')).version, '1.2.3')
-  t.end()
-})
diff --git a/test/bin/semver.js b/test/bin/semver.js
new file mode 100644
index 00000000..262ca380
--- /dev/null
+++ b/test/bin/semver.js
@@ -0,0 +1,82 @@
+'use strict'
+const t = require('tap')
+
+const thisVersion = require('../../package.json').version
+t.cleanSnapshot = str => str.split(thisVersion).join('@@VERSION@@')
+
+const spawn = require('child_process').spawn
+const bin = require.resolve('../../bin/semver')
+const run = args => new Promise((resolve, reject) => {
+  const c = spawn(process.execPath, [bin].concat(args))
+  c.on('error', reject)
+  const out = []
+  const err = []
+  c.stdout.setEncoding('utf-8')
+  c.stdout.on('data', chunk => out.push(chunk))
+  c.stderr.setEncoding('utf-8')
+  c.stderr.on('data', chunk => err.push(chunk))
+  c.on('close', (code, signal) => {
+    resolve({
+      out: out.join(''),
+      err: err.join(''),
+      code: code,
+      signal: signal,
+    })
+  })
+})
+
+t.test('inc tests', t => Promise.all([
+  ['-i', 'major', '1.0.0'],
+  ['-i', 'major', '1.0.0', '1.0.1'],
+  ['-i', 'premajor', '1.0.0', '--preid=beta'],
+  ['-i', 'premajor', '1.0.0', '--preid=beta', '-n', '1'],
+  ['-i', 'premajor', '1.0.0', '--preid=beta', '-n', 'false'],
+  ['-i', '1.2.3'],
+].map(args => t.resolveMatchSnapshot(run(args), args.join(' ')))))
+
+t.test('help output', t => Promise.all([
+  ['-h'],
+  ['-?'],
+  ['--help'],
+  [],
+].map(h => t.resolveMatchSnapshot(run(h), h[0] || '(no args)'))))
+
+t.test('sorting and filtering', t => Promise.all([
+  ['1.2.3', '3.2.1', '2.3.4'],
+  ['1.2.3', '3.2.1', '2.3.4', '2.3.4-beta'],
+  ['1.2.3', '-v', '3.2.1', '--version', '2.3.4'],
+  ['1.2.3', '-v', '3.2.1', '--version', '2.3.4', '-rv'],
+  ['1.2.3foo', '1.2.3-bar'],
+  ['1.2.3foo', '1.2.3-bar', '-l'],
+  ['1.2.3', '3.2.1', '-r', '2.x', '2.3.4'],
+  ['1.2.3', '3.2.1', '2.3.4', '2.3.4-beta', '2.0.0asdf', '-r', '2.x'],
+  ['1.2.3', '3.2.1', '2.3.4', '2.3.4-beta', '2.0.0asdf', '-r', '2.x', '-p'],
+  ['3.2.1', '2.3.4', '2.3.4-beta', '2.0.0asdf', '-r', '2.x', '-p', '-l'],
+  ['1.2.3', '3.2.1', '-r', '2.x'],
+].map(args => t.resolveMatchSnapshot(run(args), args.join(' ')))))
+
+t.test('coercing', t => Promise.all([
+  ['1.2.3.4.5.6', '-c'],
+  ['1.2.3.4.5.6', '-c', '--rtl'],
+  ['1.2.3.4.5.6', '-c', '--rtl', '--ltr'],
+  ['not a version', '1.2.3', '-c'],
+  ['not a version', '-c'],
+].map(args => t.resolveMatchSnapshot(run(args), args.join(' ')))))
+
+t.test('args with equals', t => Promise.all([
+  [['--version', '1.2.3'], '1.2.3'],
+  [['--range', '1'], ['1.2.3'], ['2.3.4'], '1.2.3'],
+  [['--increment', 'major'], ['1.0.0'], '2.0.0'],
+  [['--increment', 'premajor'], ['--preid', 'beta'], ['1.0.0'], '2.0.0-beta.0'],
+].map(async (args) => {
+  const expected = args.pop()
+  const equals = args.map((a) => a.join('='))
+  const spaces = args.reduce((acc, a) => acc.concat(a), [])
+  const res1 = await run(equals)
+  const res2 = await run(spaces)
+  t.equal(res1.signal, null)
+  t.equal(res1.code, 0)
+  t.equal(res1.err, '')
+  t.equal(res1.out.trim(), expected)
+  t.strictSame(res1, res2, args.join(' '))
+})))
diff --git a/test/classes/comparator.js b/test/classes/comparator.js
new file mode 100644
index 00000000..209a024b
--- /dev/null
+++ b/test/classes/comparator.js
@@ -0,0 +1,63 @@
+const { test } = require('tap')
+const Comparator = require('../../classes/comparator')
+const comparatorIntersection = require('../fixtures/comparator-intersection.js')
+
+test('comparator testing', t => {
+  const c = new Comparator('>=1.2.3')
+  t.ok(c.test('1.2.4'))
+  const c2 = new Comparator(c)
+  t.ok(c2.test('1.2.4'))
+  const c3 = new Comparator(c, true)
+  t.ok(c3.test('1.2.4'))
+  // test an invalid version, should not throw
+  const c4 = new Comparator(c)
+  t.notOk(c4.test('not a version string'))
+  t.end()
+})
+
+test('tostrings', (t) => {
+  t.equal(new Comparator('>= v1.2.3').toString(), '>=1.2.3')
+  t.end()
+})
+
+test('intersect comparators', (t) => {
+  t.plan(comparatorIntersection.length)
+  comparatorIntersection.forEach(([c0, c1, expect, includePrerelease]) =>
+    t.test(`${c0} ${c1} ${expect}`, t => {
+      const comp0 = new Comparator(c0)
+      const comp1 = new Comparator(c1)
+
+      t.equal(comp0.intersects(comp1, { includePrerelease }), expect,
+        `${c0} intersects ${c1}`)
+
+      t.equal(comp1.intersects(comp0, { includePrerelease }), expect,
+        `${c1} intersects ${c0}`)
+      t.end()
+    }))
+})
+
+test('intersect demands another comparator', t => {
+  const c = new Comparator('>=1.2.3')
+  t.throws(() => c.intersects(), new TypeError('a Comparator is required'))
+  t.end()
+})
+
+test('ANY matches anything', t => {
+  const c = new Comparator('')
+  t.ok(c.test('1.2.3'), 'ANY matches anything')
+  const c1 = new Comparator('>=1.2.3')
+  const ANY = Comparator.ANY
+  t.ok(c1.test(ANY), 'anything matches ANY')
+  t.end()
+})
+
+test('invalid comparator parse throws', t => {
+  t.throws(() => new Comparator('foo bar baz'),
+    new TypeError('Invalid comparator: foo bar baz'))
+  t.end()
+})
+
+test('= is ignored', t => {
+  t.match(new Comparator('=1.2.3'), new Comparator('1.2.3'))
+  t.end()
+})
diff --git a/test/classes/index.js b/test/classes/index.js
new file mode 100644
index 00000000..519d1573
--- /dev/null
+++ b/test/classes/index.js
@@ -0,0 +1,6 @@
+const t = require('tap')
+t.same(require('../../classes'), {
+  SemVer: require('../../classes/semver'),
+  Range: require('../../classes/range'),
+  Comparator: require('../../classes/comparator'),
+}, 'export all classes at semver/classes')
diff --git a/test/classes/range.js b/test/classes/range.js
new file mode 100644
index 00000000..24686adf
--- /dev/null
+++ b/test/classes/range.js
@@ -0,0 +1,107 @@
+const { test } = require('tap')
+const Range = require('../../classes/range')
+const Comparator = require('../../classes/comparator')
+const rangeIntersection = require('../fixtures/range-intersection.js')
+
+const rangeInclude = require('../fixtures/range-include.js')
+const rangeExclude = require('../fixtures/range-exclude.js')
+const rangeParse = require('../fixtures/range-parse.js')
+
+test('range tests', t => {
+  t.plan(rangeInclude.length)
+  rangeInclude.forEach(([range, ver, options]) => {
+    const r = new Range(range, options)
+    t.ok(r.test(ver), `${range} satisfied by ${ver}`)
+  })
+})
+
+test('range parsing', t => {
+  t.plan(rangeParse.length)
+  rangeParse.forEach(([range, expect, options]) =>
+    t.test(`${range} ${expect} ${JSON.stringify(options)}`, t => {
+      if (expect === null) {
+        t.throws(() => new Range(range, options), TypeError, `invalid range: ${range}`)
+      } else {
+        t.equal(new Range(range, options).range || '*', expect, `${range} => ${expect}`)
+        t.equal(new Range(range, options).range, new Range(expect).range,
+          'parsing both yields same result')
+      }
+      t.end()
+    }))
+})
+
+test('throw for empty comparator set, even in loose mode', t => {
+  t.throws(() => new Range('sadf||asdf', { loose: true }),
+    TypeError('Invalid SemVer Range: sadf||asdf'))
+  t.end()
+})
+
+test('convert comparator to range', t => {
+  const c = new Comparator('>=1.2.3')
+  const r = new Range(c)
+  t.equal(r.raw, c.value, 'created range from comparator')
+  t.end()
+})
+
+test('range as argument to range ctor', t => {
+  const loose = new Range('1.2.3', { loose: true })
+  t.equal(new Range(loose, { loose: true }), loose, 'loose option')
+  t.equal(new Range(loose, true), loose, 'loose boolean')
+  t.not(new Range(loose), loose, 'created new range if not matched')
+
+  const incPre = new Range('1.2.3', { includePrerelease: true })
+  t.equal(new Range(incPre, { includePrerelease: true }), incPre,
+    'include prerelease, option match returns argument')
+  t.not(new Range(incPre), incPre,
+    'include prerelease, option mismatch does not return argument')
+
+  t.end()
+})
+
+test('negative range tests', t => {
+  t.plan(rangeExclude.length)
+  rangeExclude.forEach(([range, ver, options]) => {
+    const r = new Range(range, options)
+    t.notOk(r.test(ver), `${range} not satisfied by ${ver}`)
+  })
+})
+
+test('strict vs loose ranges', (t) => {
+  [
+    ['>=01.02.03', '>=1.2.3'],
+    ['~1.02.03beta', '>=1.2.3-beta <1.3.0-0'],
+  ].forEach(([loose, comps]) => {
+    t.throws(() => new Range(loose))
+    t.equal(new Range(loose, true).range, comps)
+  })
+  t.end()
+})
+
+test('tostrings', (t) => {
+  t.equal(new Range('>= v1.2.3').toString(), '>=1.2.3')
+  t.end()
+})
+
+test('ranges intersect', (t) => {
+  rangeIntersection.forEach(([r0, r1, expect]) => {
+    t.test(`${r0} <~> ${r1}`, t => {
+      const range0 = new Range(r0)
+      const range1 = new Range(r1)
+
+      t.equal(range0.intersects(range1), expect,
+        `${r0} <~> ${r1} objects`)
+      t.equal(range1.intersects(range0), expect,
+        `${r1} <~> ${r0} objects`)
+      t.end()
+    })
+  })
+  t.end()
+})
+
+test('missing range parameter in range intersect', (t) => {
+  t.throws(() => {
+    new Range('1.0.0').intersects()
+  }, new TypeError('a Range is required'),
+  'throws type error')
+  t.end()
+})
diff --git a/test/classes/semver.js b/test/classes/semver.js
new file mode 100644
index 00000000..85a0ec31
--- /dev/null
+++ b/test/classes/semver.js
@@ -0,0 +1,141 @@
+const { test } = require('tap')
+const SemVer = require('../../classes/semver')
+const increments = require('../fixtures/increments.js')
+const comparisons = require('../fixtures/comparisons.js')
+const equality = require('../fixtures/equality.js')
+const invalidVersions = require('../fixtures/invalid-versions')
+
+test('comparisons', t => {
+  t.plan(comparisons.length)
+  comparisons.forEach(([v0, v1, opt]) => t.test(`${v0} ${v1}`, t => {
+    const s0 = new SemVer(v0, opt)
+    const s1 = new SemVer(v1, opt)
+    t.equal(s0.compare(s1), 1)
+    t.equal(s0.compare(v1), 1)
+    t.equal(s1.compare(s0), -1)
+    t.equal(s1.compare(v0), -1)
+    t.equal(s0.compare(v0), 0)
+    t.equal(s1.compare(v1), 0)
+    t.end()
+  }))
+})
+
+test('equality', t => {
+  t.plan(equality.length)
+  equality.forEach(([v0, v1, loose]) => t.test(`${v0} ${v1} ${loose}`, t => {
+    const s0 = new SemVer(v0, loose)
+    const s1 = new SemVer(v1, loose)
+    t.equal(s0.compare(s1), 0)
+    t.equal(s1.compare(s0), 0)
+    t.equal(s0.compare(v1), 0)
+    t.equal(s1.compare(v0), 0)
+    t.equal(s0.compare(s0), 0)
+    t.equal(s1.compare(s1), 0)
+    t.equal(s0.comparePre(s1), 0, 'comparePre just to hit that code path')
+    t.end()
+  }))
+})
+
+test('toString equals parsed version', t => {
+  t.equal(String(new SemVer('v1.2.3')), '1.2.3')
+  t.end()
+})
+
+test('throws when presented with garbage', t => {
+  t.plan(invalidVersions.length)
+  invalidVersions.forEach(([v, msg, opts]) =>
+    t.throws(() => new SemVer(v, opts), msg))
+})
+
+test('return SemVer arg to ctor if options match', t => {
+  const s = new SemVer('1.2.3', { loose: true, includePrerelease: true })
+  t.equal(new SemVer(s, { loose: true, includePrerelease: true }), s,
+    'get same object when options match')
+  t.not(new SemVer(s), s, 'get new object when options match')
+  t.end()
+})
+
+test('really big numeric prerelease value', (t) => {
+  const r = new SemVer(`1.2.3-beta.${Number.MAX_SAFE_INTEGER}0`)
+  t.strictSame(r.prerelease, ['beta', '90071992547409910'])
+  t.end()
+})
+
+test('invalid version numbers', (t) => {
+  ['1.2.3.4', 'NOT VALID', 1.2, null, 'Infinity.NaN.Infinity'].forEach((v) => {
+    t.throws(
+      () => {
+        new SemVer(v) // eslint-disable-line no-new
+      },
+      {
+        name: 'TypeError',
+        message:
+          typeof v === 'string'
+            ? `Invalid Version: ${v}`
+            : `Invalid version. Must be a string. Got type "${typeof v}".`,
+      }
+    )
+  })
+
+  t.end()
+})
+
+test('incrementing', t => {
+  t.plan(increments.length)
+  increments.forEach(([
+    version,
+    inc,
+    expect,
+    options,
+    id,
+    base,
+  ]) => t.test(`${version} ${inc} ${id || ''}`.trim(), t => {
+    if (expect === null) {
+      t.plan(1)
+      t.throws(() => new SemVer(version, options).inc(inc, id, base))
+    } else {
+      t.plan(2)
+      const incremented = new SemVer(version, options).inc(inc, id, base)
+      t.equal(incremented.version, expect)
+      if (incremented.build.length) {
+        t.equal(incremented.raw, `${expect}+${incremented.build.join('.')}`)
+      } else {
+        t.equal(incremented.raw, expect)
+      }
+    }
+  }))
+})
+
+test('compare main vs pre', (t) => {
+  const s = new SemVer('1.2.3')
+  t.equal(s.compareMain('2.3.4'), -1)
+  t.equal(s.compareMain('1.2.4'), -1)
+  t.equal(s.compareMain('0.1.2'), 1)
+  t.equal(s.compareMain('1.2.2'), 1)
+  t.equal(s.compareMain('1.2.3-pre'), 0)
+
+  const p = new SemVer('1.2.3-alpha.0.pr.1')
+  t.equal(p.comparePre('9.9.9-alpha.0.pr.1'), 0)
+  t.equal(p.comparePre('1.2.3'), -1)
+  t.equal(p.comparePre('1.2.3-alpha.0.pr.2'), -1)
+  t.equal(p.comparePre('1.2.3-alpha.0.2'), 1)
+
+  t.end()
+})
+
+test('compareBuild', (t) => {
+  const noBuild = new SemVer('1.0.0')
+  const build0 = new SemVer('1.0.0+0')
+  const build1 = new SemVer('1.0.0+1')
+  const build10 = new SemVer('1.0.0+1.0')
+  t.equal(noBuild.compareBuild(build0), -1)
+  t.equal(build0.compareBuild(build0), 0)
+  t.equal(build0.compareBuild(noBuild), 1)
+
+  t.equal(build0.compareBuild('1.0.0+0.0'), -1)
+  t.equal(build0.compareBuild(build1), -1)
+  t.equal(build1.compareBuild(build0), 1)
+  t.equal(build10.compareBuild(build1), 1)
+
+  t.end()
+})
diff --git a/test/cli.js b/test/cli.js
deleted file mode 100644
index af99d937..00000000
--- a/test/cli.js
+++ /dev/null
@@ -1,31 +0,0 @@
-'use strict'
-var t = require('tap')
-
-const spawn = require('child_process').spawn
-const bin = require.resolve('../bin/semver')
-const run = args => new Promise((resolve, reject) => {
-  const c = spawn(process.execPath, [bin].concat(args))
-  c.on('error', reject)
-  const out = []
-  const err = []
-  c.stdout.setEncoding('utf-8')
-  c.stdout.on('data', chunk => out.push(chunk))
-  c.stderr.setEncoding('utf-8')
-  c.stderr.on('data', chunk => err.push(chunk))
-  c.on('close', (code, signal) => {
-    resolve({
-      out: out.join(''),
-      err: err.join(''),
-      code: code,
-      signal: signal
-    })
-  })
-})
-
-t.test('inc tests', t => {
-  [
-    [['-i', 'major', '1.0.0'], { out: '2.0.0', code: 0, signal: null }],
-    [['-i', 'major', '1.0.0', '1.0.1'], { out: '', err: '--inc can only be used on a single version with no range', code: 1 }]
-  ].forEach(c => t.resolveMatch(run(c[0]), c[1]))
-  t.end()
-})
diff --git a/test/coerce.js b/test/coerce.js
deleted file mode 100644
index 7673289d..00000000
--- a/test/coerce.js
+++ /dev/null
@@ -1,118 +0,0 @@
-var tap = require('tap')
-var test = tap.test
-var semver = require('../semver.js')
-var coerce = semver.coerce
-var valid = semver.valid
-
-function r (text) {
-  return function (count) {
-    return text.repeat(count)
-  }
-}
-
-test('\ncoerce tests', function (t) {
-  // Expected to be null (cannot be coerced).
-  [
-    null,
-    { version: '1.2.3' },
-    function () { return '1.2.3' },
-    '',
-    '.',
-    'version one',
-    r('9')(16),
-    r('1')(17),
-    'a' + r('9')(16),
-    'a' + r('1')(17),
-    r('9')(16) + 'a',
-    r('1')(17) + 'a',
-    r('9')(16) + '.4.7.4',
-    r('9')(16) + '.' + r('2')(16) + '.' + r('3')(16),
-    r('1')(16) + '.' + r('9')(16) + '.' + r('3')(16),
-    r('1')(16) + '.' + r('2')(16) + '.' + r('9')(16)
-  ].forEach(function (input) {
-    var msg = 'coerce(' + input + ') should be null'
-    t.same(coerce(input), null, msg)
-  });
-
-  // Expected to be the valid.
-  [
-    [semver.parse('1.2.3'), '1.2.3'],
-    ['.1', '1.0.0'],
-    ['.1.', '1.0.0'],
-    ['..1', '1.0.0'],
-    ['.1.1', '1.1.0'],
-    ['1.', '1.0.0'],
-    ['1.0', '1.0.0'],
-    ['1.0.0', '1.0.0'],
-    ['0', '0.0.0'],
-    ['0.0', '0.0.0'],
-    ['0.0.0', '0.0.0'],
-    ['0.1', '0.1.0'],
-    ['0.0.1', '0.0.1'],
-    ['0.1.1', '0.1.1'],
-    ['1', '1.0.0'],
-    ['1.2', '1.2.0'],
-    ['1.2.3', '1.2.3'],
-    ['1.2.3.4', '1.2.3'],
-    ['13', '13.0.0'],
-    ['35.12', '35.12.0'],
-    ['35.12.18', '35.12.18'],
-    ['35.12.18.24', '35.12.18'],
-    ['v1', '1.0.0'],
-    ['v1.2', '1.2.0'],
-    ['v1.2.3', '1.2.3'],
-    ['v1.2.3.4', '1.2.3'],
-    [' 1', '1.0.0'],
-    ['1 ', '1.0.0'],
-    ['1 0', '1.0.0'],
-    ['1 1', '1.0.0'],
-    ['1.1 1', '1.1.0'],
-    ['1.1-1', '1.1.0'],
-    ['1.1-1', '1.1.0'],
-    ['a1', '1.0.0'],
-    ['a1a', '1.0.0'],
-    ['1a', '1.0.0'],
-    ['version 1', '1.0.0'],
-    ['version1', '1.0.0'],
-    ['version1.0', '1.0.0'],
-    ['version1.1', '1.1.0'],
-    ['42.6.7.9.3-alpha', '42.6.7'],
-    ['v2', '2.0.0'],
-    ['v3.4 replaces v3.3.1', '3.4.0'],
-    ['4.6.3.9.2-alpha2', '4.6.3'],
-    [r('1')(17) + '.2', '2.0.0'],
-    [r('1')(17) + '.2.3', '2.3.0'],
-    ['1.' + r('2')(17) + '.3', '1.0.0'],
-    ['1.2.' + r('3')(17), '1.2.0'],
-    [r('1')(17) + '.2.3.4', '2.3.4'],
-    ['1.' + r('2')(17) + '.3.4', '1.0.0'],
-    ['1.2.' + r('3')(17) + '.4', '1.2.0'],
-    [r('1')(17) + '.' + r('2')(16) + '.' + r('3')(16),
-      r('2')(16) + '.' + r('3')(16) + '.0'],
-    [r('1')(16) + '.' + r('2')(17) + '.' + r('3')(16),
-      r('1')(16) + '.0.0'],
-    [r('1')(16) + '.' + r('2')(16) + '.' + r('3')(17),
-      r('1')(16) + '.' + r('2')(16) + '.0'],
-    ['11' + r('.1')(126), '11.1.1'],
-    [r('1')(16), r('1')(16) + '.0.0'],
-    ['a' + r('1')(16), r('1')(16) + '.0.0'],
-    [r('1')(16) + '.2.3.4', r('1')(16) + '.2.3'],
-    ['1.' + r('2')(16) + '.3.4', '1.' + r('2')(16) + '.3'],
-    ['1.2.' + r('3')(16) + '.4', '1.2.' + r('3')(16)],
-    [r('1')(16) + '.' + r('2')(16) + '.' + r('3')(16),
-      r('1')(16) + '.' + r('2')(16) + '.' + r('3')(16)],
-    ['1.2.3.' + r('4')(252) + '.5', '1.2.3'],
-    ['1.2.3.' + r('4')(1024), '1.2.3'],
-    [r('1')(17) + '.4.7.4', '4.7.4']
-  ].forEach(function (tuple) {
-    var input = tuple[0]
-    var expected = tuple[1]
-    var msg = 'coerce(' + input + ') should become ' + expected
-    t.same((coerce(input) || {}).version, expected, msg)
-  })
-
-  t.same(valid(coerce('42.6.7.9.3-alpha')), '42.6.7')
-  t.same(valid(coerce('v2')), '2.0.0')
-
-  t.done()
-})
diff --git a/test/fixtures/comparator-intersection.js b/test/fixtures/comparator-intersection.js
new file mode 100644
index 00000000..1d777d38
--- /dev/null
+++ b/test/fixtures/comparator-intersection.js
@@ -0,0 +1,42 @@
+// c0, c1, expected intersection, includePrerelease
+module.exports = [
+  // One is a Version
+  ['1.3.0', '>=1.3.0', true],
+  ['1.3.0', '>1.3.0', false],
+  ['>=1.3.0', '1.3.0', true],
+  ['>1.3.0', '1.3.0', false],
+  // Same direction increasing
+  ['>1.3.0', '>1.2.0', true],
+  ['>1.2.0', '>1.3.0', true],
+  ['>=1.2.0', '>1.3.0', true],
+  ['>1.2.0', '>=1.3.0', true],
+  // Same direction decreasing
+  ['<1.3.0', '<1.2.0', true],
+  ['<1.2.0', '<1.3.0', true],
+  ['<=1.2.0', '<1.3.0', true],
+  ['<1.2.0', '<=1.3.0', true],
+  // Different directions, same semver and inclusive operator
+  ['>=1.3.0', '<=1.3.0', true],
+  ['>=v1.3.0', '<=1.3.0', true],
+  ['>=1.3.0', '>=1.3.0', true],
+  ['<=1.3.0', '<=1.3.0', true],
+  ['<=1.3.0', '<=v1.3.0', true],
+  ['>1.3.0', '<=1.3.0', false],
+  ['>=1.3.0', '<1.3.0', false],
+  // Opposite matching directions
+  ['>1.0.0', '<2.0.0', true],
+  ['>=1.0.0', '<2.0.0', true],
+  ['>=1.0.0', '<=2.0.0', true],
+  ['>1.0.0', '<=2.0.0', true],
+  ['<=2.0.0', '>1.0.0', true],
+  ['<=1.0.0', '>=2.0.0', false],
+  ['', '', true],
+  ['', '>1.0.0', true],
+  ['<=2.0.0', '', true],
+  ['<0.0.0', '<0.1.0', false],
+  ['<0.1.0', '<0.0.0', false],
+  ['<0.0.0-0', '<0.1.0', false],
+  ['<0.1.0', '<0.0.0-0', false],
+  ['<0.0.0-0', '<0.1.0', false, true],
+  ['<0.1.0', '<0.0.0-0', false, true],
+]
diff --git a/test/fixtures/comparisons.js b/test/fixtures/comparisons.js
new file mode 100644
index 00000000..45275816
--- /dev/null
+++ b/test/fixtures/comparisons.js
@@ -0,0 +1,36 @@
+// [version1, version2]
+// version1 should be greater than version2
+// used by the cmp, eq, gt, lt, and neq tests
+module.exports = [
+  ['0.0.0', '0.0.0-foo'],
+  ['0.0.1', '0.0.0'],
+  ['1.0.0', '0.9.9'],
+  ['0.10.0', '0.9.0'],
+  ['0.99.0', '0.10.0', {}],
+  ['2.0.0', '1.2.3', { loose: false }],
+  ['v0.0.0', '0.0.0-foo', true],
+  ['v0.0.1', '0.0.0', { loose: true }],
+  ['v1.0.0', '0.9.9', true],
+  ['v0.10.0', '0.9.0', true],
+  ['v0.99.0', '0.10.0', true],
+  ['v2.0.0', '1.2.3', true],
+  ['0.0.0', 'v0.0.0-foo', true],
+  ['0.0.1', 'v0.0.0', true],
+  ['1.0.0', 'v0.9.9', true],
+  ['0.10.0', 'v0.9.0', true],
+  ['0.99.0', 'v0.10.0', true],
+  ['2.0.0', 'v1.2.3', true],
+  ['1.2.3', '1.2.3-asdf'],
+  ['1.2.3', '1.2.3-4'],
+  ['1.2.3', '1.2.3-4-foo'],
+  ['1.2.3-5-foo', '1.2.3-5'],
+  ['1.2.3-5', '1.2.3-4'],
+  ['1.2.3-5-foo', '1.2.3-5-Foo'],
+  ['3.0.0', '2.7.2+asdf'],
+  ['1.2.3-a.10', '1.2.3-a.5'],
+  ['1.2.3-a.b', '1.2.3-a.5'],
+  ['1.2.3-a.b', '1.2.3-a'],
+  ['1.2.3-a.b.c.10.d.5', '1.2.3-a.b.c.5.d.100'],
+  ['1.2.3-r2', '1.2.3-r100'],
+  ['1.2.3-r100', '1.2.3-R2'],
+]
diff --git a/test/fixtures/equality.js b/test/fixtures/equality.js
new file mode 100644
index 00000000..81fb09a7
--- /dev/null
+++ b/test/fixtures/equality.js
@@ -0,0 +1,41 @@
+// [version1, version2]
+// version1 should be equivalent to version2
+module.exports = [
+  ['1.2.3', 'v1.2.3', true],
+  ['1.2.3', '=1.2.3', true],
+  ['1.2.3', 'v 1.2.3', true],
+  ['1.2.3', '= 1.2.3', true],
+  ['1.2.3', ' v1.2.3', true],
+  ['1.2.3', ' =1.2.3', true],
+  ['1.2.3', ' v 1.2.3', true],
+  ['1.2.3', ' = 1.2.3', true],
+  ['1.2.3-0', 'v1.2.3-0', true],
+  ['1.2.3-0', '=1.2.3-0', true],
+  ['1.2.3-0', 'v 1.2.3-0', true],
+  ['1.2.3-0', '= 1.2.3-0', true],
+  ['1.2.3-0', ' v1.2.3-0', true],
+  ['1.2.3-0', ' =1.2.3-0', true],
+  ['1.2.3-0', ' v 1.2.3-0', true],
+  ['1.2.3-0', ' = 1.2.3-0', true],
+  ['1.2.3-1', 'v1.2.3-1', true],
+  ['1.2.3-1', '=1.2.3-1', true],
+  ['1.2.3-1', 'v 1.2.3-1', true],
+  ['1.2.3-1', '= 1.2.3-1', true],
+  ['1.2.3-1', ' v1.2.3-1', true],
+  ['1.2.3-1', ' =1.2.3-1', true],
+  ['1.2.3-1', ' v 1.2.3-1', true],
+  ['1.2.3-1', ' = 1.2.3-1', true],
+  ['1.2.3-beta', 'v1.2.3-beta', true],
+  ['1.2.3-beta', '=1.2.3-beta', true],
+  ['1.2.3-beta', 'v 1.2.3-beta', true],
+  ['1.2.3-beta', '= 1.2.3-beta', true],
+  ['1.2.3-beta', ' v1.2.3-beta', true],
+  ['1.2.3-beta', ' =1.2.3-beta', true],
+  ['1.2.3-beta', ' v 1.2.3-beta', true],
+  ['1.2.3-beta', ' = 1.2.3-beta', true],
+  ['1.2.3-beta+build', ' = 1.2.3-beta+otherbuild', true],
+  ['1.2.3+build', ' = 1.2.3+otherbuild', true],
+  ['1.2.3-beta+build', '1.2.3-beta+otherbuild'],
+  ['1.2.3+build', '1.2.3+otherbuild'],
+  ['  v1.2.3+build', '1.2.3+otherbuild'],
+]
diff --git a/test/fixtures/increments.js b/test/fixtures/increments.js
new file mode 100644
index 00000000..65e9530b
--- /dev/null
+++ b/test/fixtures/increments.js
@@ -0,0 +1,127 @@
+//  [version, inc, result, options, identifier, identifierBase]
+//  inc(version, inc, options, identifier, identifierBase) -> result
+module.exports = [
+  ['1.2.3', 'major', '2.0.0'],
+  ['1.2.3', 'minor', '1.3.0'],
+  ['1.2.3', 'patch', '1.2.4'],
+  ['1.2.3tag', 'major', '2.0.0', true],
+  ['1.2.3-tag', 'major', '2.0.0'],
+  ['1.2.3', 'fake', null],
+  ['1.2.0-0', 'patch', '1.2.0'],
+  ['fake', 'major', null],
+  ['1.2.3-4', 'major', '2.0.0'],
+  ['1.2.3-4', 'minor', '1.3.0'],
+  ['1.2.3-4', 'patch', '1.2.3'],
+  ['1.2.3-alpha.0.beta', 'major', '2.0.0'],
+  ['1.2.3-alpha.0.beta', 'minor', '1.3.0'],
+  ['1.2.3-alpha.0.beta', 'patch', '1.2.3'],
+  ['1.2.4', 'prerelease', '1.2.5-0'],
+  ['1.2.3-0', 'prerelease', '1.2.3-1'],
+  ['1.2.3-alpha.0', 'prerelease', '1.2.3-alpha.1'],
+  ['1.2.3-alpha.1', 'prerelease', '1.2.3-alpha.2'],
+  ['1.2.3-alpha.2', 'prerelease', '1.2.3-alpha.3'],
+  ['1.2.3-alpha.0.beta', 'prerelease', '1.2.3-alpha.1.beta'],
+  ['1.2.3-alpha.1.beta', 'prerelease', '1.2.3-alpha.2.beta'],
+  ['1.2.3-alpha.2.beta', 'prerelease', '1.2.3-alpha.3.beta'],
+  ['1.2.3-alpha.10.0.beta', 'prerelease', '1.2.3-alpha.10.1.beta'],
+  ['1.2.3-alpha.10.1.beta', 'prerelease', '1.2.3-alpha.10.2.beta'],
+  ['1.2.3-alpha.10.2.beta', 'prerelease', '1.2.3-alpha.10.3.beta'],
+  ['1.2.3-alpha.10.beta.0', 'prerelease', '1.2.3-alpha.10.beta.1'],
+  ['1.2.3-alpha.10.beta.1', 'prerelease', '1.2.3-alpha.10.beta.2'],
+  ['1.2.3-alpha.10.beta.2', 'prerelease', '1.2.3-alpha.10.beta.3'],
+  ['1.2.3-alpha.9.beta', 'prerelease', '1.2.3-alpha.10.beta'],
+  ['1.2.3-alpha.10.beta', 'prerelease', '1.2.3-alpha.11.beta'],
+  ['1.2.3-alpha.11.beta', 'prerelease', '1.2.3-alpha.12.beta'],
+  ['1.2.0', 'prepatch', '1.2.1-0'],
+  ['1.2.0-1', 'prepatch', '1.2.1-0'],
+  ['1.2.0', 'preminor', '1.3.0-0'],
+  ['1.2.3-1', 'preminor', '1.3.0-0'],
+  ['1.2.0', 'premajor', '2.0.0-0'],
+  ['1.2.3-1', 'premajor', '2.0.0-0'],
+  ['1.2.0-1', 'minor', '1.2.0'],
+  ['1.0.0-1', 'major', '1.0.0'],
+
+  ['1.2.3', 'major', '2.0.0', false, 'dev'],
+  ['1.2.3', 'minor', '1.3.0', false, 'dev'],
+  ['1.2.3', 'patch', '1.2.4', false, 'dev'],
+  ['1.2.3tag', 'major', '2.0.0', true, 'dev'],
+  ['1.2.3-tag', 'major', '2.0.0', false, 'dev'],
+  ['1.2.3', 'fake', null, false, 'dev'],
+  ['1.2.0-0', 'patch', '1.2.0', false, 'dev'],
+  ['fake', 'major', null, false, 'dev'],
+  ['1.2.3-4', 'major', '2.0.0', false, 'dev'],
+  ['1.2.3-4', 'minor', '1.3.0', false, 'dev'],
+  ['1.2.3-4', 'patch', '1.2.3', false, 'dev'],
+  ['1.2.3-alpha.0.beta', 'major', '2.0.0', false, 'dev'],
+  ['1.2.3-alpha.0.beta', 'minor', '1.3.0', false, 'dev'],
+  ['1.2.3-alpha.0.beta', 'patch', '1.2.3', false, 'dev'],
+  ['1.2.4', 'prerelease', '1.2.5-dev.0', false, 'dev'],
+  ['1.2.3-0', 'prerelease', '1.2.3-dev.0', false, 'dev'],
+  ['1.2.3-alpha.0', 'prerelease', '1.2.3-dev.0', false, 'dev'],
+  ['1.2.3-alpha.0', 'prerelease', '1.2.3-alpha.1', false, 'alpha'],
+  ['1.2.3-alpha.0.beta', 'prerelease', '1.2.3-dev.0', false, 'dev'],
+  ['1.2.3-alpha.0.beta', 'prerelease', '1.2.3-alpha.1.beta', false, 'alpha'],
+  ['1.2.3-alpha.10.0.beta', 'prerelease', '1.2.3-dev.0', false, 'dev'],
+  ['1.2.3-alpha.10.0.beta', 'prerelease', '1.2.3-alpha.10.1.beta', false, 'alpha'],
+  ['1.2.3-alpha.10.1.beta', 'prerelease', '1.2.3-alpha.10.2.beta', false, 'alpha'],
+  ['1.2.3-alpha.10.2.beta', 'prerelease', '1.2.3-alpha.10.3.beta', false, 'alpha'],
+  ['1.2.3-alpha.10.beta.0', 'prerelease', '1.2.3-dev.0', false, 'dev'],
+  ['1.2.3-alpha.10.beta.0', 'prerelease', '1.2.3-alpha.10.beta.1', false, 'alpha'],
+  ['1.2.3-alpha.10.beta.1', 'prerelease', '1.2.3-alpha.10.beta.2', false, 'alpha'],
+  ['1.2.3-alpha.10.beta.2', 'prerelease', '1.2.3-alpha.10.beta.3', false, 'alpha'],
+  ['1.2.3-alpha.9.beta', 'prerelease', '1.2.3-dev.0', false, 'dev'],
+  ['1.2.3-alpha.9.beta', 'prerelease', '1.2.3-alpha.10.beta', false, 'alpha'],
+  ['1.2.3-alpha.10.beta', 'prerelease', '1.2.3-alpha.11.beta', false, 'alpha'],
+  ['1.2.3-alpha.11.beta', 'prerelease', '1.2.3-alpha.12.beta', false, 'alpha'],
+  ['1.2.0', 'prepatch', '1.2.1-dev.0', false, 'dev'],
+  ['1.2.0-1', 'prepatch', '1.2.1-dev.0', false, 'dev'],
+  ['1.2.0', 'preminor', '1.3.0-dev.0', false, 'dev'],
+  ['1.2.3-1', 'preminor', '1.3.0-dev.0', false, 'dev'],
+  ['1.2.0', 'premajor', '2.0.0-dev.0', false, 'dev'],
+  ['1.2.3-1', 'premajor', '2.0.0-dev.0', false, 'dev'],
+  ['1.2.3-1', 'premajor', '2.0.0-dev.1', false, 'dev', 1],
+  ['1.2.0-1', 'minor', '1.2.0', false, 'dev'],
+  ['1.0.0-1', 'major', '1.0.0', 'dev'],
+  ['1.2.3-dev.bar', 'prerelease', '1.2.3-dev.0', false, 'dev'],
+  ['1.2.3-0', 'prerelease', '1.2.3-1.0', false, '1'],
+  ['1.2.3-1.0', 'prerelease', '1.2.3-1.1', false, '1'],
+  ['1.2.3-1.1', 'prerelease', '1.2.3-1.2', false, '1'],
+  ['1.2.3-1.1', 'prerelease', '1.2.3-2.0', false, '2'],
+
+  // [version, inc, result, identifierIndex, loose, identifier]
+  ['1.2.0-1', 'prerelease', '1.2.0-alpha.0', false, 'alpha', '0'],
+  ['1.2.1', 'prerelease', '1.2.2-alpha.0', false, 'alpha', '0'],
+  ['0.2.0', 'prerelease', '0.2.1-alpha.0', false, 'alpha', '0'],
+  ['1.2.2', 'prerelease', '1.2.3-alpha.1', false, 'alpha', '1'],
+  ['1.2.3', 'prerelease', '1.2.4-alpha.1', false, 'alpha', '1'],
+  ['1.2.4', 'prerelease', '1.2.5-alpha.1', false, 'alpha', '1'],
+  ['1.2.0', 'prepatch', '1.2.1-dev.1', false, 'dev', '1'],
+  ['1.2.0-1', 'prepatch', '1.2.1-dev.1', false, 'dev', '1'],
+  ['1.2.0', 'premajor', '2.0.0-dev.0', false, 'dev', '0'],
+  ['1.2.3-1', 'premajor', '2.0.0-dev.0', false, 'dev', '0'],
+  ['1.2.3-dev.bar', 'prerelease', '1.2.3-dev.0', false, 'dev', '0'],
+  ['1.2.3-dev.bar', 'prerelease', '1.2.3-dev.1', false, 'dev', '1'],
+  ['1.2.3-dev.bar', 'prerelease', '1.2.3-dev.bar.0', false, '', '0'],
+  ['1.2.3-dev.bar', 'prerelease', '1.2.3-dev.bar.1', false, '', '1'],
+  ['1.2.0', 'preminor', '1.3.0-dev.1', false, 'dev', '1'],
+  ['1.2.3-1', 'preminor', '1.3.0-dev.0', false, 'dev'],
+  ['1.2.0', 'prerelease', '1.2.1-1', false, '', '1'],
+
+  ['1.2.0-1', 'prerelease', '1.2.0-alpha', false, 'alpha', false],
+  ['1.2.1', 'prerelease', '1.2.2-alpha', false, 'alpha', false],
+  ['1.2.2', 'prerelease', '1.2.3-alpha', false, 'alpha', false],
+  ['1.2.0', 'prepatch', '1.2.1-dev', false, 'dev', false],
+  ['1.2.0-1', 'prepatch', '1.2.1-dev', false, 'dev', false],
+  ['1.2.0', 'premajor', '2.0.0-dev', false, 'dev', false],
+  ['1.2.3-1', 'premajor', '2.0.0-dev', false, 'dev', false],
+  ['1.2.3-dev.bar', 'prerelease', '1.2.3-dev', false, 'dev', false],
+  ['1.2.3-dev.bar', 'prerelease', '1.2.3-dev.baz', false, 'dev.baz', false],
+  ['1.2.0', 'preminor', '1.3.0-dev', false, 'dev', false],
+  ['1.2.3-1', 'preminor', '1.3.0-dev', false, 'dev', false],
+  ['1.2.3-dev', 'prerelease', null, false, 'dev', false],
+  ['1.2.0-dev', 'premajor', '2.0.0-dev', false, 'dev', false],
+  ['1.2.0-dev', 'preminor', '1.3.0-beta', false, 'beta', false],
+  ['1.2.0-dev', 'prepatch', '1.2.1-dev', false, 'dev', false],
+  ['1.2.0', 'prerelease', null, false, '', false],
+  ['1.0.0-rc.1+build.4', 'prerelease', '1.0.0-rc.2', 'rc', false],
+]
diff --git a/test/fixtures/invalid-versions.js b/test/fixtures/invalid-versions.js
new file mode 100644
index 00000000..d782b4bf
--- /dev/null
+++ b/test/fixtures/invalid-versions.js
@@ -0,0 +1,15 @@
+// none of these are semvers
+// [value, reason, opt]
+const { MAX_LENGTH, MAX_SAFE_INTEGER } = require('../../internal/constants')
+module.exports = [
+  [new Array(MAX_LENGTH).join('1') + '.0.0', 'too long'],
+  [`${MAX_SAFE_INTEGER}0.0.0`, 'too big'],
+  [`0.${MAX_SAFE_INTEGER}0.0`, 'too big'],
+  [`0.0.${MAX_SAFE_INTEGER}0`, 'too big'],
+  ['hello, world', 'not a version'],
+  ['hello, world', true, 'even loose, its still junk'],
+  ['xyz', 'even loose as an opt, same', { loose: true }],
+  [/a regexp/, 'regexp is not a string'],
+  [/1.2.3/, 'semver-ish regexp is not a string'],
+  [{ toString: () => '1.2.3' }, 'obj with a tostring is not a string'],
+]
diff --git a/test/fixtures/range-exclude.js b/test/fixtures/range-exclude.js
new file mode 100644
index 00000000..2789148a
--- /dev/null
+++ b/test/fixtures/range-exclude.js
@@ -0,0 +1,107 @@
+// [range, version, options]
+// version should not be included by range
+module.exports = [
+  ['1.0.0 - 2.0.0', '2.2.3'],
+  ['1.2.3+asdf - 2.4.3+asdf', '1.2.3-pre.2'],
+  ['1.2.3+asdf - 2.4.3+asdf', '2.4.3-alpha'],
+  ['^1.2.3+build', '2.0.0'],
+  ['^1.2.3+build', '1.2.0'],
+  ['^1.2.3', '1.2.3-pre'],
+  ['^1.2', '1.2.0-pre'],
+  ['>1.2', '1.3.0-beta'],
+  ['<=1.2.3', '1.2.3-beta'],
+  ['^1.2.3', '1.2.3-beta'],
+  ['=0.7.x', '0.7.0-asdf'],
+  ['>=0.7.x', '0.7.0-asdf'],
+  ['<=0.7.x', '0.7.0-asdf'],
+  ['1', '1.0.0beta', { loose: 420 }],
+  ['<1', '1.0.0beta', true],
+  ['< 1', '1.0.0beta', true],
+  ['1.0.0', '1.0.1'],
+  ['>=1.0.0', '0.0.0'],
+  ['>=1.0.0', '0.0.1'],
+  ['>=1.0.0', '0.1.0'],
+  ['>1.0.0', '0.0.1'],
+  ['>1.0.0', '0.1.0'],
+  ['<=2.0.0', '3.0.0'],
+  ['<=2.0.0', '2.9999.9999'],
+  ['<=2.0.0', '2.2.9'],
+  ['<2.0.0', '2.9999.9999'],
+  ['<2.0.0', '2.2.9'],
+  ['>=0.1.97', 'v0.1.93', true],
+  ['>=0.1.97', '0.1.93'],
+  ['0.1.20 || 1.2.4', '1.2.3'],
+  ['>=0.2.3 || <0.0.1', '0.0.3'],
+  ['>=0.2.3 || <0.0.1', '0.2.2'],
+  ['2.x.x', '1.1.3', { loose: NaN }],
+  ['2.x.x', '3.1.3'],
+  ['1.2.x', '1.3.3'],
+  ['1.2.x || 2.x', '3.1.3'],
+  ['1.2.x || 2.x', '1.1.3'],
+  ['2.*.*', '1.1.3'],
+  ['2.*.*', '3.1.3'],
+  ['1.2.*', '1.3.3'],
+  ['1.2.* || 2.*', '3.1.3'],
+  ['1.2.* || 2.*', '1.1.3'],
+  ['2', '1.1.2'],
+  ['2.3', '2.4.1'],
+  ['~0.0.1', '0.1.0-alpha'],
+  ['~0.0.1', '0.1.0'],
+  ['~2.4', '2.5.0'], // >=2.4.0 <2.5.0
+  ['~2.4', '2.3.9'],
+  ['~>3.2.1', '3.3.2'], // >=3.2.1 <3.3.0
+  ['~>3.2.1', '3.2.0'], // >=3.2.1 <3.3.0
+  ['~1', '0.2.3'], // >=1.0.0 <2.0.0
+  ['~>1', '2.2.3'],
+  ['~1.0', '1.1.0'], // >=1.0.0 <1.1.0
+  ['<1', '1.0.0'],
+  ['>=1.2', '1.1.1'],
+  ['1', '2.0.0beta', true],
+  ['~v0.5.4-beta', '0.5.4-alpha'],
+  ['=0.7.x', '0.8.2'],
+  ['>=0.7.x', '0.6.2'],
+  ['<0.7.x', '0.7.2'],
+  ['<1.2.3', '1.2.3-beta'],
+  ['=1.2.3', '1.2.3-beta'],
+  ['>1.2', '1.2.8'],
+  ['^0.0.1', '0.0.2-alpha'],
+  ['^0.0.1', '0.0.2'],
+  ['^1.2.3', '2.0.0-alpha'],
+  ['^1.2.3', '1.2.2'],
+  ['^1.2', '1.1.9'],
+  ['*', 'v1.2.3-foo', true],
+
+  // invalid versions never satisfy, but shouldn't throw
+  ['*', 'not a version'],
+  ['>=2', 'glorp'],
+  ['>=2', false],
+
+  ['2.x', '3.0.0-pre.0', { includePrerelease: true }],
+  ['^1.0.0', '1.0.0-rc1', { includePrerelease: true }],
+  ['^1.0.0', '2.0.0-rc1', { includePrerelease: true }],
+  ['^1.2.3-rc2', '2.0.0', { includePrerelease: true }],
+  ['^1.0.0', '2.0.0-rc1'],
+
+  ['1 - 2', '3.0.0-pre', { includePrerelease: true }],
+  ['1 - 2', '2.0.0-pre'],
+  ['1 - 2', '1.0.0-pre'],
+  ['1.0 - 2', '1.0.0-pre'],
+
+  ['1.1.x', '1.0.0-a'],
+  ['1.1.x', '1.1.0-a'],
+  ['1.1.x', '1.2.0-a'],
+  ['1.1.x', '1.2.0-a', { includePrerelease: true }],
+  ['1.1.x', '1.0.0-a', { includePrerelease: true }],
+  ['1.x', '1.0.0-a'],
+  ['1.x', '1.1.0-a'],
+  ['1.x', '1.2.0-a'],
+  ['1.x', '0.0.0-a', { includePrerelease: true }],
+  ['1.x', '2.0.0-a', { includePrerelease: true }],
+
+  ['>=1.0.0 <1.1.0', '1.1.0'],
+  ['>=1.0.0 <1.1.0', '1.1.0', { includePrerelease: true }],
+  ['>=1.0.0 <1.1.0', '1.1.0-pre'],
+  ['>=1.0.0 <1.1.0-pre', '1.1.0-pre'],
+
+  ['== 1.0.0 || foo', '2.0.0', { loose: true }],
+]
diff --git a/test/fixtures/range-include.js b/test/fixtures/range-include.js
new file mode 100644
index 00000000..cdb7034b
--- /dev/null
+++ b/test/fixtures/range-include.js
@@ -0,0 +1,127 @@
+// [range, version, options]
+// version should be included by range
+module.exports = [
+  ['1.0.0 - 2.0.0', '1.2.3'],
+  ['^1.2.3+build', '1.2.3'],
+  ['^1.2.3+build', '1.3.0'],
+  ['1.2.3-pre+asdf - 2.4.3-pre+asdf', '1.2.3'],
+  ['1.2.3pre+asdf - 2.4.3-pre+asdf', '1.2.3', true],
+  ['1.2.3-pre+asdf - 2.4.3pre+asdf', '1.2.3', true],
+  ['1.2.3pre+asdf - 2.4.3pre+asdf', '1.2.3', true],
+  ['1.2.3-pre+asdf - 2.4.3-pre+asdf', '1.2.3-pre.2'],
+  ['1.2.3-pre+asdf - 2.4.3-pre+asdf', '2.4.3-alpha'],
+  ['1.2.3+asdf - 2.4.3+asdf', '1.2.3'],
+  ['1.0.0', '1.0.0'],
+  ['>=*', '0.2.4'],
+  ['', '1.0.0'],
+  ['*', '1.2.3', {}],
+  ['*', 'v1.2.3', { loose: 123 }],
+  ['>=1.0.0', '1.0.0', /asdf/],
+  ['>=1.0.0', '1.0.1', { loose: null }],
+  ['>=1.0.0', '1.1.0', { loose: 0 }],
+  ['>1.0.0', '1.0.1', { loose: undefined }],
+  ['>1.0.0', '1.1.0'],
+  ['<=2.0.0', '2.0.0'],
+  ['<=2.0.0', '1.9999.9999'],
+  ['<=2.0.0', '0.2.9'],
+  ['<2.0.0', '1.9999.9999'],
+  ['<2.0.0', '0.2.9'],
+  ['>= 1.0.0', '1.0.0'],
+  ['>=  1.0.0', '1.0.1'],
+  ['>=   1.0.0', '1.1.0'],
+  ['> 1.0.0', '1.0.1'],
+  ['>  1.0.0', '1.1.0'],
+  ['<=   2.0.0', '2.0.0'],
+  ['<= 2.0.0', '1.9999.9999'],
+  ['<=  2.0.0', '0.2.9'],
+  ['<    2.0.0', '1.9999.9999'],
+  ['<\t2.0.0', '0.2.9'],
+  ['>=0.1.97', 'v0.1.97', true],
+  ['>=0.1.97', '0.1.97'],
+  ['0.1.20 || 1.2.4', '1.2.4'],
+  ['>=0.2.3 || <0.0.1', '0.0.0'],
+  ['>=0.2.3 || <0.0.1', '0.2.3'],
+  ['>=0.2.3 || <0.0.1', '0.2.4'],
+  ['||', '1.3.4'],
+  ['2.x.x', '2.1.3'],
+  ['1.2.x', '1.2.3'],
+  ['1.2.x || 2.x', '2.1.3'],
+  ['1.2.x || 2.x', '1.2.3'],
+  ['x', '1.2.3'],
+  ['2.*.*', '2.1.3'],
+  ['1.2.*', '1.2.3'],
+  ['1.2.* || 2.*', '2.1.3'],
+  ['1.2.* || 2.*', '1.2.3'],
+  ['*', '1.2.3'],
+  ['2', '2.1.2'],
+  ['2.3', '2.3.1'],
+  ['~0.0.1', '0.0.1'],
+  ['~0.0.1', '0.0.2'],
+  ['~x', '0.0.9'], // >=2.4.0 <2.5.0
+  ['~2', '2.0.9'], // >=2.4.0 <2.5.0
+  ['~2.4', '2.4.0'], // >=2.4.0 <2.5.0
+  ['~2.4', '2.4.5'],
+  ['~>3.2.1', '3.2.2'], // >=3.2.1 <3.3.0,
+  ['~1', '1.2.3'], // >=1.0.0 <2.0.0
+  ['~>1', '1.2.3'],
+  ['~> 1', '1.2.3'],
+  ['~1.0', '1.0.2'], // >=1.0.0 <1.1.0,
+  ['~ 1.0', '1.0.2'],
+  ['~ 1.0.3', '1.0.12'],
+  ['~ 1.0.3alpha', '1.0.12', { loose: true }],
+  ['>=1', '1.0.0'],
+  ['>= 1', '1.0.0'],
+  ['<1.2', '1.1.1'],
+  ['< 1.2', '1.1.1'],
+  ['~v0.5.4-pre', '0.5.5'],
+  ['~v0.5.4-pre', '0.5.4'],
+  ['=0.7.x', '0.7.2'],
+  ['<=0.7.x', '0.7.2'],
+  ['>=0.7.x', '0.7.2'],
+  ['<=0.7.x', '0.6.2'],
+  ['~1.2.1 >=1.2.3', '1.2.3'],
+  ['~1.2.1 =1.2.3', '1.2.3'],
+  ['~1.2.1 1.2.3', '1.2.3'],
+  ['~1.2.1 >=1.2.3 1.2.3', '1.2.3'],
+  ['~1.2.1 1.2.3 >=1.2.3', '1.2.3'],
+  ['>=1.2.1 1.2.3', '1.2.3'],
+  ['1.2.3 >=1.2.1', '1.2.3'],
+  ['>=1.2.3 >=1.2.1', '1.2.3'],
+  ['>=1.2.1 >=1.2.3', '1.2.3'],
+  ['>=1.2', '1.2.8'],
+  ['^1.2.3', '1.8.1'],
+  ['^0.1.2', '0.1.2'],
+  ['^0.1', '0.1.2'],
+  ['^0.0.1', '0.0.1'],
+  ['^1.2', '1.4.2'],
+  ['^1.2 ^1', '1.4.2'],
+  ['^1.2.3-alpha', '1.2.3-pre'],
+  ['^1.2.0-alpha', '1.2.0-pre'],
+  ['^0.0.1-alpha', '0.0.1-beta'],
+  ['^0.0.1-alpha', '0.0.1'],
+  ['^0.1.1-alpha', '0.1.1-beta'],
+  ['^x', '1.2.3'],
+  ['x - 1.0.0', '0.9.7'],
+  ['x - 1.x', '0.9.7'],
+  ['1.0.0 - x', '1.9.7'],
+  ['1.x - x', '1.9.7'],
+  ['<=7.x', '7.9.9'],
+  ['2.x', '2.0.0-pre.0', { includePrerelease: true }],
+  ['2.x', '2.1.0-pre.0', { includePrerelease: true }],
+  ['1.1.x', '1.1.0-a', { includePrerelease: true }],
+  ['1.1.x', '1.1.1-a', { includePrerelease: true }],
+  ['*', '1.0.0-rc1', { includePrerelease: true }],
+  ['^1.0.0-0', '1.0.1-rc1', { includePrerelease: true }],
+  ['^1.0.0-rc2', '1.0.1-rc1', { includePrerelease: true }],
+  ['^1.0.0', '1.0.1-rc1', { includePrerelease: true }],
+  ['^1.0.0', '1.1.0-rc1', { includePrerelease: true }],
+  ['1 - 2', '2.0.0-pre', { includePrerelease: true }],
+  ['1 - 2', '1.0.0-pre', { includePrerelease: true }],
+  ['1.0 - 2', '1.0.0-pre', { includePrerelease: true }],
+
+  ['=0.7.x', '0.7.0-asdf', { includePrerelease: true }],
+  ['>=0.7.x', '0.7.0-asdf', { includePrerelease: true }],
+  ['<=0.7.x', '0.7.0-asdf', { includePrerelease: true }],
+
+  ['>=1.0.0 <=1.1.0', '1.1.0-pre', { includePrerelease: true }],
+]
diff --git a/test/fixtures/range-intersection.js b/test/fixtures/range-intersection.js
new file mode 100644
index 00000000..965c6e2e
--- /dev/null
+++ b/test/fixtures/range-intersection.js
@@ -0,0 +1,59 @@
+// r0, r1, expected intersection
+module.exports = [
+  ['1.3.0 || <1.0.0 >2.0.0', '1.3.0 || <1.0.0 >2.0.0', true],
+  ['<1.0.0 >2.0.0', '>0.0.0', false],
+  ['>0.0.0', '<1.0.0 >2.0.0', false],
+  ['<1.0.0 >2.0.0', '>1.4.0 <1.6.0', false],
+  ['<1.0.0 >2.0.0', '>1.4.0 <1.6.0 || 2.0.0', false],
+  ['>1.0.0 <=2.0.0', '2.0.0', true],
+  ['<1.0.0 >=2.0.0', '2.1.0', false],
+  ['<1.0.0 >=2.0.0', '>1.4.0 <1.6.0 || 2.0.0', false],
+  ['1.5.x', '<1.5.0 || >=1.6.0', false],
+  ['<1.5.0 || >=1.6.0', '1.5.x', false],
+  ['<1.6.16 || >=1.7.0 <1.7.11 || >=1.8.0 <1.8.2',
+    '>=1.6.16 <1.7.0 || >=1.7.11 <1.8.0 || >=1.8.2', false],
+  ['<=1.6.16 || >=1.7.0 <1.7.11 || >=1.8.0 <1.8.2',
+    '>=1.6.16 <1.7.0 || >=1.7.11 <1.8.0 || >=1.8.2', true],
+  ['>=1.0.0', '<=1.0.0', true],
+  ['>1.0.0 <1.0.0', '<=0.0.0', false],
+  ['*', '0.0.1', true],
+  ['*', '>=1.0.0', true],
+  ['*', '>1.0.0', true],
+  ['*', '~1.0.0', true],
+  ['*', '<1.6.0', true],
+  ['*', '<=1.6.0', true],
+  ['1.*', '0.0.1', false],
+  ['1.*', '2.0.0', false],
+  ['1.*', '1.0.0', true],
+  ['1.*', '<2.0.0', true],
+  ['1.*', '>1.0.0', true],
+  ['1.*', '<=1.0.0', true],
+  ['1.*', '^1.0.0', true],
+  ['1.0.*', '0.0.1', false],
+  ['1.0.*', '<0.0.1', false],
+  ['1.0.*', '>0.0.1', true],
+  ['*', '1.3.0 || <1.0.0 >2.0.0', true],
+  ['1.3.0 || <1.0.0 >2.0.0', '*', true],
+  ['1.*', '1.3.0 || <1.0.0 >2.0.0', true],
+  ['x', '0.0.1', true],
+  ['x', '>=1.0.0', true],
+  ['x', '>1.0.0', true],
+  ['x', '~1.0.0', true],
+  ['x', '<1.6.0', true],
+  ['x', '<=1.6.0', true],
+  ['1.x', '0.0.1', false],
+  ['1.x', '2.0.0', false],
+  ['1.x', '1.0.0', true],
+  ['1.x', '<2.0.0', true],
+  ['1.x', '>1.0.0', true],
+  ['1.x', '<=1.0.0', true],
+  ['1.x', '^1.0.0', true],
+  ['1.0.x', '0.0.1', false],
+  ['1.0.x', '<0.0.1', false],
+  ['1.0.x', '>0.0.1', true],
+  ['x', '1.3.0 || <1.0.0 >2.0.0', true],
+  ['1.3.0 || <1.0.0 >2.0.0', 'x', true],
+  ['1.x', '1.3.0 || <1.0.0 >2.0.0', true],
+  ['*', '*', true],
+  ['x', '', true],
+]
diff --git a/test/fixtures/range-parse.js b/test/fixtures/range-parse.js
new file mode 100644
index 00000000..dcafc6b5
--- /dev/null
+++ b/test/fixtures/range-parse.js
@@ -0,0 +1,89 @@
+// [range, canonical result, options]
+// null result means it's not a valid range
+// '*' is the return value from functions.validRange(), but
+// new Range().range will be '' in those cases
+const { MAX_SAFE_INTEGER } = require('../../internal/constants')
+module.exports = [
+  ['1.0.0 - 2.0.0', '>=1.0.0 <=2.0.0'],
+  ['1.0.0 - 2.0.0', '>=1.0.0-0 <2.0.1-0', { includePrerelease: true }],
+  ['1 - 2', '>=1.0.0 <3.0.0-0'],
+  ['1 - 2', '>=1.0.0-0 <3.0.0-0', { includePrerelease: true }],
+  ['1.0 - 2.0', '>=1.0.0 <2.1.0-0'],
+  ['1.0 - 2.0', '>=1.0.0-0 <2.1.0-0', { includePrerelease: true }],
+  ['1.0.0', '1.0.0', { loose: false }],
+  ['>=*', '*'],
+  ['', '*'],
+  ['*', '*'],
+  ['>=1.0.0', '>=1.0.0'],
+  ['>1.0.0', '>1.0.0'],
+  ['<=2.0.0', '<=2.0.0'],
+  ['1', '>=1.0.0 <2.0.0-0'],
+  ['<2.0.0', '<2.0.0'],
+  ['>= 1.0.0', '>=1.0.0'],
+  ['>=  1.0.0', '>=1.0.0'],
+  ['>=   1.0.0', '>=1.0.0'],
+  ['> 1.0.0', '>1.0.0'],
+  ['>  1.0.0', '>1.0.0'],
+  ['<=   2.0.0', '<=2.0.0'],
+  ['<= 2.0.0', '<=2.0.0'],
+  ['<=  2.0.0', '<=2.0.0'],
+  ['<    2.0.0', '<2.0.0'],
+  ['<\t2.0.0', '<2.0.0'],
+  ['>=0.1.97', '>=0.1.97'],
+  ['0.1.20 || 1.2.4', '0.1.20||1.2.4'],
+  ['>=0.2.3 || <0.0.1', '>=0.2.3||<0.0.1'],
+  ['||', '*'],
+  ['2.x.x', '>=2.0.0 <3.0.0-0'],
+  ['1.2.x', '>=1.2.0 <1.3.0-0'],
+  ['1.2.x || 2.x', '>=1.2.0 <1.3.0-0||>=2.0.0 <3.0.0-0'],
+  ['x', '*'],
+  ['2.*.*', '>=2.0.0 <3.0.0-0'],
+  ['1.2.*', '>=1.2.0 <1.3.0-0'],
+  ['1.2.* || 2.*', '>=1.2.0 <1.3.0-0||>=2.0.0 <3.0.0-0'],
+  ['2', '>=2.0.0 <3.0.0-0'],
+  ['2.3', '>=2.3.0 <2.4.0-0'],
+  ['~2.4', '>=2.4.0 <2.5.0-0'],
+  ['~>3.2.1', '>=3.2.1 <3.3.0-0'],
+  ['~1', '>=1.0.0 <2.0.0-0'],
+  ['~>1', '>=1.0.0 <2.0.0-0'],
+  ['~> 1', '>=1.0.0 <2.0.0-0'],
+  ['~1.0', '>=1.0.0 <1.1.0-0'],
+  ['~ 1.0', '>=1.0.0 <1.1.0-0'],
+  ['^0', '<1.0.0-0'],
+  ['^ 1', '>=1.0.0 <2.0.0-0'],
+  ['^0.1', '>=0.1.0 <0.2.0-0'],
+  ['^1.0', '>=1.0.0 <2.0.0-0'],
+  ['^1.2', '>=1.2.0 <2.0.0-0'],
+  ['^0.0.1', '>=0.0.1 <0.0.2-0'],
+  ['^0.0.1-beta', '>=0.0.1-beta <0.0.2-0'],
+  ['^0.1.2', '>=0.1.2 <0.2.0-0'],
+  ['^1.2.3', '>=1.2.3 <2.0.0-0'],
+  ['^1.2.3-beta.4', '>=1.2.3-beta.4 <2.0.0-0'],
+  ['<1', '<1.0.0-0'],
+  ['< 1', '<1.0.0-0'],
+  ['>=1', '>=1.0.0'],
+  ['>= 1', '>=1.0.0'],
+  ['<1.2', '<1.2.0-0'],
+  ['< 1.2', '<1.2.0-0'],
+  ['>01.02.03', '>1.2.3', true],
+  ['>01.02.03', null],
+  ['~1.2.3beta', '>=1.2.3-beta <1.3.0-0', { loose: true }],
+  ['~1.2.3beta', null],
+  ['^ 1.2 ^ 1', '>=1.2.0 <2.0.0-0 >=1.0.0'],
+  ['1.2 - 3.4.5', '>=1.2.0 <=3.4.5'],
+  ['1.2.3 - 3.4', '>=1.2.3 <3.5.0-0'],
+  ['1.2 - 3.4', '>=1.2.0 <3.5.0-0'],
+  ['>1', '>=2.0.0'],
+  ['>1.2', '>=1.3.0'],
+  ['>X', '<0.0.0-0'],
+  ['<X', '<0.0.0-0'],
+  ['<x <* || >* 2.x', '<0.0.0-0'],
+  ['>x 2.x || * || <x', '*'],
+  ['>=09090', null],
+  ['>=09090', '>=9090.0.0', true],
+  ['>=09090-0', null, { includePrerelease: true }],
+  ['>=09090-0', null, { loose: true, includePrerelease: true }],
+  [`^${MAX_SAFE_INTEGER}.0.0`, null],
+  [`=${MAX_SAFE_INTEGER}.0.0`, `${MAX_SAFE_INTEGER}.0.0`],
+  [`^${MAX_SAFE_INTEGER - 1}.0.0`, `>=${MAX_SAFE_INTEGER - 1}.0.0 <${MAX_SAFE_INTEGER}.0.0-0`],
+]
diff --git a/test/fixtures/version-gt-range.js b/test/fixtures/version-gt-range.js
new file mode 100644
index 00000000..51049924
--- /dev/null
+++ b/test/fixtures/version-gt-range.js
@@ -0,0 +1,60 @@
+// [range, version, options]
+// Version should be greater than range
+module.exports = [
+  ['~1.2.2', '1.3.0'],
+  ['~0.6.1-1', '0.7.1-1'],
+  ['1.0.0 - 2.0.0', '2.0.1'],
+  ['1.0.0', '1.0.1-beta1'],
+  ['1.0.0', '2.0.0'],
+  ['<=2.0.0', '2.1.1'],
+  ['<=2.0.0', '3.2.9'],
+  ['<2.0.0', '2.0.0'],
+  ['0.1.20 || 1.2.4', '1.2.5'],
+  ['2.x.x', '3.0.0'],
+  ['1.2.x', '1.3.0'],
+  ['1.2.x || 2.x', '3.0.0'],
+  ['2.*.*', '5.0.1'],
+  ['1.2.*', '1.3.3'],
+  ['1.2.* || 2.*', '4.0.0'],
+  ['2', '3.0.0'],
+  ['2.3', '2.4.2'],
+  ['~2.4', '2.5.0'], // >=2.4.0 <2.5.0
+  ['~2.4', '2.5.5'],
+  ['~>3.2.1', '3.3.0'], // >=3.2.1 <3.3.0
+  ['~1', '2.2.3'], // >=1.0.0 <2.0.0
+  ['~>1', '2.2.4'],
+  ['~> 1', '3.2.3'],
+  ['~1.0', '1.1.2'], // >=1.0.0 <1.1.0
+  ['~ 1.0', '1.1.0'],
+  ['<1.2', '1.2.0'],
+  ['< 1.2', '1.2.1'],
+  ['1', '2.0.0beta', true],
+  ['~v0.5.4-pre', '0.6.0'],
+  ['~v0.5.4-pre', '0.6.1-pre'],
+  ['=0.7.x', '0.8.0'],
+  ['=0.7.x', '0.8.0-asdf'],
+  ['<0.7.x', '0.7.0'],
+  ['1.0.0 - 2.0.0', '2.2.3'],
+  ['1.0.0', '1.0.1'],
+  ['<=2.0.0', '3.0.0'],
+  ['<=2.0.0', '2.9999.9999'],
+  ['<=2.0.0', '2.2.9'],
+  ['<2.0.0', '2.9999.9999'],
+  ['<2.0.0', '2.2.9'],
+  ['2.x.x', '3.1.3'],
+  ['1.2.x', '1.3.3'],
+  ['1.2.x || 2.x', '3.1.3'],
+  ['2.*.*', '3.1.3'],
+  ['1.2.* || 2.*', '3.1.3'],
+  ['2', '3.1.2'],
+  ['2.3', '2.4.1'],
+  ['~>3.2.1', '3.3.2'], // >=3.2.1 <3.3.0
+  ['~>1', '2.2.3'],
+  ['~1.0', '1.1.0'], // >=1.0.0 <1.1.0
+  ['<1', '1.0.0'],
+  ['<1', '1.0.0beta', true],
+  ['< 1', '1.0.0beta', true],
+  ['=0.7.x', '0.8.2'],
+  ['<0.7.x', '0.7.2'],
+  ['0.7.x', '0.7.2-beta'],
+]
diff --git a/test/fixtures/version-lt-range.js b/test/fixtures/version-lt-range.js
new file mode 100644
index 00000000..55fe5c17
--- /dev/null
+++ b/test/fixtures/version-lt-range.js
@@ -0,0 +1,62 @@
+// [range, version, options]
+// Version should be less than range
+module.exports = [
+  ['~1.2.2', '1.2.1'],
+  ['~0.6.1-1', '0.6.1-0'],
+  ['1.0.0 - 2.0.0', '0.0.1'],
+  ['1.0.0-beta.2', '1.0.0-beta.1'],
+  ['1.0.0', '0.0.0'],
+  ['>=2.0.0', '1.1.1'],
+  ['>=2.0.0', '1.2.9'],
+  ['>2.0.0', '2.0.0'],
+  ['0.1.20 || 1.2.4', '0.1.5'],
+  ['2.x.x', '1.0.0'],
+  ['1.2.x', '1.1.0'],
+  ['1.2.x || 2.x', '1.0.0'],
+  ['2.*.*', '1.0.1'],
+  ['1.2.*', '1.1.3'],
+  ['1.2.* || 2.*', '1.1.9999'],
+  ['2', '1.0.0'],
+  ['2.3', '2.2.2'],
+  ['~2.4', '2.3.0'], // >=2.4.0 <2.5.0
+  ['~2.4', '2.3.5'],
+  ['~>3.2.1', '3.2.0'], // >=3.2.1 <3.3.0
+  ['~1', '0.2.3'], // >=1.0.0 <2.0.0
+  ['~>1', '0.2.4'],
+  ['~> 1', '0.2.3'],
+  ['~1.0', '0.1.2'], // >=1.0.0 <1.1.0
+  ['~ 1.0', '0.1.0'],
+  ['>1.2', '1.2.0'],
+  ['> 1.2', '1.2.1'],
+  ['1', '0.0.0beta', true],
+  ['~v0.5.4-pre', '0.5.4-alpha'],
+  ['=0.7.x', '0.6.0'],
+  ['=0.7.x', '0.6.0-asdf'],
+  ['>=0.7.x', '0.6.0'],
+  ['1.0.0 - 2.0.0', '0.2.3'],
+  ['1.0.0', '0.0.1'],
+  ['>=2.0.0', '1.0.0'],
+  ['>=2.0.0', '1.9999.9999'],
+  ['>2.0.0', '1.2.9'],
+  ['2.x.x', '1.1.3'],
+  ['1.2.x', '1.1.3'],
+  ['1.2.x || 2.x', '1.1.3'],
+  ['2.*.*', '1.1.3'],
+  ['1.2.* || 2.*', '1.1.3'],
+  ['2', '1.9999.9999'],
+  ['2.3', '2.2.1'],
+  ['~>3.2.1', '2.3.2'], // >=3.2.1 <3.3.0
+  ['~>1', '0.2.3'],
+  ['~1.0', '0.0.0'], // >=1.0.0 <1.1.0
+  ['>1', '1.0.0'],
+  ['2', '1.0.0beta', true],
+  ['>1', '1.0.0beta', true],
+  ['> 1', '1.0.0beta', true],
+  ['=0.7.x', '0.6.2'],
+  ['=0.7.x', '0.7.0-asdf'],
+  ['^1', '1.0.0-0'],
+  ['>=0.7.x', '0.7.0-asdf'],
+  ['1', '1.0.0beta', true],
+  ['>=0.7.x', '0.6.2'],
+  ['>1.2.3', '1.3.0-alpha'],
+]
diff --git a/test/fixtures/version-not-gt-range.js b/test/fixtures/version-not-gt-range.js
new file mode 100644
index 00000000..1f40738e
--- /dev/null
+++ b/test/fixtures/version-not-gt-range.js
@@ -0,0 +1,84 @@
+// [range, version, options]
+// Version should NOT be greater than range
+module.exports = [
+  ['~0.6.1-1', '0.6.1-1'],
+  ['1.0.0 - 2.0.0', '1.2.3'],
+  ['1.0.0 - 2.0.0', '0.9.9'],
+  ['1.0.0', '1.0.0'],
+  ['>=*', '0.2.4'],
+  ['', '1.0.0', true],
+  ['*', '1.2.3'],
+  ['*', 'v1.2.3-foo'],
+  ['>=1.0.0', '1.0.0'],
+  ['>=1.0.0', '1.0.1'],
+  ['>=1.0.0', '1.1.0'],
+  ['>1.0.0', '1.0.1'],
+  ['>1.0.0', '1.1.0'],
+  ['<=2.0.0', '2.0.0'],
+  ['<=2.0.0', '1.9999.9999'],
+  ['<=2.0.0', '0.2.9'],
+  ['<2.0.0', '1.9999.9999'],
+  ['<2.0.0', '0.2.9'],
+  ['>= 1.0.0', '1.0.0'],
+  ['>=  1.0.0', '1.0.1'],
+  ['>=   1.0.0', '1.1.0'],
+  ['> 1.0.0', '1.0.1'],
+  ['>  1.0.0', '1.1.0'],
+  ['<=   2.0.0', '2.0.0'],
+  ['<= 2.0.0', '1.9999.9999'],
+  ['<=  2.0.0', '0.2.9'],
+  ['<    2.0.0', '1.9999.9999'],
+  ['<\t2.0.0', '0.2.9'],
+  ['>=0.1.97', 'v0.1.97'],
+  ['>=0.1.97', '0.1.97'],
+  ['0.1.20 || 1.2.4', '1.2.4'],
+  ['0.1.20 || >1.2.4', '1.2.4'],
+  ['0.1.20 || 1.2.4', '1.2.3'],
+  ['0.1.20 || 1.2.4', '0.1.20'],
+  ['>=0.2.3 || <0.0.1', '0.0.0'],
+  ['>=0.2.3 || <0.0.1', '0.2.3'],
+  ['>=0.2.3 || <0.0.1', '0.2.4'],
+  ['||', '1.3.4'],
+  ['2.x.x', '2.1.3'],
+  ['1.2.x', '1.2.3'],
+  ['1.2.x || 2.x', '2.1.3'],
+  ['1.2.x || 2.x', '1.2.3'],
+  ['x', '1.2.3'],
+  ['2.*.*', '2.1.3'],
+  ['1.2.*', '1.2.3'],
+  ['1.2.* || 2.*', '2.1.3'],
+  ['1.2.* || 2.*', '1.2.3'],
+  ['2', '2.1.2'],
+  ['2.3', '2.3.1'],
+  ['~2.4', '2.4.0'], // >=2.4.0 <2.5.0
+  ['~2.4', '2.4.5'],
+  ['~>3.2.1', '3.2.2'], // >=3.2.1 <3.3.0
+  ['~1', '1.2.3'], // >=1.0.0 <2.0.0
+  ['~>1', '1.2.3'],
+  ['~> 1', '1.2.3'],
+  ['~1.0', '1.0.2'], // >=1.0.0 <1.1.0
+  ['~ 1.0', '1.0.2'],
+  ['>=1', '1.0.0'],
+  ['>= 1', '1.0.0'],
+  ['<1.2', '1.1.1'],
+  ['< 1.2', '1.1.1'],
+  ['1', '1.0.0beta', true],
+  ['~v0.5.4-pre', '0.5.5'],
+  ['~v0.5.4-pre', '0.5.4'],
+  ['=0.7.x', '0.7.2'],
+  ['>=0.7.x', '0.7.2'],
+  ['=0.7.x', '0.7.0-asdf'],
+  ['>=0.7.x', '0.7.0-asdf'],
+  ['<=0.7.x', '0.6.2'],
+  ['>0.2.3 >0.2.4 <=0.2.5', '0.2.5'],
+  ['>=0.2.3 <=0.2.4', '0.2.4'],
+  ['1.0.0 - 2.0.0', '2.0.0'],
+  ['^1', '0.0.0-0'],
+  ['^3.0.0', '2.0.0'],
+  ['^1.0.0 || ~2.0.1', '2.0.0'],
+  ['^0.1.0 || ~3.0.1 || 5.0.0', '3.2.0'],
+  ['^0.1.0 || ~3.0.1 || 5.0.0', '1.0.0beta', true],
+  ['^0.1.0 || ~3.0.1 || 5.0.0', '5.0.0-0', true],
+  ['^0.1.0 || ~3.0.1 || >4 <=5.0.0', '3.5.0'],
+  ['0.7.x', '0.7.2-beta', { includePrerelease: true }],
+]
diff --git a/test/fixtures/version-not-lt-range.js b/test/fixtures/version-not-lt-range.js
new file mode 100644
index 00000000..aac7c254
--- /dev/null
+++ b/test/fixtures/version-not-lt-range.js
@@ -0,0 +1,87 @@
+// [range, version, options]
+// Version should NOT be less than range
+module.exports = [
+  ['~ 1.0', '1.1.0'],
+  ['~0.6.1-1', '0.6.1-1'],
+  ['1.0.0 - 2.0.0', '1.2.3'],
+  ['1.0.0 - 2.0.0', '2.9.9'],
+  ['1.0.0', '1.0.0'],
+  ['>=*', '0.2.4'],
+  ['', '1.0.0', true],
+  ['*', '1.2.3'],
+  ['>=1.0.0', '1.0.0'],
+  ['>=1.0.0', '1.0.1'],
+  ['>=1.0.0', '1.1.0'],
+  ['>1.0.0', '1.0.1'],
+  ['>1.0.0', '1.1.0'],
+  ['<=2.0.0', '2.0.0'],
+  ['<=2.0.0', '1.9999.9999'],
+  ['<=2.0.0', '0.2.9'],
+  ['<2.0.0', '1.9999.9999'],
+  ['<2.0.0', '0.2.9'],
+  ['>= 1.0.0', '1.0.0'],
+  ['>=  1.0.0', '1.0.1'],
+  ['>=   1.0.0', '1.1.0'],
+  ['> 1.0.0', '1.0.1'],
+  ['>  1.0.0', '1.1.0'],
+  ['<=   2.0.0', '2.0.0'],
+  ['<= 2.0.0', '1.9999.9999'],
+  ['<=  2.0.0', '0.2.9'],
+  ['<    2.0.0', '1.9999.9999'],
+  ['<\t2.0.0', '0.2.9'],
+  ['>=0.1.97', 'v0.1.97'],
+  ['>=0.1.97', '0.1.97'],
+  ['0.1.20 || 1.2.4', '1.2.4'],
+  ['0.1.20 || >1.2.4', '1.2.4'],
+  ['0.1.20 || 1.2.4', '1.2.3'],
+  ['0.1.20 || 1.2.4', '0.1.20'],
+  ['>=0.2.3 || <0.0.1', '0.0.0'],
+  ['>=0.2.3 || <0.0.1', '0.2.3'],
+  ['>=0.2.3 || <0.0.1', '0.2.4'],
+  ['||', '1.3.4'],
+  ['2.x.x', '2.1.3'],
+  ['1.2.x', '1.2.3'],
+  ['1.2.x || 2.x', '2.1.3'],
+  ['1.2.x || 2.x', '1.2.3'],
+  ['x', '1.2.3'],
+  ['2.*.*', '2.1.3'],
+  ['1.2.*', '1.2.3'],
+  ['1.2.* || 2.*', '2.1.3'],
+  ['1.2.* || 2.*', '1.2.3'],
+  ['2', '2.1.2'],
+  ['2.3', '2.3.1'],
+  ['~2.4', '2.4.0'], // >=2.4.0 <2.5.0
+  ['~2.4', '2.4.5'],
+  ['~>3.2.1', '3.2.2'], // >=3.2.1 <3.3.0
+  ['~1', '1.2.3'], // >=1.0.0 <2.0.0
+  ['~>1', '1.2.3'],
+  ['~> 1', '1.2.3'],
+  ['~1.0', '1.0.2'], // >=1.0.0 <1.1.0
+  ['~ 1.0', '1.0.2'],
+  ['>=1', '1.0.0'],
+  ['>= 1', '1.0.0'],
+  ['<1.2', '1.1.1'],
+  ['< 1.2', '1.1.1'],
+  ['~v0.5.4-pre', '0.5.5'],
+  ['~v0.5.4-pre', '0.5.4'],
+  ['=0.7.x', '0.7.2'],
+  ['>=0.7.x', '0.7.2'],
+  ['<=0.7.x', '0.6.2'],
+  ['>0.2.3 >0.2.4 <=0.2.5', '0.2.5'],
+  ['>=0.2.3 <=0.2.4', '0.2.4'],
+  ['1.0.0 - 2.0.0', '2.0.0'],
+  ['^3.0.0', '4.0.0'],
+  ['^1.0.0 || ~2.0.1', '2.0.0'],
+  ['^0.1.0 || ~3.0.1 || 5.0.0', '3.2.0'],
+  ['^0.1.0 || ~3.0.1 || 5.0.0', '1.0.0beta', true],
+  ['^0.1.0 || ~3.0.1 || 5.0.0', '5.0.0-0', true],
+  ['^0.1.0 || ~3.0.1 || >4 <=5.0.0', '3.5.0'],
+  ['^1.0.0alpha', '1.0.0beta', true],
+  ['~1.0.0alpha', '1.0.0beta', true],
+  ['^1.0.0-alpha', '1.0.0beta', true],
+  ['~1.0.0-alpha', '1.0.0beta', true],
+  ['^1.0.0-alpha', '1.0.0-beta'],
+  ['~1.0.0-alpha', '1.0.0-beta'],
+  ['=0.1.0', '1.0.0'],
+  ['>1.2.3', '1.3.0-alpha', { includePrerelease: true }],
+]
diff --git a/test/clean.js b/test/functions/clean.js
similarity index 59%
rename from test/clean.js
rename to test/functions/clean.js
index d48c149e..830e824b 100644
--- a/test/clean.js
+++ b/test/functions/clean.js
@@ -1,9 +1,7 @@
-var tap = require('tap')
-var test = tap.test
-var semver = require('../semver.js')
-var clean = semver.clean
+const { test } = require('tap')
+const clean = require('../../functions/clean')
 
-test('\nclean tests', function (t) {
+test('clean tests', (t) => {
   // [range, version]
   // Version should be detectable despite extra characters
   [
@@ -18,11 +16,10 @@ test('\nclean tests', function (t) {
     ['>1.2.3', null],
     ['~1.2.3', null],
     ['<=1.2.3', null],
-    ['1.2.x', null]
-  ].forEach(function (tuple) {
-    var range = tuple[0]
-    var version = tuple[1]
-    var msg = 'clean(' + range + ') = ' + version
+    ['1.2.x', null],
+    ['0.12.0-dev.1150+3c22cecee', '0.12.0-dev.1150'],
+  ].forEach(([range, version]) => {
+    const msg = `clean(${range}) = ${version}`
     t.equal(clean(range), version, msg)
   })
   t.end()
diff --git a/test/functions/cmp.js b/test/functions/cmp.js
new file mode 100644
index 00000000..d7f572a2
--- /dev/null
+++ b/test/functions/cmp.js
@@ -0,0 +1,49 @@
+const { test } = require('tap')
+const cmp = require('../../functions/cmp')
+const comparisons = require('../fixtures/comparisons.js')
+const equality = require('../fixtures/equality.js')
+const SemVer = require('../../classes/semver')
+
+test('invalid cmp usage', (t) => {
+  t.throws(() => {
+    cmp('1.2.3', 'a frog', '4.5.6')
+  }, new TypeError('Invalid operator: a frog'))
+  t.end()
+})
+
+test('comparison tests', t => {
+  t.plan(comparisons.length)
+  comparisons.forEach(([v0, v1, loose]) => t.test(`${v0} ${v1} ${loose}`, t => {
+    t.plan(8)
+    t.ok(cmp(v0, '>', v1, loose), `cmp('${v0}' > '${v1}')`)
+    t.ok(cmp(v1, '<', v0, loose), `cmp('${v1}' < '${v0}')`)
+    t.ok(!cmp(v1, '>', v0, loose), `!cmp('${v1}' > '${v0}')`)
+    t.ok(!cmp(v0, '<', v1, loose), `!cmp('${v0}' < '${v1}')`)
+    t.ok(cmp(v1, '==', v1, loose), `cmp('${v1}' == '${v1}')`)
+    t.ok(cmp(v0, '>=', v1, loose), `cmp('${v0}' >= '${v1}')`)
+    t.ok(cmp(v1, '<=', v0, loose), `cmp('${v1}' <= '${v0}')`)
+    t.ok(cmp(v0, '!=', v1, loose), `cmp('${v0}' != '${v1}')`)
+  }))
+})
+
+test('equality tests', t => {
+  t.plan(equality.length)
+  equality.forEach(([v0, v1, loose]) => t.test(`${v0} ${v1} ${loose}`, t => {
+    t.plan(8)
+    t.ok(cmp(v0, '', v1, loose), `cmp(${v0} "" ${v1})`)
+    t.ok(cmp(v0, '=', v1, loose), `cmp(${v0}=${v1})`)
+    t.ok(cmp(v0, '==', v1, loose), `cmp(${v0}==${v1})`)
+    t.ok(!cmp(v0, '!=', v1, loose), `!cmp(${v0}!=${v1})`)
+    t.ok(!cmp(v0, '===', v1, loose), `!cmp(${v0}===${v1})`)
+
+    // also test with an object. they are === because obj.version matches
+    t.ok(cmp(new SemVer(v0, { loose: loose }), '===',
+      new SemVer(v1, { loose: loose })),
+    `!cmp(${v0}===${v1}) object`)
+
+    t.ok(cmp(v0, '!==', v1, loose), `cmp(${v0}!==${v1})`)
+
+    t.ok(!cmp(new SemVer(v0, loose), '!==', new SemVer(v1, loose)),
+      `cmp(${v0}!==${v1}) object`)
+  }))
+})
diff --git a/test/functions/coerce.js b/test/functions/coerce.js
new file mode 100644
index 00000000..24e2ff76
--- /dev/null
+++ b/test/functions/coerce.js
@@ -0,0 +1,157 @@
+const { test } = require('tap')
+const coerce = require('../../functions/coerce')
+const parse = require('../../functions/parse')
+const valid = require('../../functions/valid')
+
+test('coerce tests', (t) => {
+  // Expected to be null (cannot be coerced).
+  const coerceToNull = [
+    null,
+    { version: '1.2.3' },
+    function () {
+      return '1.2.3'
+    },
+    '',
+    '.',
+    'version one',
+    '9'.repeat(16),
+    '1'.repeat(17),
+    `a${'9'.repeat(16)}`,
+    `a${'1'.repeat(17)}`,
+    `${'9'.repeat(16)}a`,
+    `${'1'.repeat(17)}a`,
+    `${'9'.repeat(16)}.4.7.4`,
+    `${'9'.repeat(16)}.${'2'.repeat(16)}.${'3'.repeat(16)}`,
+    `${'1'.repeat(16)}.${'9'.repeat(16)}.${'3'.repeat(16)}`,
+    `${'1'.repeat(16)}.${'2'.repeat(16)}.${'9'.repeat(16)}`,
+  ]
+  coerceToNull.forEach((input) => {
+    const msg = `coerce(${input}) should be null`
+    t.same(coerce(input), null, msg)
+  })
+
+  // Expected to be valid.
+  const coerceToValid = [
+    [parse('1.2.3'), '1.2.3'],
+    ['.1', '1.0.0'],
+    ['.1.', '1.0.0'],
+    ['..1', '1.0.0'],
+    ['.1.1', '1.1.0'],
+    ['1.', '1.0.0'],
+    ['1.0', '1.0.0'],
+    ['1.0.0', '1.0.0'],
+    ['0', '0.0.0'],
+    ['0.0', '0.0.0'],
+    ['0.0.0', '0.0.0'],
+    ['0.1', '0.1.0'],
+    ['0.0.1', '0.0.1'],
+    ['0.1.1', '0.1.1'],
+    ['1', '1.0.0'],
+    ['1.2', '1.2.0'],
+    ['1.2.3', '1.2.3'],
+    ['1.2.3.4', '1.2.3'],
+    ['13', '13.0.0'],
+    ['35.12', '35.12.0'],
+    ['35.12.18', '35.12.18'],
+    ['35.12.18.24', '35.12.18'],
+    ['v1', '1.0.0'],
+    ['v1.2', '1.2.0'],
+    ['v1.2.3', '1.2.3'],
+    ['v1.2.3.4', '1.2.3'],
+    [' 1', '1.0.0'],
+    ['1 ', '1.0.0'],
+    ['1 0', '1.0.0'],
+    ['1 1', '1.0.0'],
+    ['1.1 1', '1.1.0'],
+    ['1.1-1', '1.1.0'],
+    ['1.1-1', '1.1.0'],
+    ['a1', '1.0.0'],
+    ['a1a', '1.0.0'],
+    ['1a', '1.0.0'],
+    ['version 1', '1.0.0'],
+    ['version1', '1.0.0'],
+    ['version1.0', '1.0.0'],
+    ['version1.1', '1.1.0'],
+    ['42.6.7.9.3-alpha', '42.6.7'],
+    ['v2', '2.0.0'],
+    ['v3.4 replaces v3.3.1', '3.4.0'],
+    ['4.6.3.9.2-alpha2', '4.6.3'],
+    [`${'1'.repeat(17)}.2`, '2.0.0'],
+    [`${'1'.repeat(17)}.2.3`, '2.3.0'],
+    [`1.${'2'.repeat(17)}.3`, '1.0.0'],
+    [`1.2.${'3'.repeat(17)}`, '1.2.0'],
+    [`${'1'.repeat(17)}.2.3.4`, '2.3.4'],
+    [`1.${'2'.repeat(17)}.3.4`, '1.0.0'],
+    [`1.2.${'3'.repeat(17)}.4`, '1.2.0'],
+    [`${'1'.repeat(17)}.${'2'.repeat(16)}.${'3'.repeat(16)}`,
+      `${'2'.repeat(16)}.${'3'.repeat(16)}.0`],
+    [`${'1'.repeat(16)}.${'2'.repeat(17)}.${'3'.repeat(16)}`,
+      `${'1'.repeat(16)}.0.0`],
+    [`${'1'.repeat(16)}.${'2'.repeat(16)}.${'3'.repeat(17)}`,
+      `${'1'.repeat(16)}.${'2'.repeat(16)}.0`],
+    [`11${'.1'.repeat(126)}`, '11.1.1'],
+    ['1'.repeat(16), `${'1'.repeat(16)}.0.0`],
+    [`a${'1'.repeat(16)}`, `${'1'.repeat(16)}.0.0`],
+    [`${'1'.repeat(16)}.2.3.4`, `${'1'.repeat(16)}.2.3`],
+    [`1.${'2'.repeat(16)}.3.4`, `1.${'2'.repeat(16)}.3`],
+    [`1.2.${'3'.repeat(16)}.4`, `1.2.${'3'.repeat(16)}`],
+    [`${'1'.repeat(16)}.${'2'.repeat(16)}.${'3'.repeat(16)}`,
+      `${'1'.repeat(16)}.${'2'.repeat(16)}.${'3'.repeat(16)}`],
+    [`1.2.3.${'4'.repeat(252)}.5`, '1.2.3'],
+    [`1.2.3.${'4'.repeat(1024)}`, '1.2.3'],
+    [`${'1'.repeat(17)}.4.7.4`, '4.7.4'],
+    [10, '10.0.0'],
+    ['1.2.3/a/b/c/2.3.4', '2.3.4', { rtl: true }],
+    ['1.2.3.4.5.6', '4.5.6', { rtl: true }],
+    ['1.2.3.4.5/6', '6.0.0', { rtl: true }],
+    ['1.2.3.4./6', '6.0.0', { rtl: true }],
+    ['1.2.3.4/6', '6.0.0', { rtl: true }],
+    ['1.2.3./6', '6.0.0', { rtl: true }],
+    ['1.2.3/6', '6.0.0', { rtl: true }],
+    ['1.2.3.4', '2.3.4', { rtl: true }],
+    ['1.2.3.4xyz', '2.3.4', { rtl: true }],
+
+    ['1-rc.5', '1.0.0-rc.5', { includePrerelease: true }],
+    ['1.2-rc.5', '1.2.0-rc.5', { includePrerelease: true }],
+    ['1.2.3-rc.5', '1.2.3-rc.5', { includePrerelease: true }],
+    ['1.2.3-rc.5/a', '1.2.3-rc.5', { includePrerelease: true }],
+    ['1.2.3.4-rc.5', '1.2.3', { includePrerelease: true }],
+    ['1.2.3.4+rev.6', '1.2.3', { includePrerelease: true }],
+
+    ['1+rev.6', '1.0.0+rev.6', { includePrerelease: true }],
+    ['1.2+rev.6', '1.2.0+rev.6', { includePrerelease: true }],
+    ['1.2.3+rev.6', '1.2.3+rev.6', { includePrerelease: true }],
+    ['1.2.3+rev.6/a', '1.2.3+rev.6', { includePrerelease: true }],
+    ['1.2.3.4-rc.5', '1.2.3', { includePrerelease: true }],
+    ['1.2.3.4+rev.6', '1.2.3', { includePrerelease: true }],
+
+    ['1-rc.5+rev.6', '1.0.0-rc.5+rev.6', { includePrerelease: true }],
+    ['1.2-rc.5+rev.6', '1.2.0-rc.5+rev.6', { includePrerelease: true }],
+    ['1.2.3-rc.5+rev.6', '1.2.3-rc.5+rev.6', { includePrerelease: true }],
+    ['1.2.3-rc.5+rev.6/a', '1.2.3-rc.5+rev.6', { includePrerelease: true }],
+
+    ['1.2-rc.5+rev.6', '1.2.0-rc.5+rev.6', { rtl: true, includePrerelease: true }],
+    ['1.2.3-rc.5+rev.6', '1.2.3-rc.5+rev.6', { rtl: true, includePrerelease: true }],
+    ['1.2.3.4-rc.5+rev.6', '2.3.4-rc.5+rev.6', { rtl: true, includePrerelease: true }],
+    ['1.2.3.4-rc.5', '2.3.4-rc.5', { rtl: true, includePrerelease: true }],
+    ['1.2.3.4+rev.6', '2.3.4+rev.6', { rtl: true, includePrerelease: true }],
+    ['1.2.3.4-rc.5+rev.6/7', '7.0.0', { rtl: true, includePrerelease: true }],
+    ['1.2.3.4-rc/7.5+rev.6', '7.5.0+rev.6', { rtl: true, includePrerelease: true }],
+    ['1.2.3.4/7-rc.5+rev.6', '7.0.0-rc.5+rev.6', { rtl: true, includePrerelease: true }],
+  ]
+  coerceToValid.forEach(([input, expected, options]) => {
+    const coerceExpression = `coerce(${input}, ${JSON.stringify(options)})`
+    const coercedVersion = coerce(input, options) || {}
+    const expectedVersion = parse(expected)
+    t.equal(expectedVersion.compare(coercedVersion), 0,
+      `${coerceExpression} should be equal to ${expectedVersion}`)
+    t.equal(expectedVersion.compareBuild(coercedVersion), 0,
+      `${coerceExpression} build should be equal to ${expectedVersion}`)
+  })
+
+  t.same(valid(coerce('42.6.7.9.3-alpha')), '42.6.7')
+  t.same(valid(coerce('42.6.7-alpha+rev.1', { includePrerelease: true })), '42.6.7-alpha')
+  t.same(valid(coerce('v2')), '2.0.0')
+
+  t.end()
+})
diff --git a/test/functions/compare-build.js b/test/functions/compare-build.js
new file mode 100644
index 00000000..7f8a76c1
--- /dev/null
+++ b/test/functions/compare-build.js
@@ -0,0 +1,19 @@
+const { test } = require('tap')
+const compareBuild = require('../../functions/compare-build')
+
+test('compareBuild', (t) => {
+  const noBuild = '1.0.0'
+  const build0 = '1.0.0+0'
+  const build1 = '1.0.0+1'
+  const build10 = '1.0.0+1.0'
+  t.equal(compareBuild(noBuild, build0), -1)
+  t.equal(compareBuild(build0, build0), 0)
+  t.equal(compareBuild(build0, noBuild), 1)
+
+  t.equal(compareBuild(build0, '1.0.0+0.0'), -1)
+  t.equal(compareBuild(build0, build1), -1)
+  t.equal(compareBuild(build1, build0), 1)
+  t.equal(compareBuild(build10, build1), 1)
+
+  t.end()
+})
diff --git a/test/functions/compare-loose.js b/test/functions/compare-loose.js
new file mode 100644
index 00000000..36c31832
--- /dev/null
+++ b/test/functions/compare-loose.js
@@ -0,0 +1,30 @@
+const { test } = require('tap')
+const compareLoose = require('../../functions/compare-loose')
+const SemVer = require('../../classes/semver')
+const eq = require('../../functions/eq')
+
+test('strict vs loose version numbers', (t) => {
+  [['=1.2.3', '1.2.3'],
+    ['01.02.03', '1.2.3'],
+    ['1.2.3-beta.01', '1.2.3-beta.1'],
+    ['   =1.2.3', '1.2.3'],
+    ['1.2.3foo', '1.2.3-foo'],
+  ].forEach((v) => {
+    const loose = v[0]
+    const strict = v[1]
+    t.throws(() => {
+      SemVer(loose) // eslint-disable-line no-new
+    })
+    const lv = new SemVer(loose, true)
+    t.equal(lv.version, strict)
+    t.ok(eq(loose, strict, true))
+    t.throws(() => {
+      eq(loose, strict)
+    })
+    t.throws(() => {
+      new SemVer(strict).compare(loose)
+    })
+    t.equal(compareLoose(v[0], v[1]), 0)
+  })
+  t.end()
+})
diff --git a/test/functions/compare.js b/test/functions/compare.js
new file mode 100644
index 00000000..6c519893
--- /dev/null
+++ b/test/functions/compare.js
@@ -0,0 +1,35 @@
+const { test } = require('tap')
+const compare = require('../../functions/compare.js')
+const comparisons = require('../fixtures/comparisons.js')
+const equality = require('../fixtures/equality.js')
+const SemVer = require('../../classes/semver.js')
+
+test('comparison tests', t => {
+  t.plan(comparisons.length)
+  comparisons.forEach(([v0, v1, loose]) => t.test(`${v0} ${v1} ${loose}`, t => {
+    t.plan(4)
+    t.equal(compare(v0, v1, loose), 1, `compare('${v0}', '${v1}')`)
+    t.equal(compare(v1, v0, loose), -1, `compare('${v1}', '${v0}')`)
+    t.equal(compare(v0, v0, loose), 0, `compare('${v0}', '${v0}')`)
+    t.equal(compare(v1, v1, loose), 0, `compare('${v1}', '${v1}')`)
+  }))
+})
+
+test('equality tests', (t) => {
+  // [version1, version2]
+  // version1 should be equivalent to version2
+  t.plan(equality.length)
+  equality.forEach(([v0, v1, loose]) => t.test(`${v0} ${v1} ${loose}`, t => {
+    t.plan(5)
+    t.equal(compare(v0, v1, loose), 0, `${v0} ${v1}`)
+    t.equal(compare(v1, v0, loose), 0, `${v1} ${v0}`)
+    t.equal(compare(v0, v0, loose), 0, `${v0} ${v0}`)
+    t.equal(compare(v1, v1, loose), 0, `${v1} ${v1}`)
+
+    // also test with an object. they are === because obj.version matches
+    t.equal(compare(new SemVer(v0, { loose: loose }),
+      new SemVer(v1, { loose: loose })), 0,
+    `compare(${v0}, ${v1}) object`)
+  }))
+  t.end()
+})
diff --git a/test/functions/diff.js b/test/functions/diff.js
new file mode 100644
index 00000000..720e159b
--- /dev/null
+++ b/test/functions/diff.js
@@ -0,0 +1,57 @@
+const { test } = require('tap')
+const diff = require('../../functions/diff')
+
+test('diff versions test', (t) => {
+//  [version1, version2, result]
+//  diff(version1, version2) -> result
+  [
+    ['1.2.3', '0.2.3', 'major'],
+    ['0.2.3', '1.2.3', 'major'],
+    ['1.4.5', '0.2.3', 'major'],
+    ['1.2.3', '2.0.0-pre', 'premajor'],
+    ['2.0.0-pre', '1.2.3', 'premajor'],
+    ['1.2.3', '1.3.3', 'minor'],
+    ['1.0.1', '1.1.0-pre', 'preminor'],
+    ['1.2.3', '1.2.4', 'patch'],
+    ['1.2.3', '1.2.4-pre', 'prepatch'],
+    ['0.0.1', '0.0.1-pre', 'patch'],
+    ['0.0.1', '0.0.1-pre-2', 'patch'],
+    ['1.1.0', '1.1.0-pre', 'minor'],
+    ['1.1.0-pre-1', '1.1.0-pre-2', 'prerelease'],
+    ['1.0.0', '1.0.0', null],
+    ['1.0.0-1', '1.0.0-1', null],
+    ['0.0.2-1', '0.0.2', 'patch'],
+    ['0.0.2-1', '0.0.3', 'patch'],
+    ['0.0.2-1', '0.1.0', 'minor'],
+    ['0.0.2-1', '1.0.0', 'major'],
+    ['0.1.0-1', '0.1.0', 'minor'],
+    ['1.0.0-1', '1.0.0', 'major'],
+    ['1.0.0-1', '1.1.1', 'major'],
+    ['1.0.0-1', '2.1.1', 'major'],
+    ['1.0.1-1', '1.0.1', 'patch'],
+    ['0.0.0-1', '0.0.0', 'major'],
+    ['1.0.0-1', '2.0.0', 'major'],
+    ['1.0.0-1', '2.0.0-1', 'premajor'],
+    ['1.0.0-1', '1.1.0-1', 'preminor'],
+    ['1.0.0-1', '1.0.1-1', 'prepatch'],
+  ].forEach((v) => {
+    const version1 = v[0]
+    const version2 = v[1]
+    const wanted = v[2]
+    const found = diff(version1, version2)
+    const cmd = `diff(${version1}, ${version2})`
+    t.equal(found, wanted, `${cmd} === ${wanted}`)
+  })
+
+  t.end()
+})
+
+test('throws on bad version', (t) => {
+  t.throws(() => {
+    diff('bad', '1.2.3')
+  }, {
+    message: 'Invalid Version: bad',
+    name: 'TypeError',
+  })
+  t.end()
+})
diff --git a/test/functions/eq.js b/test/functions/eq.js
new file mode 100644
index 00000000..24ce7724
--- /dev/null
+++ b/test/functions/eq.js
@@ -0,0 +1,26 @@
+const { test } = require('tap')
+const eq = require('../../functions/eq')
+const comparisons = require('../fixtures/comparisons.js')
+const equality = require('../fixtures/equality.js')
+
+test('comparison tests', t => {
+  t.plan(comparisons.length)
+  comparisons.forEach(([v0, v1, loose]) => t.test(`${v0} ${v1} ${loose}`, t => {
+    t.plan(4)
+    t.notOk(eq(v0, v1, loose), `!eq(${v0}, ${v1})`)
+    t.notOk(eq(v1, v0, loose), `!eq(${v1}, ${v0})`)
+    t.ok(eq(v1, v1, loose), `eq('${v1}', '${v1}')`)
+    t.ok(eq(v0, v0, loose), `eq('${v0}', '${v0}')`)
+  }))
+})
+
+test('equality tests', t => {
+  t.plan(equality.length)
+  equality.forEach(([v0, v1, loose]) => t.test(`${v0} ${v1} ${loose}`, t => {
+    t.plan(4)
+    t.ok(eq(v0, v1, loose), `eq(${v0}, ${v1})`)
+    t.ok(eq(v1, v0, loose), `eq(${v1}, ${v0})`)
+    t.ok(eq(v0, v0, loose), `eq(${v0}, ${v0})`)
+    t.ok(eq(v1, v1, loose), `eq(${v1}, ${v1})`)
+  }))
+})
diff --git a/test/functions/gt.js b/test/functions/gt.js
new file mode 100644
index 00000000..04c774c5
--- /dev/null
+++ b/test/functions/gt.js
@@ -0,0 +1,24 @@
+const { test } = require('tap')
+const gt = require('../../functions/gt')
+const comparisons = require('../fixtures/comparisons.js')
+const equality = require('../fixtures/equality.js')
+
+test('comparison tests', t => {
+  t.plan(comparisons.length)
+  comparisons.forEach(([v0, v1, loose]) => t.test(`${v0} ${v1} ${loose}`, t => {
+    t.plan(4)
+    t.ok(gt(v0, v1, loose), `gt('${v0}', '${v1}')`)
+    t.ok(!gt(v1, v0, loose), `!gt('${v1}', '${v0}')`)
+    t.ok(!gt(v1, v1, loose), `!gt('${v1}', '${v1}')`)
+    t.ok(!gt(v0, v0, loose), `!gt('${v0}', '${v0}')`)
+  }))
+})
+
+test('equality tests', t => {
+  t.plan(equality.length)
+  equality.forEach(([v0, v1, loose]) => t.test(`${v0} ${v1} ${loose}`, t => {
+    t.plan(2)
+    t.ok(!gt(v0, v1, loose), `!gt(${v0}, ${v1})`)
+    t.ok(!gt(v1, v0, loose), `!gt(${v1}, ${v0})`)
+  }))
+})
diff --git a/test/functions/gte.js b/test/functions/gte.js
new file mode 100644
index 00000000..c70e764a
--- /dev/null
+++ b/test/functions/gte.js
@@ -0,0 +1,24 @@
+const { test } = require('tap')
+const gte = require('../../functions/gte')
+const comparisons = require('../fixtures/comparisons.js')
+const equality = require('../fixtures/equality.js')
+
+test('comparison tests', t => {
+  t.plan(comparisons.length)
+  comparisons.forEach(([v0, v1, loose]) => t.test(`${v0} ${v1} ${loose}`, t => {
+    t.plan(4)
+    t.ok(gte(v0, v1, loose), `gte('${v0}', '${v1}')`)
+    t.ok(!gte(v1, v0, loose), `!gte('${v1}', '${v0}')`)
+    t.ok(gte(v1, v1, loose), `gte('${v1}', '${v1}')`)
+    t.ok(gte(v0, v0, loose), `gte('${v0}', '${v0}')`)
+  }))
+})
+
+test('equality tests', t => {
+  t.plan(equality.length)
+  equality.forEach(([v0, v1, loose]) => t.test(`${v0} ${v1} ${loose}`, t => {
+    t.plan(2)
+    t.ok(gte(v0, v1, loose), `gte(${v0}, ${v1})`)
+    t.ok(gte(v1, v0, loose), `gte(${v1}, ${v0})`)
+  }))
+})
diff --git a/test/functions/inc.js b/test/functions/inc.js
new file mode 100644
index 00000000..2f6f9bb4
--- /dev/null
+++ b/test/functions/inc.js
@@ -0,0 +1,45 @@
+const { test } = require('tap')
+const inc = require('../../functions/inc')
+const parse = require('../../functions/parse')
+const increments = require('../fixtures/increments.js')
+
+test('increment versions test', (t) => {
+  increments.forEach(([pre, what, wanted, options, id, base]) => {
+    const found = inc(pre, what, options, id, base)
+    const cmd = `inc(${pre}, ${what}, ${id}, ${base})`
+    t.equal(found, wanted, `${cmd} === ${wanted}`)
+
+    const parsed = parse(pre, options)
+    const parsedAsInput = parse(pre, options)
+    if (wanted) {
+      parsed.inc(what, id, base)
+      t.equal(parsed.version, wanted, `${cmd} object version updated`)
+      if (parsed.build.length) {
+        t.equal(
+          parsed.raw,
+          `${wanted}+${parsed.build.join('.')}`,
+          `${cmd} object raw field updated with build`
+        )
+      } else {
+        t.equal(parsed.raw, wanted, `${cmd} object raw field updated`)
+      }
+
+      const preIncObject = JSON.stringify(parsedAsInput)
+      inc(parsedAsInput, what, options, id, base)
+      const postIncObject = JSON.stringify(parsedAsInput)
+      t.equal(
+        postIncObject,
+        preIncObject,
+        `${cmd} didn't modify its input`
+      )
+    } else if (parsed) {
+      t.throws(() => {
+        parsed.inc(what, id, base)
+      })
+    } else {
+      t.equal(parsed, null)
+    }
+  })
+
+  t.end()
+})
diff --git a/test/functions/lt.js b/test/functions/lt.js
new file mode 100644
index 00000000..f8760f69
--- /dev/null
+++ b/test/functions/lt.js
@@ -0,0 +1,24 @@
+const { test } = require('tap')
+const lt = require('../../functions/lt')
+const comparisons = require('../fixtures/comparisons.js')
+const equality = require('../fixtures/equality.js')
+
+test('comparison tests', t => {
+  t.plan(comparisons.length)
+  comparisons.forEach(([v0, v1, loose]) => t.test(`${v0} ${v1} ${loose}`, t => {
+    t.plan(4)
+    t.ok(!lt(v0, v1, loose), `!lt('${v0}', '${v1}')`)
+    t.ok(lt(v1, v0, loose), `lt('${v1}', '${v0}')`)
+    t.ok(!lt(v1, v1, loose), `!lt('${v1}', '${v1}')`)
+    t.ok(!lt(v0, v0, loose), `!lt('${v0}', '${v0}')`)
+  }))
+})
+
+test('equality tests', t => {
+  t.plan(equality.length)
+  equality.forEach(([v0, v1, loose]) => t.test(`${v0} ${v1} ${loose}`, t => {
+    t.plan(2)
+    t.ok(!lt(v0, v1, loose), `!lt(${v0}, ${v1})`)
+    t.ok(!lt(v1, v0, loose), `!lt(${v1}, ${v0})`)
+  }))
+})
diff --git a/test/functions/lte.js b/test/functions/lte.js
new file mode 100644
index 00000000..074ce614
--- /dev/null
+++ b/test/functions/lte.js
@@ -0,0 +1,24 @@
+const { test } = require('tap')
+const lte = require('../../functions/lte')
+const comparisons = require('../fixtures/comparisons.js')
+const equality = require('../fixtures/equality.js')
+
+test('comparison tests', t => {
+  t.plan(comparisons.length)
+  comparisons.forEach(([v0, v1, loose]) => t.test(`${v0} ${v1} ${loose}`, t => {
+    t.plan(4)
+    t.ok(!lte(v0, v1, loose), `!lte('${v0}', '${v1}')`)
+    t.ok(lte(v1, v0, loose), `lte('${v1}', '${v0}')`)
+    t.ok(lte(v1, v1, loose), `lte('${v1}', '${v1}')`)
+    t.ok(lte(v0, v0, loose), `lte('${v0}', '${v0}')`)
+  }))
+})
+
+test('equality tests', t => {
+  t.plan(equality.length)
+  equality.forEach(([v0, v1, loose]) => t.test(`${v0} ${v1} ${loose}`, t => {
+    t.plan(2)
+    t.ok(lte(v0, v1, loose), `lte(${v0}, ${v1})`)
+    t.ok(lte(v1, v0, loose), `lte(${v1}, ${v0})`)
+  }))
+})
diff --git a/test/functions/major.js b/test/functions/major.js
new file mode 100644
index 00000000..e04468ea
--- /dev/null
+++ b/test/functions/major.js
@@ -0,0 +1,25 @@
+const { test } = require('tap')
+const major = require('../../functions/major')
+
+test('major tests', (t) => {
+  // [range, version]
+  // Version should be detectable despite extra characters
+  [
+    ['1.2.3', 1],
+    [' 1.2.3 ', 1],
+    [' 2.2.3-4 ', 2],
+    [' 3.2.3-pre ', 3],
+    ['v5.2.3', 5],
+    [' v8.2.3 ', 8],
+    ['\t13.2.3', 13],
+    ['=21.2.3', 21, true],
+    ['v=34.2.3', 34, true],
+  ].forEach((tuple) => {
+    const range = tuple[0]
+    const version = tuple[1]
+    const loose = tuple[2] || false
+    const msg = `major(${range}) = ${version}`
+    t.equal(major(range, loose), version, msg)
+  })
+  t.end()
+})
diff --git a/test/functions/minor.js b/test/functions/minor.js
new file mode 100644
index 00000000..8abe7dd5
--- /dev/null
+++ b/test/functions/minor.js
@@ -0,0 +1,25 @@
+const { test } = require('tap')
+const minor = require('../../functions/minor')
+
+test('minor tests', (t) => {
+  // [range, version]
+  // Version should be detectable despite extra characters
+  [
+    ['1.1.3', 1],
+    [' 1.1.3 ', 1],
+    [' 1.2.3-4 ', 2],
+    [' 1.3.3-pre ', 3],
+    ['v1.5.3', 5],
+    [' v1.8.3 ', 8],
+    ['\t1.13.3', 13],
+    ['=1.21.3', 21, true],
+    ['v=1.34.3', 34, true],
+  ].forEach((tuple) => {
+    const range = tuple[0]
+    const version = tuple[1]
+    const loose = tuple[2] || false
+    const msg = `minor(${range}) = ${version}`
+    t.equal(minor(range, loose), version, msg)
+  })
+  t.end()
+})
diff --git a/test/functions/neq.js b/test/functions/neq.js
new file mode 100644
index 00000000..c259369b
--- /dev/null
+++ b/test/functions/neq.js
@@ -0,0 +1,26 @@
+const { test } = require('tap')
+const neq = require('../../functions/neq')
+const comparisons = require('../fixtures/comparisons.js')
+const equality = require('../fixtures/equality.js')
+
+test('comparison tests', t => {
+  t.plan(comparisons.length)
+  comparisons.forEach(([v0, v1, loose]) => t.test(`${v0} ${v1} ${loose}`, t => {
+    t.plan(4)
+    t.ok(neq(v0, v1, loose), `neq(${v0}, ${v1})`)
+    t.ok(neq(v1, v0, loose), `neq(${v1}, ${v0})`)
+    t.notOk(neq(v1, v1, loose), `!neq('${v1}', '${v1}')`)
+    t.notOk(neq(v0, v0, loose), `!neq('${v0}', '${v0}')`)
+  }))
+})
+
+test('equality tests', t => {
+  t.plan(equality.length)
+  equality.forEach(([v0, v1, loose]) => t.test(`${v0} ${v1} ${loose}`, t => {
+    t.plan(4)
+    t.notOk(neq(v0, v1, loose), `!neq(${v0}, ${v1})`)
+    t.notOk(neq(v1, v0, loose), `!neq(${v1}, ${v0})`)
+    t.notOk(neq(v0, v0, loose), `!neq(${v0}, ${v0})`)
+    t.notOk(neq(v1, v1, loose), `!neq(${v1}, ${v1})`)
+  }))
+})
diff --git a/test/functions/parse.js b/test/functions/parse.js
new file mode 100644
index 00000000..dd091e94
--- /dev/null
+++ b/test/functions/parse.js
@@ -0,0 +1,36 @@
+const t = require('tap')
+const parse = require('../../functions/parse')
+const SemVer = require('../../classes/semver')
+const invalidVersions = require('../fixtures/invalid-versions')
+
+t.test('returns null instead of throwing when presented with garbage', t => {
+  t.plan(invalidVersions.length)
+  invalidVersions.forEach(([v, msg, opts]) =>
+    t.equal(parse(v, opts), null, msg))
+})
+
+t.test('throw errors if asked to', t => {
+  t.throws(() => {
+    parse('bad', null, true)
+  }, {
+    name: 'TypeError',
+    message: 'Invalid Version: bad',
+  })
+  t.throws(() => {
+    parse([], null, true)
+  }, {
+    name: 'TypeError',
+    message: 'Invalid version. Must be a string. Got type "object".',
+  })
+  t.end()
+})
+
+t.test('parse a version into a SemVer object', t => {
+  t.match(parse('1.2.3'), new SemVer('1.2.3'))
+  const s = new SemVer('4.5.6')
+  t.equal(parse(s), s, 'just return it if its a SemVer obj')
+  const loose = new SemVer('4.2.0', { loose: true })
+  t.match(parse('4.2.0', true), loose, 'looseness as a boolean')
+  t.match(parse('4.2.0', { loose: true }), loose, 'looseness as an option')
+  t.end()
+})
diff --git a/test/functions/patch.js b/test/functions/patch.js
new file mode 100644
index 00000000..20aeb8cd
--- /dev/null
+++ b/test/functions/patch.js
@@ -0,0 +1,25 @@
+const { test } = require('tap')
+const patch = require('../../functions/patch')
+
+test('patch tests', (t) => {
+  // [range, version]
+  // Version should be detectable despite extra characters
+  [
+    ['1.2.1', 1],
+    [' 1.2.1 ', 1],
+    [' 1.2.2-4 ', 2],
+    [' 1.2.3-pre ', 3],
+    ['v1.2.5', 5],
+    [' v1.2.8 ', 8],
+    ['\t1.2.13', 13],
+    ['=1.2.21', 21, true],
+    ['v=1.2.34', 34, true],
+  ].forEach((tuple) => {
+    const range = tuple[0]
+    const version = tuple[1]
+    const loose = tuple[2] || false
+    const msg = `patch(${range}) = ${version}`
+    t.equal(patch(range, loose), version, msg)
+  })
+  t.end()
+})
diff --git a/test/prerelease.js b/test/functions/prerelease.js
similarity index 53%
rename from test/prerelease.js
rename to test/functions/prerelease.js
index 77c14e40..39fa22ce 100644
--- a/test/prerelease.js
+++ b/test/functions/prerelease.js
@@ -1,9 +1,7 @@
-var tap = require('tap')
-var test = tap.test
-var semver = require('../semver.js')
-var prerelease = semver.prerelease
+const { test } = require('tap')
+const prerelease = require('../../functions/prerelease')
 
-test('\nprerelease', function (t) {
+test('prerelease', (t) => {
   // [prereleaseParts, version, loose]
   [
     [['alpha', 1], '1.2.2-alpha.1'],
@@ -14,12 +12,12 @@ test('\nprerelease', function (t) {
     [['beta'], '0.6.1beta', true],
     [null, '1.0.0', true],
     [null, '~2.0.0-alpha.1', false],
-    [null, 'invalid version']
-  ].forEach(function (tuple) {
-    var expected = tuple[0]
-    var version = tuple[1]
-    var loose = tuple[2]
-    var msg = 'prerelease(' + version + ')'
+    [null, 'invalid version'],
+  ].forEach((tuple) => {
+    const expected = tuple[0]
+    const version = tuple[1]
+    const loose = tuple[2]
+    const msg = `prerelease(${version})`
     t.same(prerelease(version, loose), expected, msg)
   })
   t.end()
diff --git a/test/functions/rcompare.js b/test/functions/rcompare.js
new file mode 100644
index 00000000..8225d0aa
--- /dev/null
+++ b/test/functions/rcompare.js
@@ -0,0 +1,11 @@
+const { test } = require('tap')
+const rcompare = require('../../functions/rcompare')
+
+test('rcompare', (t) => {
+  t.equal(rcompare('1.0.0', '1.0.1'), 1)
+  t.equal(rcompare('1.0.0', '1.0.0'), 0)
+  t.equal(rcompare('1.0.0+0', '1.0.0'), 0)
+  t.equal(rcompare('1.0.1', '1.0.0'), -1)
+
+  t.end()
+})
diff --git a/test/functions/rsort.js b/test/functions/rsort.js
new file mode 100644
index 00000000..a0086359
--- /dev/null
+++ b/test/functions/rsort.js
@@ -0,0 +1,21 @@
+const { test } = require('tap')
+const rsort = require('../../functions/rsort')
+
+test('sorting', (t) => {
+  const list = [
+    '1.2.3+1',
+    '1.2.3+0',
+    '1.2.3',
+    '5.9.6',
+    '0.1.2',
+  ]
+  const rsorted = [
+    '5.9.6',
+    '1.2.3+1',
+    '1.2.3+0',
+    '1.2.3',
+    '0.1.2',
+  ]
+  t.same(rsort(list), rsorted)
+  t.end()
+})
diff --git a/test/functions/satisfies.js b/test/functions/satisfies.js
new file mode 100644
index 00000000..1025c3c7
--- /dev/null
+++ b/test/functions/satisfies.js
@@ -0,0 +1,28 @@
+const { test } = require('tap')
+const satisfies = require('../../functions/satisfies')
+const rangeInclude = require('../fixtures/range-include.js')
+const rangeExclude = require('../fixtures/range-exclude.js')
+test('range tests', t => {
+  t.plan(rangeInclude.length)
+  rangeInclude.forEach(([range, ver, options]) =>
+    t.ok(satisfies(ver, range, options), `${range} satisfied by ${ver}`))
+})
+
+test('negative range tests', t => {
+  t.plan(rangeExclude.length)
+  rangeExclude.forEach(([range, ver, options]) =>
+    t.notOk(satisfies(ver, range, options), `${range} not satisfied by ${ver}`))
+})
+
+test('invalid ranges never satisfied (but do not throw)', t => {
+  const cases = [
+    ['blerg', '1.2.3'],
+    ['git+https://user:password0123@github.com/foo', '123.0.0', true],
+    ['^1.2.3', '2.0.0-pre'],
+    ['0.x', undefined],
+    ['*', undefined],
+  ]
+  t.plan(cases.length)
+  cases.forEach(([range, ver]) =>
+    t.notOk(satisfies(ver, range), `${range} not satisfied because invalid`))
+})
diff --git a/test/functions/sort.js b/test/functions/sort.js
new file mode 100644
index 00000000..25e7ce36
--- /dev/null
+++ b/test/functions/sort.js
@@ -0,0 +1,22 @@
+const { test } = require('tap')
+const sort = require('../../functions/sort')
+
+test('sorting', (t) => {
+  const list = [
+    '1.2.3+1',
+    '1.2.3+0',
+    '1.2.3',
+    '5.9.6',
+    '0.1.2',
+  ]
+  const sorted = [
+    '0.1.2',
+    '1.2.3',
+    '1.2.3+0',
+    '1.2.3+1',
+    '5.9.6',
+  ]
+
+  t.same(sort(list), sorted)
+  t.end()
+})
diff --git a/test/functions/valid.js b/test/functions/valid.js
new file mode 100644
index 00000000..33399ed7
--- /dev/null
+++ b/test/functions/valid.js
@@ -0,0 +1,29 @@
+const t = require('tap')
+const valid = require('../../functions/valid')
+const SemVer = require('../../classes/semver')
+const invalidVersions = require('../fixtures/invalid-versions')
+const { MAX_SAFE_INTEGER } = require('../../internal/constants')
+
+t.test('returns null instead of throwing when presented with garbage', t => {
+  t.plan(invalidVersions.length)
+  invalidVersions.forEach(([v, msg, opts]) =>
+    t.equal(valid(v, opts), null, msg))
+})
+
+t.test('validate a version into a SemVer object', t => {
+  t.equal(valid('1.2.3'), '1.2.3')
+  const s = new SemVer('4.5.6')
+  t.equal(valid(s), '4.5.6', 'return the version if a SemVer obj')
+  t.equal(valid('4.2.0foo', true), '4.2.0-foo', 'looseness as a boolean')
+  t.equal(valid('4.2.0foo', { loose: true }), '4.2.0-foo', 'looseness as an option')
+  t.end()
+})
+
+t.test('long build id', t => {
+  const longBuild = '-928490632884417731e7af463c92b034d6a78268fc993bcb88a57944'
+  const shortVersion = '1.1.1'
+  const longVersion = `${MAX_SAFE_INTEGER}.${MAX_SAFE_INTEGER}.${MAX_SAFE_INTEGER}`
+  t.equal(valid(shortVersion + longBuild), shortVersion + longBuild)
+  t.equal(valid(longVersion + longBuild), longVersion + longBuild)
+  t.end()
+})
diff --git a/test/gtr.js b/test/gtr.js
deleted file mode 100644
index dc3ec833..00000000
--- a/test/gtr.js
+++ /dev/null
@@ -1,173 +0,0 @@
-var tap = require('tap')
-var test = tap.test
-var semver = require('../semver.js')
-var gtr = semver.gtr
-
-test('\ngtr tests', function (t) {
-  // [range, version, loose]
-  // Version should be greater than range
-  [
-    ['~1.2.2', '1.3.0'],
-    ['~0.6.1-1', '0.7.1-1'],
-    ['1.0.0 - 2.0.0', '2.0.1'],
-    ['1.0.0', '1.0.1-beta1'],
-    ['1.0.0', '2.0.0'],
-    ['<=2.0.0', '2.1.1'],
-    ['<=2.0.0', '3.2.9'],
-    ['<2.0.0', '2.0.0'],
-    ['0.1.20 || 1.2.4', '1.2.5'],
-    ['2.x.x', '3.0.0'],
-    ['1.2.x', '1.3.0'],
-    ['1.2.x || 2.x', '3.0.0'],
-    ['2.*.*', '5.0.1'],
-    ['1.2.*', '1.3.3'],
-    ['1.2.* || 2.*', '4.0.0'],
-    ['2', '3.0.0'],
-    ['2.3', '2.4.2'],
-    ['~2.4', '2.5.0'], // >=2.4.0 <2.5.0
-    ['~2.4', '2.5.5'],
-    ['~>3.2.1', '3.3.0'], // >=3.2.1 <3.3.0
-    ['~1', '2.2.3'], // >=1.0.0 <2.0.0
-    ['~>1', '2.2.4'],
-    ['~> 1', '3.2.3'],
-    ['~1.0', '1.1.2'], // >=1.0.0 <1.1.0
-    ['~ 1.0', '1.1.0'],
-    ['<1.2', '1.2.0'],
-    ['< 1.2', '1.2.1'],
-    ['1', '2.0.0beta', true],
-    ['~v0.5.4-pre', '0.6.0'],
-    ['~v0.5.4-pre', '0.6.1-pre'],
-    ['=0.7.x', '0.8.0'],
-    ['=0.7.x', '0.8.0-asdf'],
-    ['<0.7.x', '0.7.0'],
-    ['~1.2.2', '1.3.0'],
-    ['1.0.0 - 2.0.0', '2.2.3'],
-    ['1.0.0', '1.0.1'],
-    ['<=2.0.0', '3.0.0'],
-    ['<=2.0.0', '2.9999.9999'],
-    ['<=2.0.0', '2.2.9'],
-    ['<2.0.0', '2.9999.9999'],
-    ['<2.0.0', '2.2.9'],
-    ['2.x.x', '3.1.3'],
-    ['1.2.x', '1.3.3'],
-    ['1.2.x || 2.x', '3.1.3'],
-    ['2.*.*', '3.1.3'],
-    ['1.2.*', '1.3.3'],
-    ['1.2.* || 2.*', '3.1.3'],
-    ['2', '3.1.2'],
-    ['2.3', '2.4.1'],
-    ['~2.4', '2.5.0'], // >=2.4.0 <2.5.0
-    ['~>3.2.1', '3.3.2'], // >=3.2.1 <3.3.0
-    ['~1', '2.2.3'], // >=1.0.0 <2.0.0
-    ['~>1', '2.2.3'],
-    ['~1.0', '1.1.0'], // >=1.0.0 <1.1.0
-    ['<1', '1.0.0'],
-    ['1', '2.0.0beta', true],
-    ['<1', '1.0.0beta', true],
-    ['< 1', '1.0.0beta', true],
-    ['=0.7.x', '0.8.2'],
-    ['<0.7.x', '0.7.2']
-  ].forEach(function (tuple) {
-    var range = tuple[0]
-    var version = tuple[1]
-    var loose = tuple[2] || false
-    var msg = 'gtr(' + version + ', ' + range + ', ' + loose + ')'
-    t.ok(gtr(version, range, loose), msg)
-  })
-  t.end()
-})
-
-test('\nnegative gtr tests', function (t) {
-  // [range, version, loose]
-  // Version should NOT be greater than range
-  [
-    ['~0.6.1-1', '0.6.1-1'],
-    ['1.0.0 - 2.0.0', '1.2.3'],
-    ['1.0.0 - 2.0.0', '0.9.9'],
-    ['1.0.0', '1.0.0'],
-    ['>=*', '0.2.4'],
-    ['', '1.0.0', true],
-    ['*', '1.2.3'],
-    ['*', 'v1.2.3-foo'],
-    ['>=1.0.0', '1.0.0'],
-    ['>=1.0.0', '1.0.1'],
-    ['>=1.0.0', '1.1.0'],
-    ['>1.0.0', '1.0.1'],
-    ['>1.0.0', '1.1.0'],
-    ['<=2.0.0', '2.0.0'],
-    ['<=2.0.0', '1.9999.9999'],
-    ['<=2.0.0', '0.2.9'],
-    ['<2.0.0', '1.9999.9999'],
-    ['<2.0.0', '0.2.9'],
-    ['>= 1.0.0', '1.0.0'],
-    ['>=  1.0.0', '1.0.1'],
-    ['>=   1.0.0', '1.1.0'],
-    ['> 1.0.0', '1.0.1'],
-    ['>  1.0.0', '1.1.0'],
-    ['<=   2.0.0', '2.0.0'],
-    ['<= 2.0.0', '1.9999.9999'],
-    ['<=  2.0.0', '0.2.9'],
-    ['<    2.0.0', '1.9999.9999'],
-    ['<\t2.0.0', '0.2.9'],
-    ['>=0.1.97', 'v0.1.97'],
-    ['>=0.1.97', '0.1.97'],
-    ['0.1.20 || 1.2.4', '1.2.4'],
-    ['0.1.20 || >1.2.4', '1.2.4'],
-    ['0.1.20 || 1.2.4', '1.2.3'],
-    ['0.1.20 || 1.2.4', '0.1.20'],
-    ['>=0.2.3 || <0.0.1', '0.0.0'],
-    ['>=0.2.3 || <0.0.1', '0.2.3'],
-    ['>=0.2.3 || <0.0.1', '0.2.4'],
-    ['||', '1.3.4'],
-    ['2.x.x', '2.1.3'],
-    ['1.2.x', '1.2.3'],
-    ['1.2.x || 2.x', '2.1.3'],
-    ['1.2.x || 2.x', '1.2.3'],
-    ['x', '1.2.3'],
-    ['2.*.*', '2.1.3'],
-    ['1.2.*', '1.2.3'],
-    ['1.2.* || 2.*', '2.1.3'],
-    ['1.2.* || 2.*', '1.2.3'],
-    ['1.2.* || 2.*', '1.2.3'],
-    ['*', '1.2.3'],
-    ['2', '2.1.2'],
-    ['2.3', '2.3.1'],
-    ['~2.4', '2.4.0'], // >=2.4.0 <2.5.0
-    ['~2.4', '2.4.5'],
-    ['~>3.2.1', '3.2.2'], // >=3.2.1 <3.3.0
-    ['~1', '1.2.3'], // >=1.0.0 <2.0.0
-    ['~>1', '1.2.3'],
-    ['~> 1', '1.2.3'],
-    ['~1.0', '1.0.2'], // >=1.0.0 <1.1.0
-    ['~ 1.0', '1.0.2'],
-    ['>=1', '1.0.0'],
-    ['>= 1', '1.0.0'],
-    ['<1.2', '1.1.1'],
-    ['< 1.2', '1.1.1'],
-    ['1', '1.0.0beta', true],
-    ['~v0.5.4-pre', '0.5.5'],
-    ['~v0.5.4-pre', '0.5.4'],
-    ['=0.7.x', '0.7.2'],
-    ['>=0.7.x', '0.7.2'],
-    ['=0.7.x', '0.7.0-asdf'],
-    ['>=0.7.x', '0.7.0-asdf'],
-    ['<=0.7.x', '0.6.2'],
-    ['>0.2.3 >0.2.4 <=0.2.5', '0.2.5'],
-    ['>=0.2.3 <=0.2.4', '0.2.4'],
-    ['1.0.0 - 2.0.0', '2.0.0'],
-    ['^1', '0.0.0-0'],
-    ['^3.0.0', '2.0.0'],
-    ['^1.0.0 || ~2.0.1', '2.0.0'],
-    ['^0.1.0 || ~3.0.1 || 5.0.0', '3.2.0'],
-    ['^0.1.0 || ~3.0.1 || 5.0.0', '1.0.0beta', true],
-    ['^0.1.0 || ~3.0.1 || 5.0.0', '5.0.0-0', true],
-    ['^0.1.0 || ~3.0.1 || >4 <=5.0.0', '3.5.0']
-  ].forEach(function (tuple) {
-    var range = tuple[0]
-    var version = tuple[1]
-    var loose = tuple[2] || false
-    var msg = '!gtr(' + version + ', ' + range + ', ' + loose + ')'
-    t.notOk(gtr(version, range, loose), msg)
-  })
-  t.end()
-})
diff --git a/test/index.js b/test/index.js
index 5e57c3fd..6185dc7c 100644
--- a/test/index.js
+++ b/test/index.js
@@ -1,982 +1,11 @@
-'use strict'
-
-var tap = require('tap')
-var test = tap.test
-var semver = require('../semver.js')
-var eq = semver.eq
-var gt = semver.gt
-var lt = semver.lt
-var neq = semver.neq
-var cmp = semver.cmp
-var gte = semver.gte
-var lte = semver.lte
-var satisfies = semver.satisfies
-var validRange = semver.validRange
-var inc = semver.inc
-var diff = semver.diff
-var toComparators = semver.toComparators
-var SemVer = semver.SemVer
-var Range = semver.Range
-var Comparator = semver.Comparator
-
-test('comparison tests', function (t) {
-  // [version1, version2]
-  // version1 should be greater than version2
-  [['0.0.0', '0.0.0-foo'],
-    ['0.0.1', '0.0.0'],
-    ['1.0.0', '0.9.9'],
-    ['0.10.0', '0.9.0'],
-    ['0.99.0', '0.10.0', {}],
-    ['2.0.0', '1.2.3', { loose: false }],
-    ['v0.0.0', '0.0.0-foo', true],
-    ['v0.0.1', '0.0.0', { loose: true }],
-    ['v1.0.0', '0.9.9', true],
-    ['v0.10.0', '0.9.0', true],
-    ['v0.99.0', '0.10.0', true],
-    ['v2.0.0', '1.2.3', true],
-    ['0.0.0', 'v0.0.0-foo', true],
-    ['0.0.1', 'v0.0.0', true],
-    ['1.0.0', 'v0.9.9', true],
-    ['0.10.0', 'v0.9.0', true],
-    ['0.99.0', 'v0.10.0', true],
-    ['2.0.0', 'v1.2.3', true],
-    ['1.2.3', '1.2.3-asdf'],
-    ['1.2.3', '1.2.3-4'],
-    ['1.2.3', '1.2.3-4-foo'],
-    ['1.2.3-5-foo', '1.2.3-5'],
-    ['1.2.3-5', '1.2.3-4'],
-    ['1.2.3-5-foo', '1.2.3-5-Foo'],
-    ['3.0.0', '2.7.2+asdf'],
-    ['1.2.3-a.10', '1.2.3-a.5'],
-    ['1.2.3-a.b', '1.2.3-a.5'],
-    ['1.2.3-a.b', '1.2.3-a'],
-    ['1.2.3-a.b.c.10.d.5', '1.2.3-a.b.c.5.d.100'],
-    ['1.2.3-r2', '1.2.3-r100'],
-    ['1.2.3-r100', '1.2.3-R2']
-  ].forEach(function (v) {
-    var v0 = v[0]
-    var v1 = v[1]
-    var loose = v[2]
-    t.ok(gt(v0, v1, loose), "gt('" + v0 + "', '" + v1 + "')")
-    t.ok(lt(v1, v0, loose), "lt('" + v1 + "', '" + v0 + "')")
-    t.ok(!gt(v1, v0, loose), "!gt('" + v1 + "', '" + v0 + "')")
-    t.ok(!lt(v0, v1, loose), "!lt('" + v0 + "', '" + v1 + "')")
-    t.ok(eq(v0, v0, loose), "eq('" + v0 + "', '" + v0 + "')")
-    t.ok(eq(v1, v1, loose), "eq('" + v1 + "', '" + v1 + "')")
-    t.ok(neq(v0, v1, loose), "neq('" + v0 + "', '" + v1 + "')")
-    t.ok(cmp(v1, '==', v1, loose), "cmp('" + v1 + "' == '" + v1 + "')")
-    t.ok(cmp(v0, '>=', v1, loose), "cmp('" + v0 + "' >= '" + v1 + "')")
-    t.ok(cmp(v1, '<=', v0, loose), "cmp('" + v1 + "' <= '" + v0 + "')")
-    t.ok(cmp(v0, '!=', v1, loose), "cmp('" + v0 + "' != '" + v1 + "')")
-  })
-  t.end()
-})
-
-test('equality tests', function (t) {
-  // [version1, version2]
-  // version1 should be equivalent to version2
-  [['1.2.3', 'v1.2.3', true],
-    ['1.2.3', '=1.2.3', true],
-    ['1.2.3', 'v 1.2.3', true],
-    ['1.2.3', '= 1.2.3', true],
-    ['1.2.3', ' v1.2.3', true],
-    ['1.2.3', ' =1.2.3', true],
-    ['1.2.3', ' v 1.2.3', true],
-    ['1.2.3', ' = 1.2.3', true],
-    ['1.2.3-0', 'v1.2.3-0', true],
-    ['1.2.3-0', '=1.2.3-0', true],
-    ['1.2.3-0', 'v 1.2.3-0', true],
-    ['1.2.3-0', '= 1.2.3-0', true],
-    ['1.2.3-0', ' v1.2.3-0', true],
-    ['1.2.3-0', ' =1.2.3-0', true],
-    ['1.2.3-0', ' v 1.2.3-0', true],
-    ['1.2.3-0', ' = 1.2.3-0', true],
-    ['1.2.3-1', 'v1.2.3-1', true],
-    ['1.2.3-1', '=1.2.3-1', true],
-    ['1.2.3-1', 'v 1.2.3-1', true],
-    ['1.2.3-1', '= 1.2.3-1', true],
-    ['1.2.3-1', ' v1.2.3-1', true],
-    ['1.2.3-1', ' =1.2.3-1', true],
-    ['1.2.3-1', ' v 1.2.3-1', true],
-    ['1.2.3-1', ' = 1.2.3-1', true],
-    ['1.2.3-beta', 'v1.2.3-beta', true],
-    ['1.2.3-beta', '=1.2.3-beta', true],
-    ['1.2.3-beta', 'v 1.2.3-beta', true],
-    ['1.2.3-beta', '= 1.2.3-beta', true],
-    ['1.2.3-beta', ' v1.2.3-beta', true],
-    ['1.2.3-beta', ' =1.2.3-beta', true],
-    ['1.2.3-beta', ' v 1.2.3-beta', true],
-    ['1.2.3-beta', ' = 1.2.3-beta', true],
-    ['1.2.3-beta+build', ' = 1.2.3-beta+otherbuild', true],
-    ['1.2.3+build', ' = 1.2.3+otherbuild', true],
-    ['1.2.3-beta+build', '1.2.3-beta+otherbuild'],
-    ['1.2.3+build', '1.2.3+otherbuild'],
-    ['  v1.2.3+build', '1.2.3+otherbuild']
-  ].forEach(function (v) {
-    var v0 = v[0]
-    var v1 = v[1]
-    var loose = v[2]
-    t.ok(eq(v0, v1, loose), "eq('" + v0 + "', '" + v1 + "')")
-    t.ok(!neq(v0, v1, loose), "!neq('" + v0 + "', '" + v1 + "')")
-    t.ok(cmp(v0, '==', v1, loose), 'cmp(' + v0 + '==' + v1 + ')')
-    t.ok(!cmp(v0, '!=', v1, loose), '!cmp(' + v0 + '!=' + v1 + ')')
-    t.ok(!cmp(v0, '===', v1, loose), '!cmp(' + v0 + '===' + v1 + ')')
-
-    // also test with an object. they are === because obj.version matches
-    t.ok(cmp(new SemVer(v0, { loose: loose }), '===',
-      new SemVer(v1, { loose: loose })),
-      '!cmp(' + v0 + '===' + v1 + ') object')
-
-    t.ok(cmp(v0, '!==', v1, loose), 'cmp(' + v0 + '!==' + v1 + ')')
-
-    t.ok(!cmp(new SemVer(v0, loose), '!==', new SemVer(v1, loose)),
-      'cmp(' + v0 + '!==' + v1 + ') object')
-
-    t.ok(!gt(v0, v1, loose), "!gt('" + v0 + "', '" + v1 + "')")
-    t.ok(gte(v0, v1, loose), "gte('" + v0 + "', '" + v1 + "')")
-    t.ok(!lt(v0, v1, loose), "!lt('" + v0 + "', '" + v1 + "')")
-    t.ok(lte(v0, v1, loose), "lte('" + v0 + "', '" + v1 + "')")
-  })
-  t.end()
-})
-
-test('range tests', function (t) {
-  // [range, version]
-  // version should be included by range
-  [['1.0.0 - 2.0.0', '1.2.3'],
-    ['^1.2.3+build', '1.2.3'],
-    ['^1.2.3+build', '1.3.0'],
-    ['1.2.3-pre+asdf - 2.4.3-pre+asdf', '1.2.3'],
-    ['1.2.3pre+asdf - 2.4.3-pre+asdf', '1.2.3', true],
-    ['1.2.3-pre+asdf - 2.4.3pre+asdf', '1.2.3', true],
-    ['1.2.3pre+asdf - 2.4.3pre+asdf', '1.2.3', true],
-    ['1.2.3-pre+asdf - 2.4.3-pre+asdf', '1.2.3-pre.2'],
-    ['1.2.3-pre+asdf - 2.4.3-pre+asdf', '2.4.3-alpha'],
-    ['1.2.3+asdf - 2.4.3+asdf', '1.2.3'],
-    ['1.0.0', '1.0.0'],
-    ['>=*', '0.2.4'],
-    ['', '1.0.0'],
-    ['*', '1.2.3', {}],
-    ['*', 'v1.2.3', { loose: 123 }],
-    ['>=1.0.0', '1.0.0', /asdf/],
-    ['>=1.0.0', '1.0.1', { loose: null }],
-    ['>=1.0.0', '1.1.0', { loose: 0 }],
-    ['>1.0.0', '1.0.1', { loose: undefined }],
-    ['>1.0.0', '1.1.0'],
-    ['<=2.0.0', '2.0.0'],
-    ['<=2.0.0', '1.9999.9999'],
-    ['<=2.0.0', '0.2.9'],
-    ['<2.0.0', '1.9999.9999'],
-    ['<2.0.0', '0.2.9'],
-    ['>= 1.0.0', '1.0.0'],
-    ['>=  1.0.0', '1.0.1'],
-    ['>=   1.0.0', '1.1.0'],
-    ['> 1.0.0', '1.0.1'],
-    ['>  1.0.0', '1.1.0'],
-    ['<=   2.0.0', '2.0.0'],
-    ['<= 2.0.0', '1.9999.9999'],
-    ['<=  2.0.0', '0.2.9'],
-    ['<    2.0.0', '1.9999.9999'],
-    ['<\t2.0.0', '0.2.9'],
-    ['>=0.1.97', 'v0.1.97', true],
-    ['>=0.1.97', '0.1.97'],
-    ['0.1.20 || 1.2.4', '1.2.4'],
-    ['>=0.2.3 || <0.0.1', '0.0.0'],
-    ['>=0.2.3 || <0.0.1', '0.2.3'],
-    ['>=0.2.3 || <0.0.1', '0.2.4'],
-    ['||', '1.3.4'],
-    ['2.x.x', '2.1.3'],
-    ['1.2.x', '1.2.3'],
-    ['1.2.x || 2.x', '2.1.3'],
-    ['1.2.x || 2.x', '1.2.3'],
-    ['x', '1.2.3'],
-    ['2.*.*', '2.1.3'],
-    ['1.2.*', '1.2.3'],
-    ['1.2.* || 2.*', '2.1.3'],
-    ['1.2.* || 2.*', '1.2.3'],
-    ['*', '1.2.3'],
-    ['2', '2.1.2'],
-    ['2.3', '2.3.1'],
-    ['~x', '0.0.9'], // >=2.4.0 <2.5.0
-    ['~2', '2.0.9'], // >=2.4.0 <2.5.0
-    ['~2.4', '2.4.0'], // >=2.4.0 <2.5.0
-    ['~2.4', '2.4.5'],
-    ['~>3.2.1', '3.2.2'], // >=3.2.1 <3.3.0,
-    ['~1', '1.2.3'], // >=1.0.0 <2.0.0
-    ['~>1', '1.2.3'],
-    ['~> 1', '1.2.3'],
-    ['~1.0', '1.0.2'], // >=1.0.0 <1.1.0,
-    ['~ 1.0', '1.0.2'],
-    ['~ 1.0.3', '1.0.12'],
-    ['~ 1.0.3alpha', '1.0.12', { loose: true }],
-    ['>=1', '1.0.0'],
-    ['>= 1', '1.0.0'],
-    ['<1.2', '1.1.1'],
-    ['< 1.2', '1.1.1'],
-    ['~v0.5.4-pre', '0.5.5'],
-    ['~v0.5.4-pre', '0.5.4'],
-    ['=0.7.x', '0.7.2'],
-    ['<=0.7.x', '0.7.2'],
-    ['>=0.7.x', '0.7.2'],
-    ['<=0.7.x', '0.6.2'],
-    ['~1.2.1 >=1.2.3', '1.2.3'],
-    ['~1.2.1 =1.2.3', '1.2.3'],
-    ['~1.2.1 1.2.3', '1.2.3'],
-    ['~1.2.1 >=1.2.3 1.2.3', '1.2.3'],
-    ['~1.2.1 1.2.3 >=1.2.3', '1.2.3'],
-    ['~1.2.1 1.2.3', '1.2.3'],
-    ['>=1.2.1 1.2.3', '1.2.3'],
-    ['1.2.3 >=1.2.1', '1.2.3'],
-    ['>=1.2.3 >=1.2.1', '1.2.3'],
-    ['>=1.2.1 >=1.2.3', '1.2.3'],
-    ['>=1.2', '1.2.8'],
-    ['^1.2.3', '1.8.1'],
-    ['^0.1.2', '0.1.2'],
-    ['^0.1', '0.1.2'],
-    ['^0.0.1', '0.0.1'],
-    ['^1.2', '1.4.2'],
-    ['^1.2 ^1', '1.4.2'],
-    ['^1.2.3-alpha', '1.2.3-pre'],
-    ['^1.2.0-alpha', '1.2.0-pre'],
-    ['^0.0.1-alpha', '0.0.1-beta'],
-    ['^0.1.1-alpha', '0.1.1-beta'],
-    ['^x', '1.2.3'],
-    ['x - 1.0.0', '0.9.7'],
-    ['x - 1.x', '0.9.7'],
-    ['1.0.0 - x', '1.9.7'],
-    ['1.x - x', '1.9.7'],
-    ['<=7.x', '7.9.9']
-  ].forEach(function (v) {
-    var range = v[0]
-    var ver = v[1]
-    var loose = v[2]
-    t.ok(satisfies(ver, range, loose), range + ' satisfied by ' + ver)
-  })
-  t.end()
-})
-
-test('negative range tests', function (t) {
-  // [range, version]
-  // version should not be included by range
-  [['1.0.0 - 2.0.0', '2.2.3'],
-    ['1.2.3+asdf - 2.4.3+asdf', '1.2.3-pre.2'],
-    ['1.2.3+asdf - 2.4.3+asdf', '2.4.3-alpha'],
-    ['^1.2.3+build', '2.0.0'],
-    ['^1.2.3+build', '1.2.0'],
-    ['^1.2.3', '1.2.3-pre'],
-    ['^1.2', '1.2.0-pre'],
-    ['>1.2', '1.3.0-beta'],
-    ['<=1.2.3', '1.2.3-beta'],
-    ['^1.2.3', '1.2.3-beta'],
-    ['=0.7.x', '0.7.0-asdf'],
-    ['>=0.7.x', '0.7.0-asdf'],
-    ['1', '1.0.0beta', { loose: 420 }],
-    ['<1', '1.0.0beta', true],
-    ['< 1', '1.0.0beta', true],
-    ['1.0.0', '1.0.1'],
-    ['>=1.0.0', '0.0.0'],
-    ['>=1.0.0', '0.0.1'],
-    ['>=1.0.0', '0.1.0'],
-    ['>1.0.0', '0.0.1'],
-    ['>1.0.0', '0.1.0'],
-    ['<=2.0.0', '3.0.0'],
-    ['<=2.0.0', '2.9999.9999'],
-    ['<=2.0.0', '2.2.9'],
-    ['<2.0.0', '2.9999.9999'],
-    ['<2.0.0', '2.2.9'],
-    ['>=0.1.97', 'v0.1.93', true],
-    ['>=0.1.97', '0.1.93'],
-    ['0.1.20 || 1.2.4', '1.2.3'],
-    ['>=0.2.3 || <0.0.1', '0.0.3'],
-    ['>=0.2.3 || <0.0.1', '0.2.2'],
-    ['2.x.x', '1.1.3', { loose: NaN }],
-    ['2.x.x', '3.1.3'],
-    ['1.2.x', '1.3.3'],
-    ['1.2.x || 2.x', '3.1.3'],
-    ['1.2.x || 2.x', '1.1.3'],
-    ['2.*.*', '1.1.3'],
-    ['2.*.*', '3.1.3'],
-    ['1.2.*', '1.3.3'],
-    ['1.2.* || 2.*', '3.1.3'],
-    ['1.2.* || 2.*', '1.1.3'],
-    ['2', '1.1.2'],
-    ['2.3', '2.4.1'],
-    ['~2.4', '2.5.0'], // >=2.4.0 <2.5.0
-    ['~2.4', '2.3.9'],
-    ['~>3.2.1', '3.3.2'], // >=3.2.1 <3.3.0
-    ['~>3.2.1', '3.2.0'], // >=3.2.1 <3.3.0
-    ['~1', '0.2.3'], // >=1.0.0 <2.0.0
-    ['~>1', '2.2.3'],
-    ['~1.0', '1.1.0'], // >=1.0.0 <1.1.0
-    ['<1', '1.0.0'],
-    ['>=1.2', '1.1.1'],
-    ['1', '2.0.0beta', true],
-    ['~v0.5.4-beta', '0.5.4-alpha'],
-    ['=0.7.x', '0.8.2'],
-    ['>=0.7.x', '0.6.2'],
-    ['<0.7.x', '0.7.2'],
-    ['<1.2.3', '1.2.3-beta'],
-    ['=1.2.3', '1.2.3-beta'],
-    ['>1.2', '1.2.8'],
-    ['^0.0.1', '0.0.2'],
-    ['^1.2.3', '2.0.0-alpha'],
-    ['^1.2.3', '1.2.2'],
-    ['^1.2', '1.1.9'],
-    ['*', 'v1.2.3-foo', true],
-    // invalid ranges never satisfied!
-    ['blerg', '1.2.3'],
-    ['git+https://user:password0123@github.com/foo', '123.0.0', true],
-    ['^1.2.3', '2.0.0-pre'],
-    ['^1.2.3', false]
-  ].forEach(function (v) {
-    var range = v[0]
-    var ver = v[1]
-    var loose = v[2]
-    var found = satisfies(ver, range, loose)
-    t.ok(!found, ver + ' not satisfied by ' + range)
-  })
-  t.end()
-})
-
-test('unlocked prerelease range tests', function (t) {
-  // [range, version]
-  // version should be included by range
-  [['*', '1.0.0-rc1'],
-    ['^1.0.0', '2.0.0-rc1'],
-    ['^1.0.0-0', '1.0.1-rc1'],
-    ['^1.0.0-rc2', '1.0.1-rc1'],
-    ['^1.0.0', '1.0.1-rc1'],
-    ['^1.0.0', '1.1.0-rc1']
-  ].forEach(function (v) {
-    var range = v[0]
-    var ver = v[1]
-    var options = { includePrerelease: true }
-    t.ok(satisfies(ver, range, options), range + ' satisfied by ' + ver)
-  })
-  t.end()
-})
-
-test('negative unlocked prerelease range tests', function (t) {
-  // [range, version]
-  // version should not be included by range
-  [['^1.0.0', '1.0.0-rc1'],
-    ['^1.2.3-rc2', '2.0.0']
-  ].forEach(function (v) {
-    var range = v[0]
-    var ver = v[1]
-    var options = { includePrerelease: true }
-    var found = satisfies(ver, range, options)
-    t.ok(!found, ver + ' not satisfied by ' + range)
-  })
-  t.end()
-})
-
-test('increment versions test', function (t) {
-//  [version, inc, result, identifier]
-//  inc(version, inc) -> result
-  [['1.2.3', 'major', '2.0.0'],
-    ['1.2.3', 'minor', '1.3.0'],
-    ['1.2.3', 'patch', '1.2.4'],
-    ['1.2.3tag', 'major', '2.0.0', true],
-    ['1.2.3-tag', 'major', '2.0.0'],
-    ['1.2.3', 'fake', null],
-    ['1.2.0-0', 'patch', '1.2.0'],
-    ['fake', 'major', null],
-    ['1.2.3-4', 'major', '2.0.0'],
-    ['1.2.3-4', 'minor', '1.3.0'],
-    ['1.2.3-4', 'patch', '1.2.3'],
-    ['1.2.3-alpha.0.beta', 'major', '2.0.0'],
-    ['1.2.3-alpha.0.beta', 'minor', '1.3.0'],
-    ['1.2.3-alpha.0.beta', 'patch', '1.2.3'],
-    ['1.2.4', 'prerelease', '1.2.5-0'],
-    ['1.2.3-0', 'prerelease', '1.2.3-1'],
-    ['1.2.3-alpha.0', 'prerelease', '1.2.3-alpha.1'],
-    ['1.2.3-alpha.1', 'prerelease', '1.2.3-alpha.2'],
-    ['1.2.3-alpha.2', 'prerelease', '1.2.3-alpha.3'],
-    ['1.2.3-alpha.0.beta', 'prerelease', '1.2.3-alpha.1.beta'],
-    ['1.2.3-alpha.1.beta', 'prerelease', '1.2.3-alpha.2.beta'],
-    ['1.2.3-alpha.2.beta', 'prerelease', '1.2.3-alpha.3.beta'],
-    ['1.2.3-alpha.10.0.beta', 'prerelease', '1.2.3-alpha.10.1.beta'],
-    ['1.2.3-alpha.10.1.beta', 'prerelease', '1.2.3-alpha.10.2.beta'],
-    ['1.2.3-alpha.10.2.beta', 'prerelease', '1.2.3-alpha.10.3.beta'],
-    ['1.2.3-alpha.10.beta.0', 'prerelease', '1.2.3-alpha.10.beta.1'],
-    ['1.2.3-alpha.10.beta.1', 'prerelease', '1.2.3-alpha.10.beta.2'],
-    ['1.2.3-alpha.10.beta.2', 'prerelease', '1.2.3-alpha.10.beta.3'],
-    ['1.2.3-alpha.9.beta', 'prerelease', '1.2.3-alpha.10.beta'],
-    ['1.2.3-alpha.10.beta', 'prerelease', '1.2.3-alpha.11.beta'],
-    ['1.2.3-alpha.11.beta', 'prerelease', '1.2.3-alpha.12.beta'],
-    ['1.2.0', 'prepatch', '1.2.1-0'],
-    ['1.2.0-1', 'prepatch', '1.2.1-0'],
-    ['1.2.0', 'preminor', '1.3.0-0'],
-    ['1.2.3-1', 'preminor', '1.3.0-0'],
-    ['1.2.0', 'premajor', '2.0.0-0'],
-    ['1.2.3-1', 'premajor', '2.0.0-0'],
-    ['1.2.0-1', 'minor', '1.2.0'],
-    ['1.0.0-1', 'major', '1.0.0'],
-
-    ['1.2.3', 'major', '2.0.0', false, 'dev'],
-    ['1.2.3', 'minor', '1.3.0', false, 'dev'],
-    ['1.2.3', 'patch', '1.2.4', false, 'dev'],
-    ['1.2.3tag', 'major', '2.0.0', true, 'dev'],
-    ['1.2.3-tag', 'major', '2.0.0', false, 'dev'],
-    ['1.2.3', 'fake', null, false, 'dev'],
-    ['1.2.0-0', 'patch', '1.2.0', false, 'dev'],
-    ['fake', 'major', null, false, 'dev'],
-    ['1.2.3-4', 'major', '2.0.0', false, 'dev'],
-    ['1.2.3-4', 'minor', '1.3.0', false, 'dev'],
-    ['1.2.3-4', 'patch', '1.2.3', false, 'dev'],
-    ['1.2.3-alpha.0.beta', 'major', '2.0.0', false, 'dev'],
-    ['1.2.3-alpha.0.beta', 'minor', '1.3.0', false, 'dev'],
-    ['1.2.3-alpha.0.beta', 'patch', '1.2.3', false, 'dev'],
-    ['1.2.4', 'prerelease', '1.2.5-dev.0', false, 'dev'],
-    ['1.2.3-0', 'prerelease', '1.2.3-dev.0', false, 'dev'],
-    ['1.2.3-alpha.0', 'prerelease', '1.2.3-dev.0', false, 'dev'],
-    ['1.2.3-alpha.0', 'prerelease', '1.2.3-alpha.1', false, 'alpha'],
-    ['1.2.3-alpha.0.beta', 'prerelease', '1.2.3-dev.0', false, 'dev'],
-    ['1.2.3-alpha.0.beta', 'prerelease', '1.2.3-alpha.1.beta', false, 'alpha'],
-    ['1.2.3-alpha.10.0.beta', 'prerelease', '1.2.3-dev.0', false, 'dev'],
-    ['1.2.3-alpha.10.0.beta', 'prerelease', '1.2.3-alpha.10.1.beta', false, 'alpha'],
-    ['1.2.3-alpha.10.1.beta', 'prerelease', '1.2.3-alpha.10.2.beta', false, 'alpha'],
-    ['1.2.3-alpha.10.2.beta', 'prerelease', '1.2.3-alpha.10.3.beta', false, 'alpha'],
-    ['1.2.3-alpha.10.beta.0', 'prerelease', '1.2.3-dev.0', false, 'dev'],
-    ['1.2.3-alpha.10.beta.0', 'prerelease', '1.2.3-alpha.10.beta.1', false, 'alpha'],
-    ['1.2.3-alpha.10.beta.1', 'prerelease', '1.2.3-alpha.10.beta.2', false, 'alpha'],
-    ['1.2.3-alpha.10.beta.2', 'prerelease', '1.2.3-alpha.10.beta.3', false, 'alpha'],
-    ['1.2.3-alpha.9.beta', 'prerelease', '1.2.3-dev.0', false, 'dev'],
-    ['1.2.3-alpha.9.beta', 'prerelease', '1.2.3-alpha.10.beta', false, 'alpha'],
-    ['1.2.3-alpha.10.beta', 'prerelease', '1.2.3-alpha.11.beta', false, 'alpha'],
-    ['1.2.3-alpha.11.beta', 'prerelease', '1.2.3-alpha.12.beta', false, 'alpha'],
-    ['1.2.0', 'prepatch', '1.2.1-dev.0', false, 'dev'],
-    ['1.2.0-1', 'prepatch', '1.2.1-dev.0', false, 'dev'],
-    ['1.2.0', 'preminor', '1.3.0-dev.0', false, 'dev'],
-    ['1.2.3-1', 'preminor', '1.3.0-dev.0', false, 'dev'],
-    ['1.2.0', 'premajor', '2.0.0-dev.0', false, 'dev'],
-    ['1.2.3-1', 'premajor', '2.0.0-dev.0', false, 'dev'],
-    ['1.2.0-1', 'minor', '1.2.0', false, 'dev'],
-    ['1.0.0-1', 'major', '1.0.0', 'dev'],
-    ['1.2.3-dev.bar', 'prerelease', '1.2.3-dev.0', false, 'dev']
-
-  ].forEach(function (v) {
-    var pre = v[0]
-    var what = v[1]
-    var wanted = v[2]
-    var loose = v[3]
-    var id = v[4]
-    var found = inc(pre, what, loose, id)
-    var cmd = 'inc(' + pre + ', ' + what + ', ' + id + ')'
-    t.equal(found, wanted, cmd + ' === ' + wanted)
-
-    var parsed = semver.parse(pre, loose)
-    if (wanted) {
-      parsed.inc(what, id)
-      t.equal(parsed.version, wanted, cmd + ' object version updated')
-      t.equal(parsed.raw, wanted, cmd + ' object raw field updated')
-    } else if (parsed) {
-      t.throws(function () {
-        parsed.inc(what, id)
-      })
-    } else {
-      t.equal(parsed, null)
-    }
-  })
-
-  t.end()
-})
-
-test('diff versions test', function (t) {
-//  [version1, version2, result]
-//  diff(version1, version2) -> result
-  [['1.2.3', '0.2.3', 'major'],
-    ['1.4.5', '0.2.3', 'major'],
-    ['1.2.3', '2.0.0-pre', 'premajor'],
-    ['1.2.3', '1.3.3', 'minor'],
-    ['1.0.1', '1.1.0-pre', 'preminor'],
-    ['1.2.3', '1.2.4', 'patch'],
-    ['1.2.3', '1.2.4-pre', 'prepatch'],
-    ['0.0.1', '0.0.1-pre', 'prerelease'],
-    ['0.0.1', '0.0.1-pre-2', 'prerelease'],
-    ['1.1.0', '1.1.0-pre', 'prerelease'],
-    ['1.1.0-pre-1', '1.1.0-pre-2', 'prerelease'],
-    ['1.0.0', '1.0.0', null]
-
-  ].forEach(function (v) {
-    var version1 = v[0]
-    var version2 = v[1]
-    var wanted = v[2]
-    var found = diff(version1, version2)
-    var cmd = 'diff(' + version1 + ', ' + version2 + ')'
-    t.equal(found, wanted, cmd + ' === ' + wanted)
-  })
-
-  t.end()
-})
-
-test('valid range test', function (t) {
-  // [range, result]
-  // validRange(range) -> result
-  // translate ranges into their canonical form
-  [['1.0.0 - 2.0.0', '>=1.0.0 <=2.0.0'],
-    ['1.0.0', '1.0.0'],
-    ['>=*', '*'],
-    ['', '*'],
-    ['*', '*'],
-    ['*', '*'],
-    ['>=1.0.0', '>=1.0.0'],
-    ['>1.0.0', '>1.0.0'],
-    ['<=2.0.0', '<=2.0.0'],
-    ['1', '>=1.0.0 <2.0.0'],
-    ['<=2.0.0', '<=2.0.0'],
-    ['<=2.0.0', '<=2.0.0'],
-    ['<2.0.0', '<2.0.0'],
-    ['<2.0.0', '<2.0.0'],
-    ['>= 1.0.0', '>=1.0.0'],
-    ['>=  1.0.0', '>=1.0.0'],
-    ['>=   1.0.0', '>=1.0.0'],
-    ['> 1.0.0', '>1.0.0'],
-    ['>  1.0.0', '>1.0.0'],
-    ['<=   2.0.0', '<=2.0.0'],
-    ['<= 2.0.0', '<=2.0.0'],
-    ['<=  2.0.0', '<=2.0.0'],
-    ['<    2.0.0', '<2.0.0'],
-    ['<\t2.0.0', '<2.0.0'],
-    ['>=0.1.97', '>=0.1.97'],
-    ['>=0.1.97', '>=0.1.97'],
-    ['0.1.20 || 1.2.4', '0.1.20||1.2.4'],
-    ['>=0.2.3 || <0.0.1', '>=0.2.3||<0.0.1'],
-    ['>=0.2.3 || <0.0.1', '>=0.2.3||<0.0.1'],
-    ['>=0.2.3 || <0.0.1', '>=0.2.3||<0.0.1'],
-    ['||', '||'],
-    ['2.x.x', '>=2.0.0 <3.0.0'],
-    ['1.2.x', '>=1.2.0 <1.3.0'],
-    ['1.2.x || 2.x', '>=1.2.0 <1.3.0||>=2.0.0 <3.0.0'],
-    ['1.2.x || 2.x', '>=1.2.0 <1.3.0||>=2.0.0 <3.0.0'],
-    ['x', '*'],
-    ['2.*.*', '>=2.0.0 <3.0.0'],
-    ['1.2.*', '>=1.2.0 <1.3.0'],
-    ['1.2.* || 2.*', '>=1.2.0 <1.3.0||>=2.0.0 <3.0.0'],
-    ['*', '*'],
-    ['2', '>=2.0.0 <3.0.0'],
-    ['2.3', '>=2.3.0 <2.4.0'],
-    ['~2.4', '>=2.4.0 <2.5.0'],
-    ['~2.4', '>=2.4.0 <2.5.0'],
-    ['~>3.2.1', '>=3.2.1 <3.3.0'],
-    ['~1', '>=1.0.0 <2.0.0'],
-    ['~>1', '>=1.0.0 <2.0.0'],
-    ['~> 1', '>=1.0.0 <2.0.0'],
-    ['~1.0', '>=1.0.0 <1.1.0'],
-    ['~ 1.0', '>=1.0.0 <1.1.0'],
-    ['^0', '>=0.0.0 <1.0.0'],
-    ['^ 1', '>=1.0.0 <2.0.0'],
-    ['^0.1', '>=0.1.0 <0.2.0'],
-    ['^1.0', '>=1.0.0 <2.0.0'],
-    ['^1.2', '>=1.2.0 <2.0.0'],
-    ['^0.0.1', '>=0.0.1 <0.0.2'],
-    ['^0.0.1-beta', '>=0.0.1-beta <0.0.2'],
-    ['^0.1.2', '>=0.1.2 <0.2.0'],
-    ['^1.2.3', '>=1.2.3 <2.0.0'],
-    ['^1.2.3-beta.4', '>=1.2.3-beta.4 <2.0.0'],
-    ['<1', '<1.0.0'],
-    ['< 1', '<1.0.0'],
-    ['>=1', '>=1.0.0'],
-    ['>= 1', '>=1.0.0'],
-    ['<1.2', '<1.2.0'],
-    ['< 1.2', '<1.2.0'],
-    ['1', '>=1.0.0 <2.0.0'],
-    ['>01.02.03', '>1.2.3', true],
-    ['>01.02.03', null],
-    ['~1.2.3beta', '>=1.2.3-beta <1.3.0', true],
-    ['~1.2.3beta', null],
-    ['^ 1.2 ^ 1', '>=1.2.0 <2.0.0 >=1.0.0 <2.0.0']
-  ].forEach(function (v) {
-    var pre = v[0]
-    var wanted = v[1]
-    var loose = v[2]
-    var found = validRange(pre, loose)
-
-    t.equal(found, wanted, 'validRange(' + pre + ') === ' + wanted)
-  })
-
-  t.end()
-})
-
-test('comparators test', function (t) {
-  // [range, comparators]
-  // turn range into a set of individual comparators
-  [['1.0.0 - 2.0.0', [['>=1.0.0', '<=2.0.0']]],
-    ['1.0.0', [['1.0.0']]],
-    ['>=*', [['']]],
-    ['', [['']]],
-    ['*', [['']]],
-    ['*', [['']]],
-    ['>=1.0.0', [['>=1.0.0']]],
-    ['>=1.0.0', [['>=1.0.0']]],
-    ['>=1.0.0', [['>=1.0.0']]],
-    ['>1.0.0', [['>1.0.0']]],
-    ['>1.0.0', [['>1.0.0']]],
-    ['<=2.0.0', [['<=2.0.0']]],
-    ['1', [['>=1.0.0', '<2.0.0']]],
-    ['<=2.0.0', [['<=2.0.0']]],
-    ['<=2.0.0', [['<=2.0.0']]],
-    ['<2.0.0', [['<2.0.0']]],
-    ['<2.0.0', [['<2.0.0']]],
-    ['>= 1.0.0', [['>=1.0.0']]],
-    ['>=  1.0.0', [['>=1.0.0']]],
-    ['>=   1.0.0', [['>=1.0.0']]],
-    ['> 1.0.0', [['>1.0.0']]],
-    ['>  1.0.0', [['>1.0.0']]],
-    ['<=   2.0.0', [['<=2.0.0']]],
-    ['<= 2.0.0', [['<=2.0.0']]],
-    ['<=  2.0.0', [['<=2.0.0']]],
-    ['<    2.0.0', [['<2.0.0']]],
-    ['<\t2.0.0', [['<2.0.0']]],
-    ['>=0.1.97', [['>=0.1.97']]],
-    ['>=0.1.97', [['>=0.1.97']]],
-    ['0.1.20 || 1.2.4', [['0.1.20'], ['1.2.4']]],
-    ['>=0.2.3 || <0.0.1', [['>=0.2.3'], ['<0.0.1']]],
-    ['>=0.2.3 || <0.0.1', [['>=0.2.3'], ['<0.0.1']]],
-    ['>=0.2.3 || <0.0.1', [['>=0.2.3'], ['<0.0.1']]],
-    ['||', [[''], ['']]],
-    ['2.x.x', [['>=2.0.0', '<3.0.0']]],
-    ['1.2.x', [['>=1.2.0', '<1.3.0']]],
-    ['1.2.x || 2.x', [['>=1.2.0', '<1.3.0'], ['>=2.0.0', '<3.0.0']]],
-    ['1.2.x || 2.x', [['>=1.2.0', '<1.3.0'], ['>=2.0.0', '<3.0.0']]],
-    ['x', [['']]],
-    ['2.*.*', [['>=2.0.0', '<3.0.0']]],
-    ['1.2.*', [['>=1.2.0', '<1.3.0']]],
-    ['1.2.* || 2.*', [['>=1.2.0', '<1.3.0'], ['>=2.0.0', '<3.0.0']]],
-    ['1.2.* || 2.*', [['>=1.2.0', '<1.3.0'], ['>=2.0.0', '<3.0.0']]],
-    ['*', [['']]],
-    ['2', [['>=2.0.0', '<3.0.0']]],
-    ['2.3', [['>=2.3.0', '<2.4.0']]],
-    ['~2.4', [['>=2.4.0', '<2.5.0']]],
-    ['~2.4', [['>=2.4.0', '<2.5.0']]],
-    ['~>3.2.1', [['>=3.2.1', '<3.3.0']]],
-    ['~1', [['>=1.0.0', '<2.0.0']]],
-    ['~>1', [['>=1.0.0', '<2.0.0']]],
-    ['~> 1', [['>=1.0.0', '<2.0.0']]],
-    ['~1.0', [['>=1.0.0', '<1.1.0']]],
-    ['~ 1.0', [['>=1.0.0', '<1.1.0']]],
-    ['~ 1.0.3', [['>=1.0.3', '<1.1.0']]],
-    ['~> 1.0.3', [['>=1.0.3', '<1.1.0']]],
-    ['<1', [['<1.0.0']]],
-    ['< 1', [['<1.0.0']]],
-    ['>=1', [['>=1.0.0']]],
-    ['>= 1', [['>=1.0.0']]],
-    ['<1.2', [['<1.2.0']]],
-    ['< 1.2', [['<1.2.0']]],
-    ['1', [['>=1.0.0', '<2.0.0']]],
-    ['1 2', [['>=1.0.0', '<2.0.0', '>=2.0.0', '<3.0.0']]],
-    ['1.2 - 3.4.5', [['>=1.2.0', '<=3.4.5']]],
-    ['1.2.3 - 3.4', [['>=1.2.3', '<3.5.0']]],
-    ['1.2.3 - 3', [['>=1.2.3', '<4.0.0']]],
-    ['>*', [['<0.0.0']]],
-    ['<*', [['<0.0.0']]]
-  ].forEach(function (v) {
-    var pre = v[0]
-    var wanted = v[1]
-    var found = toComparators(v[0])
-    var jw = JSON.stringify(wanted)
-    t.equivalent(found, wanted, 'toComparators(' + pre + ') === ' + jw)
-  })
-
-  t.end()
-})
-
-test('invalid version numbers', function (t) {
-  ['1.2.3.4',
-    'NOT VALID',
-    1.2,
-    null,
-    'Infinity.NaN.Infinity'
-  ].forEach(function (v) {
-    t.throws(function () {
-      new SemVer(v) // eslint-disable-line no-new
-    }, { name: 'TypeError', message: 'Invalid Version: ' + v })
-  })
-
-  t.end()
-})
-
-test('strict vs loose version numbers', function (t) {
-  [['=1.2.3', '1.2.3'],
-    ['01.02.03', '1.2.3'],
-    ['1.2.3-beta.01', '1.2.3-beta.1'],
-    ['   =1.2.3', '1.2.3'],
-    ['1.2.3foo', '1.2.3-foo']
-  ].forEach(function (v) {
-    var loose = v[0]
-    var strict = v[1]
-    t.throws(function () {
-      SemVer(loose) // eslint-disable-line no-new
-    })
-    var lv = new SemVer(loose, true)
-    t.equal(lv.version, strict)
-    t.ok(eq(loose, strict, true))
-    t.throws(function () {
-      eq(loose, strict)
-    })
-    t.throws(function () {
-      new SemVer(strict).compare(loose)
-    })
-    t.equal(semver.compareLoose(v[0], v[1]), 0)
-  })
-  t.end()
-})
-
-test('compare main vs pre', function (t) {
-  var s = new SemVer('1.2.3')
-  t.equal(s.compareMain('2.3.4'), -1)
-  t.equal(s.compareMain('1.2.4'), -1)
-  t.equal(s.compareMain('0.1.2'), 1)
-  t.equal(s.compareMain('1.2.2'), 1)
-  t.equal(s.compareMain('1.2.3-pre'), 0)
-
-  const p = new SemVer('1.2.3-alpha.0.pr.1')
-  t.equal(p.comparePre('9.9.9-alpha.0.pr.1'), 0)
-  t.equal(p.comparePre('1.2.3'), -1)
-  t.equal(p.comparePre('1.2.3-alpha.0.pr.2'), -1)
-  t.equal(p.comparePre('1.2.3-alpha.0.2'), 1)
-
-  t.end()
-})
-
-test('rcompareIdentifiers and compareIdentifiers', function (t) {
-  var set = [
-    ['1', '2'],
-    ['alpha', 'beta'],
-    ['0', 'beta'],
-  ]
-  set.forEach(function (ab) {
-    var a = ab[0]
-    var b = ab[1]
-    t.equal(semver.compareIdentifiers(a, b), -1)
-    t.equal(semver.rcompareIdentifiers(a, b), 1)
-  })
-  t.equal(semver.compareIdentifiers('0', '0'), 0)
-  t.equal(semver.rcompareIdentifiers('0', '0'), 0)
-  t.end()
-})
-
-test('strict vs loose ranges', function (t) {
-  [['>=01.02.03', '>=1.2.3'],
-    ['~1.02.03beta', '>=1.2.3-beta <1.3.0']
-  ].forEach(function (v) {
-    var loose = v[0]
-    var comps = v[1]
-    t.throws(function () {
-      new Range(loose) // eslint-disable-line no-new
-    })
-    t.equal(new Range(loose, true).range, comps)
-  })
-  t.end()
-})
-
-test('max satisfying', function (t) {
-  [[['1.2.3', '1.2.4'], '1.2', '1.2.4'],
-    [['1.2.4', '1.2.3'], '1.2', '1.2.4'],
-    [['1.2.3', '1.2.4', '1.2.5', '1.2.6'], '~1.2.3', '1.2.6'],
-    [['1.1.0', '1.2.0', '1.2.1', '1.3.0', '2.0.0b1', '2.0.0b2', '2.0.0b3', '2.0.0', '2.1.0'], '~2.0.0', '2.0.0', true]
-  ].forEach(function (v) {
-    var versions = v[0]
-    var range = v[1]
-    var expect = v[2]
-    var loose = v[3]
-    var actual = semver.maxSatisfying(versions, range, loose)
-    t.equal(actual, expect)
-  })
-  t.end()
-})
-
-test('min satisfying', function (t) {
-  [[['1.2.3', '1.2.4'], '1.2', '1.2.3'],
-    [['1.2.4', '1.2.3'], '1.2', '1.2.3'],
-    [['1.2.3', '1.2.4', '1.2.5', '1.2.6'], '~1.2.3', '1.2.3'],
-    [['1.1.0', '1.2.0', '1.2.1', '1.3.0', '2.0.0b1', '2.0.0b2', '2.0.0b3', '2.0.0', '2.1.0'], '~2.0.0', '2.0.0', true]
-  ].forEach(function (v) {
-    var versions = v[0]
-    var range = v[1]
-    var expect = v[2]
-    var loose = v[3]
-    var actual = semver.minSatisfying(versions, range, loose)
-    t.equal(actual, expect)
-  })
-  t.end()
-})
-
-test('intersect comparators', function (t) {
-  [
-    // One is a Version
-    ['1.3.0', '>=1.3.0', true],
-    ['1.3.0', '>1.3.0', false],
-    ['>=1.3.0', '1.3.0', true],
-    ['>1.3.0', '1.3.0', false],
-    // Same direction increasing
-    ['>1.3.0', '>1.2.0', true],
-    ['>1.2.0', '>1.3.0', true],
-    ['>=1.2.0', '>1.3.0', true],
-    ['>1.2.0', '>=1.3.0', true],
-    // Same direction decreasing
-    ['<1.3.0', '<1.2.0', true],
-    ['<1.2.0', '<1.3.0', true],
-    ['<=1.2.0', '<1.3.0', true],
-    ['<1.2.0', '<=1.3.0', true],
-    // Different directions, same semver and inclusive operator
-    ['>=1.3.0', '<=1.3.0', true],
-    ['>=v1.3.0', '<=1.3.0', true],
-    ['>=1.3.0', '>=1.3.0', true],
-    ['<=1.3.0', '<=1.3.0', true],
-    ['<=1.3.0', '<=v1.3.0', true],
-    ['>1.3.0', '<=1.3.0', false],
-    ['>=1.3.0', '<1.3.0', false],
-    // Opposite matching directions
-    ['>1.0.0', '<2.0.0', true],
-    ['>=1.0.0', '<2.0.0', true],
-    ['>=1.0.0', '<=2.0.0', true],
-    ['>1.0.0', '<=2.0.0', true],
-    ['<=2.0.0', '>1.0.0', true],
-    ['<=1.0.0', '>=2.0.0', false]
-  ].forEach(function (v) {
-    var comparator1 = new Comparator(v[0])
-    var comparator2 = new Comparator(v[1])
-    var expect = v[2]
-
-    var actual1 = comparator1.intersects(comparator2, false)
-    var actual2 = comparator2.intersects(comparator1, { loose: false })
-    var actual3 = semver.intersects(comparator1, comparator2)
-    var actual4 = semver.intersects(comparator2, comparator1)
-    var actual5 = semver.intersects(comparator1, comparator2, true)
-    var actual6 = semver.intersects(comparator2, comparator1, true)
-    var actual7 = semver.intersects(v[0], v[1])
-    var actual8 = semver.intersects(v[1], v[0])
-    var actual9 = semver.intersects(v[0], v[1], true)
-    var actual10 = semver.intersects(v[1], v[0], true)
-    t.equal(actual1, expect)
-    t.equal(actual2, expect)
-    t.equal(actual3, expect)
-    t.equal(actual4, expect)
-    t.equal(actual5, expect)
-    t.equal(actual6, expect)
-    t.equal(actual7, expect)
-    t.equal(actual8, expect)
-    t.equal(actual9, expect)
-    t.equal(actual10, expect)
-  })
-  t.end()
-})
-
-test('missing comparator parameter in intersect comparators', function (t) {
-  t.throws(function () {
-    new Comparator('>1.0.0').intersects()
-  }, new TypeError('a Comparator is required'),
-  'throws type error')
-  t.end()
-})
-
-test('ranges intersect', function (t) {
-  [
-    ['1.3.0 || <1.0.0 >2.0.0', '1.3.0 || <1.0.0 >2.0.0', true],
-    ['<1.0.0 >2.0.0', '>0.0.0', true],
-    ['<1.0.0 >2.0.0', '>1.4.0 <1.6.0', false],
-    ['<1.0.0 >2.0.0', '>1.4.0 <1.6.0 || 2.0.0', false],
-    ['>1.0.0 <=2.0.0', '2.0.0', true],
-    ['<1.0.0 >=2.0.0', '2.1.0', false],
-    ['<1.0.0 >=2.0.0', '>1.4.0 <1.6.0 || 2.0.0', false]
-  ].forEach(function (v) {
-    var range1 = new Range(v[0])
-    var range2 = new Range(v[1])
-    var expect = v[2]
-    var actual1 = range1.intersects(range2)
-    var actual2 = range2.intersects(range1)
-    var actual3 = semver.intersects(v[1], v[0])
-    var actual4 = semver.intersects(v[0], v[1])
-    var actual5 = semver.intersects(v[1], v[0], true)
-    var actual6 = semver.intersects(v[0], v[1], true)
-    var actual7 = semver.intersects(range1, range2)
-    var actual8 = semver.intersects(range2, range1)
-    var actual9 = semver.intersects(range1, range2, true)
-    var actual0 = semver.intersects(range2, range1, true)
-    t.equal(actual1, expect)
-    t.equal(actual2, expect)
-    t.equal(actual3, expect)
-    t.equal(actual4, expect)
-    t.equal(actual5, expect)
-    t.equal(actual6, expect)
-    t.equal(actual7, expect)
-    t.equal(actual8, expect)
-    t.equal(actual9, expect)
-    t.equal(actual0, expect)
-  })
-  t.end()
-})
-
-test('missing range parameter in range intersect', function (t) {
-  t.throws(function () {
-    new Range('1.0.0').intersects()
-  }, new TypeError('a Range is required'),
-  'throws type error')
-  t.end()
-})
-
-test('outside with bad hilo throws', function (t) {
-  t.throws(function () {
-    semver.outside('1.2.3', '>1.5.0', 'blerg', true)
-  }, new TypeError('Must provide a hilo val of "<" or ">"'))
-  t.end()
-})
-
-test('comparator testing', function (t) {
-  var c = new Comparator('>=1.2.3')
-  t.ok(c.test('1.2.4'))
-  var c2 = new Comparator(c)
-  t.ok(c2.test('1.2.4'))
-  var c3 = new Comparator(c, true)
-  t.ok(c3.test('1.2.4'))
-  t.end()
-})
-
-test('tostrings', function (t) {
-  t.equal(Range('>= v1.2.3').toString(), '>=1.2.3')
-  t.equal(Comparator('>= v1.2.3').toString(), '>=1.2.3')
-  t.end()
-})
-
-test('invalid cmp usage', function (t) {
-  t.throws(function () {
-    cmp('1.2.3', 'a frog', '4.5.6')
-  }, new TypeError('Invalid operator: a frog'))
-  t.end()
-})
-
-test('sorting', function (t) {
-  var list = [
-    '1.2.3',
-    '5.9.6',
-    '0.1.2'
-  ]
-  var sorted = [
-    '0.1.2',
-    '1.2.3',
-    '5.9.6'
-  ]
-  var rsorted = [
-    '5.9.6',
-    '1.2.3',
-    '0.1.2'
-  ]
-  t.same(semver.sort(list), sorted)
-  t.same(semver.rsort(list), rsorted)
-  t.end()
-})
-
-test('bad ranges in max/min satisfying', function (t) {
-  var r = 'some frogs and sneks-v2.5.6'
-  t.equal(semver.maxSatisfying([], r), null)
-  t.equal(semver.minSatisfying([], r), null)
-  t.end()
-})
-
-test('really big numeric prerelease value', function (t) {
-  var r = SemVer('1.2.3-beta.' + Number.MAX_SAFE_INTEGER + '0')
-  t.strictSame(r.prerelease, [ 'beta', '90071992547409910' ])
-  t.end()
-})
+const t = require('tap')
+const semver = require('../')
+const { SEMVER_SPEC_VERSION } = require('../internal/constants')
+
+t.match(Object.getOwnPropertyDescriptor(semver, 'SEMVER_SPEC_VERSION'), {
+  get: undefined,
+  set: undefined,
+  value: SEMVER_SPEC_VERSION,
+  configurable: true,
+  enumerable: true,
+}, 'just a normal value property')
diff --git a/test/integration/whitespace.js b/test/integration/whitespace.js
new file mode 100644
index 00000000..a3541325
--- /dev/null
+++ b/test/integration/whitespace.js
@@ -0,0 +1,49 @@
+const { test } = require('tap')
+const Range = require('../../classes/range')
+const SemVer = require('../../classes/semver')
+const Comparator = require('../../classes/comparator')
+const validRange = require('../../ranges/valid')
+const minVersion = require('../../ranges/min-version')
+const minSatisfying = require('../../ranges/min-satisfying')
+const maxSatisfying = require('../../ranges/max-satisfying')
+
+const wsMedium = ' '.repeat(125)
+const wsLarge = ' '.repeat(500000)
+const zeroLarge = '0'.repeat(500000)
+
+test('range with whitespace', (t) => {
+  // a range with these extra characters would take a few minutes to process if
+  // any redos susceptible regexes were used. there is a global tap timeout per
+  // file set in the package.json that will error if this test takes too long.
+  const r = `1.2.3 ${wsLarge} <1.3.0`
+  t.equal(new Range(r).range, '1.2.3 <1.3.0')
+  t.equal(validRange(r), '1.2.3 <1.3.0')
+  t.equal(minVersion(r).version, '1.2.3')
+  t.equal(minSatisfying(['1.2.3'], r), '1.2.3')
+  t.equal(maxSatisfying(['1.2.3'], r), '1.2.3')
+  t.end()
+})
+
+test('range with 0', (t) => {
+  const r = `1.2.3 ${zeroLarge} <1.3.0`
+  t.throws(() => new Range(r).range)
+  t.equal(validRange(r), null)
+  t.throws(() => minVersion(r).version)
+  t.equal(minSatisfying(['1.2.3'], r), null)
+  t.equal(maxSatisfying(['1.2.3'], r), null)
+  t.end()
+})
+
+test('semver version', (t) => {
+  const v = `${wsMedium}1.2.3${wsMedium}`
+  const tooLong = `${wsLarge}1.2.3${wsLarge}`
+  t.equal(new SemVer(v).version, '1.2.3')
+  t.throws(() => new SemVer(tooLong))
+  t.end()
+})
+
+test('comparator', (t) => {
+  const comparator = `${wsLarge}<${wsLarge}1.2.3${wsLarge}`
+  t.equal(new Comparator(comparator).value, '<1.2.3')
+  t.end()
+})
diff --git a/test/internal/constants.js b/test/internal/constants.js
new file mode 100644
index 00000000..a8f6ab2d
--- /dev/null
+++ b/test/internal/constants.js
@@ -0,0 +1,10 @@
+const t = require('tap')
+const constants = require('../../internal/constants')
+
+t.match(constants, {
+  MAX_LENGTH: Number,
+  MAX_SAFE_COMPONENT_LENGTH: Number,
+  MAX_SAFE_INTEGER: Number,
+  RELEASE_TYPES: Array,
+  SEMVER_SPEC_VERSION: String,
+}, 'got appropriate data types exported')
diff --git a/test/internal/debug.js b/test/internal/debug.js
new file mode 100644
index 00000000..cafe0773
--- /dev/null
+++ b/test/internal/debug.js
@@ -0,0 +1,40 @@
+const main = () => {
+  const t = require('tap')
+  const { spawn } = require('child_process')
+  t.plan(2)
+  t.test('without env set', t => {
+    const c = spawn(process.execPath, [__filename, 'child'], { env: {
+      ...process.env,
+      NODE_DEBUG: '',
+    } })
+    const err = []
+    c.stderr.on('data', chunk => err.push(chunk))
+    c.on('close', (code, signal) => {
+      t.equal(code, 0, 'success exit status')
+      t.equal(signal, null, 'no signal')
+      t.equal(Buffer.concat(err).toString('utf8'), '', 'got no output')
+      t.end()
+    })
+  })
+  t.test('with env set', t => {
+    const c = spawn(process.execPath, [__filename, 'child'], { env: {
+      ...process.env,
+      NODE_DEBUG: 'semver',
+    } })
+    const err = []
+    c.stderr.on('data', chunk => err.push(chunk))
+    c.on('close', (code, signal) => {
+      t.equal(code, 0, 'success exit status')
+      t.equal(signal, null, 'no signal')
+      t.equal(Buffer.concat(err).toString('utf8'), 'SEMVER hello, world\n', 'got expected output')
+      t.end()
+    })
+  })
+  t.end()
+}
+
+if (process.argv[2] === 'child') {
+  require('../../internal/debug')('hello, world')
+} else {
+  main()
+}
diff --git a/test/internal/identifiers.js b/test/internal/identifiers.js
new file mode 100644
index 00000000..6497c366
--- /dev/null
+++ b/test/internal/identifiers.js
@@ -0,0 +1,19 @@
+const { test } = require('tap')
+const { compareIdentifiers, rcompareIdentifiers } = require('../../internal/identifiers')
+
+test('rcompareIdentifiers and compareIdentifiers', (t) => {
+  const set = [
+    ['1', '2'],
+    ['alpha', 'beta'],
+    ['0', 'beta'],
+  ]
+  set.forEach((ab) => {
+    const a = ab[0]
+    const b = ab[1]
+    t.equal(compareIdentifiers(a, b), -1)
+    t.equal(rcompareIdentifiers(a, b), 1)
+  })
+  t.equal(compareIdentifiers('0', '0'), 0)
+  t.equal(rcompareIdentifiers('0', '0'), 0)
+  t.end()
+})
diff --git a/test/internal/parse-options.js b/test/internal/parse-options.js
new file mode 100644
index 00000000..2400537d
--- /dev/null
+++ b/test/internal/parse-options.js
@@ -0,0 +1,43 @@
+const t = require('tap')
+const parseOptions = require('../../internal/parse-options.js')
+
+t.test('falsey values always empty options object', t => {
+  t.strictSame(parseOptions(null), {})
+  t.strictSame(parseOptions(false), {})
+  t.strictSame(parseOptions(undefined), {})
+  t.strictSame(parseOptions(), {})
+  t.strictSame(parseOptions(0), {})
+  t.strictSame(parseOptions(''), {})
+  t.end()
+})
+
+t.test('truthy non-objects always loose mode, for backwards comp', t => {
+  t.strictSame(parseOptions('hello'), { loose: true })
+  t.strictSame(parseOptions(true), { loose: true })
+  t.strictSame(parseOptions(1), { loose: true })
+  t.end()
+})
+
+t.test('any object passed is returned', t => {
+  t.strictSame(parseOptions(/asdf/), /asdf/)
+  t.strictSame(parseOptions(new Error('hello')), new Error('hello'))
+  t.strictSame(parseOptions({ loose: true, a: 1, rtl: false }), { loose: true, a: 1, rtl: false })
+  t.strictSame(parseOptions({ loose: 1, rtl: 2, includePrerelease: 10 }), {
+    loose: 1,
+    rtl: 2,
+    includePrerelease: 10,
+  })
+  t.strictSame(parseOptions({ loose: true }), { loose: true })
+  t.strictSame(parseOptions({ rtl: true }), { rtl: true })
+  t.strictSame(parseOptions({ includePrerelease: true }), { includePrerelease: true })
+  t.strictSame(parseOptions({ loose: true, rtl: true }), { loose: true, rtl: true })
+  t.strictSame(parseOptions({ loose: true, includePrerelease: true }), {
+    loose: true,
+    includePrerelease: true,
+  })
+  t.strictSame(parseOptions({ rtl: true, includePrerelease: true }), {
+    rtl: true,
+    includePrerelease: true,
+  })
+  t.end()
+})
diff --git a/test/internal/re.js b/test/internal/re.js
new file mode 100644
index 00000000..2851b325
--- /dev/null
+++ b/test/internal/re.js
@@ -0,0 +1,23 @@
+const { test } = require('tap')
+const { src, re, safeRe } = require('../../internal/re')
+const semver = require('../../')
+
+test('has a list of src, re, and tokens', (t) => {
+  t.match(Object.assign({}, semver), {
+    src: Array,
+    re: Array,
+    tokens: Object,
+  })
+  re.forEach(r => t.match(r, RegExp, 'regexps are regexps'))
+  src.forEach(s => t.match(s, String, 'src is strings'))
+  for (const i in semver.tokens) {
+    t.match(semver.tokens[i], Number, 'tokens are numbers')
+  }
+
+  safeRe.forEach(r => {
+    t.notMatch(r.source, '\\s+', 'safe regex do not contain greedy whitespace')
+    t.notMatch(r.source, '\\s*', 'safe regex do not contain greedy whitespace')
+  })
+
+  t.end()
+})
diff --git a/test/ltr.js b/test/ltr.js
deleted file mode 100644
index b6376668..00000000
--- a/test/ltr.js
+++ /dev/null
@@ -1,181 +0,0 @@
-var tap = require('tap')
-var test = tap.test
-var semver = require('../semver.js')
-var ltr = semver.ltr
-
-test('\nltr tests', function (t) {
-  // [range, version, loose]
-  // Version should be less than range
-  [
-    ['~1.2.2', '1.2.1'],
-    ['~0.6.1-1', '0.6.1-0'],
-    ['1.0.0 - 2.0.0', '0.0.1'],
-    ['1.0.0-beta.2', '1.0.0-beta.1'],
-    ['1.0.0', '0.0.0'],
-    ['>=2.0.0', '1.1.1'],
-    ['>=2.0.0', '1.2.9'],
-    ['>2.0.0', '2.0.0'],
-    ['0.1.20 || 1.2.4', '0.1.5'],
-    ['2.x.x', '1.0.0'],
-    ['1.2.x', '1.1.0'],
-    ['1.2.x || 2.x', '1.0.0'],
-    ['2.*.*', '1.0.1'],
-    ['1.2.*', '1.1.3'],
-    ['1.2.* || 2.*', '1.1.9999'],
-    ['2', '1.0.0'],
-    ['2.3', '2.2.2'],
-    ['~2.4', '2.3.0'], // >=2.4.0 <2.5.0
-    ['~2.4', '2.3.5'],
-    ['~>3.2.1', '3.2.0'], // >=3.2.1 <3.3.0
-    ['~1', '0.2.3'], // >=1.0.0 <2.0.0
-    ['~>1', '0.2.4'],
-    ['~> 1', '0.2.3'],
-    ['~1.0', '0.1.2'], // >=1.0.0 <1.1.0
-    ['~ 1.0', '0.1.0'],
-    ['>1.2', '1.2.0'],
-    ['> 1.2', '1.2.1'],
-    ['1', '0.0.0beta', true],
-    ['~v0.5.4-pre', '0.5.4-alpha'],
-    ['~v0.5.4-pre', '0.5.4-alpha'],
-    ['=0.7.x', '0.6.0'],
-    ['=0.7.x', '0.6.0-asdf'],
-    ['>=0.7.x', '0.6.0'],
-    ['~1.2.2', '1.2.1'],
-    ['1.0.0 - 2.0.0', '0.2.3'],
-    ['1.0.0', '0.0.1'],
-    ['>=2.0.0', '1.0.0'],
-    ['>=2.0.0', '1.9999.9999'],
-    ['>=2.0.0', '1.2.9'],
-    ['>2.0.0', '2.0.0'],
-    ['>2.0.0', '1.2.9'],
-    ['2.x.x', '1.1.3'],
-    ['1.2.x', '1.1.3'],
-    ['1.2.x || 2.x', '1.1.3'],
-    ['2.*.*', '1.1.3'],
-    ['1.2.*', '1.1.3'],
-    ['1.2.* || 2.*', '1.1.3'],
-    ['2', '1.9999.9999'],
-    ['2.3', '2.2.1'],
-    ['~2.4', '2.3.0'], // >=2.4.0 <2.5.0
-    ['~>3.2.1', '2.3.2'], // >=3.2.1 <3.3.0
-    ['~1', '0.2.3'], // >=1.0.0 <2.0.0
-    ['~>1', '0.2.3'],
-    ['~1.0', '0.0.0'], // >=1.0.0 <1.1.0
-    ['>1', '1.0.0'],
-    ['2', '1.0.0beta', true],
-    ['>1', '1.0.0beta', true],
-    ['> 1', '1.0.0beta', true],
-    ['=0.7.x', '0.6.2'],
-    ['=0.7.x', '0.7.0-asdf'],
-    ['^1', '1.0.0-0'],
-    ['>=0.7.x', '0.7.0-asdf'],
-    ['1', '1.0.0beta', true],
-    ['>=0.7.x', '0.6.2'],
-    ['>1.2.3', '1.3.0-alpha']
-  ].forEach(function (tuple) {
-    var range = tuple[0]
-    var version = tuple[1]
-    var loose = tuple[2] || false
-    var msg = 'ltr(' + version + ', ' + range + ', ' + loose + ')'
-    t.ok(ltr(version, range, loose), msg)
-  })
-  t.end()
-})
-
-test('\nnegative ltr tests', function (t) {
-  // [range, version, loose]
-  // Version should NOT be less than range
-  [
-    ['~ 1.0', '1.1.0'],
-    ['~0.6.1-1', '0.6.1-1'],
-    ['1.0.0 - 2.0.0', '1.2.3'],
-    ['1.0.0 - 2.0.0', '2.9.9'],
-    ['1.0.0', '1.0.0'],
-    ['>=*', '0.2.4'],
-    ['', '1.0.0', true],
-    ['*', '1.2.3'],
-    ['>=1.0.0', '1.0.0'],
-    ['>=1.0.0', '1.0.1'],
-    ['>=1.0.0', '1.1.0'],
-    ['>1.0.0', '1.0.1'],
-    ['>1.0.0', '1.1.0'],
-    ['<=2.0.0', '2.0.0'],
-    ['<=2.0.0', '1.9999.9999'],
-    ['<=2.0.0', '0.2.9'],
-    ['<2.0.0', '1.9999.9999'],
-    ['<2.0.0', '0.2.9'],
-    ['>= 1.0.0', '1.0.0'],
-    ['>=  1.0.0', '1.0.1'],
-    ['>=   1.0.0', '1.1.0'],
-    ['> 1.0.0', '1.0.1'],
-    ['>  1.0.0', '1.1.0'],
-    ['<=   2.0.0', '2.0.0'],
-    ['<= 2.0.0', '1.9999.9999'],
-    ['<=  2.0.0', '0.2.9'],
-    ['<    2.0.0', '1.9999.9999'],
-    ['<\t2.0.0', '0.2.9'],
-    ['>=0.1.97', 'v0.1.97'],
-    ['>=0.1.97', '0.1.97'],
-    ['0.1.20 || 1.2.4', '1.2.4'],
-    ['0.1.20 || >1.2.4', '1.2.4'],
-    ['0.1.20 || 1.2.4', '1.2.3'],
-    ['0.1.20 || 1.2.4', '0.1.20'],
-    ['>=0.2.3 || <0.0.1', '0.0.0'],
-    ['>=0.2.3 || <0.0.1', '0.2.3'],
-    ['>=0.2.3 || <0.0.1', '0.2.4'],
-    ['||', '1.3.4'],
-    ['2.x.x', '2.1.3'],
-    ['1.2.x', '1.2.3'],
-    ['1.2.x || 2.x', '2.1.3'],
-    ['1.2.x || 2.x', '1.2.3'],
-    ['x', '1.2.3'],
-    ['2.*.*', '2.1.3'],
-    ['1.2.*', '1.2.3'],
-    ['1.2.* || 2.*', '2.1.3'],
-    ['1.2.* || 2.*', '1.2.3'],
-    ['1.2.* || 2.*', '1.2.3'],
-    ['*', '1.2.3'],
-    ['2', '2.1.2'],
-    ['2.3', '2.3.1'],
-    ['~2.4', '2.4.0'], // >=2.4.0 <2.5.0
-    ['~2.4', '2.4.5'],
-    ['~>3.2.1', '3.2.2'], // >=3.2.1 <3.3.0
-    ['~1', '1.2.3'], // >=1.0.0 <2.0.0
-    ['~>1', '1.2.3'],
-    ['~> 1', '1.2.3'],
-    ['~1.0', '1.0.2'], // >=1.0.0 <1.1.0
-    ['~ 1.0', '1.0.2'],
-    ['>=1', '1.0.0'],
-    ['>= 1', '1.0.0'],
-    ['<1.2', '1.1.1'],
-    ['< 1.2', '1.1.1'],
-    ['~v0.5.4-pre', '0.5.5'],
-    ['~v0.5.4-pre', '0.5.4'],
-    ['=0.7.x', '0.7.2'],
-    ['>=0.7.x', '0.7.2'],
-    ['<=0.7.x', '0.6.2'],
-    ['>0.2.3 >0.2.4 <=0.2.5', '0.2.5'],
-    ['>=0.2.3 <=0.2.4', '0.2.4'],
-    ['1.0.0 - 2.0.0', '2.0.0'],
-    ['^3.0.0', '4.0.0'],
-    ['^1.0.0 || ~2.0.1', '2.0.0'],
-    ['^0.1.0 || ~3.0.1 || 5.0.0', '3.2.0'],
-    ['^0.1.0 || ~3.0.1 || 5.0.0', '1.0.0beta', true],
-    ['^0.1.0 || ~3.0.1 || 5.0.0', '5.0.0-0', true],
-    ['^0.1.0 || ~3.0.1 || >4 <=5.0.0', '3.5.0'],
-    ['^1.0.0alpha', '1.0.0beta', true],
-    ['~1.0.0alpha', '1.0.0beta', true],
-    ['^1.0.0-alpha', '1.0.0beta', true],
-    ['~1.0.0-alpha', '1.0.0beta', true],
-    ['^1.0.0-alpha', '1.0.0-beta'],
-    ['~1.0.0-alpha', '1.0.0-beta'],
-    ['=0.1.0', '1.0.0']
-  ].forEach(function (tuple) {
-    var range = tuple[0]
-    var version = tuple[1]
-    var loose = tuple[2] || false
-    var msg = '!ltr(' + version + ', ' + range + ', ' + loose + ')'
-    t.notOk(ltr(version, range, loose), msg)
-  })
-  t.end()
-})
diff --git a/test/major-minor-patch.js b/test/major-minor-patch.js
deleted file mode 100644
index a074878e..00000000
--- a/test/major-minor-patch.js
+++ /dev/null
@@ -1,72 +0,0 @@
-var tap = require('tap')
-var test = tap.test
-var semver = require('../semver.js')
-
-test('\nmajor tests', function (t) {
-  // [range, version]
-  // Version should be detectable despite extra characters
-  [
-    ['1.2.3', 1],
-    [' 1.2.3 ', 1],
-    [' 2.2.3-4 ', 2],
-    [' 3.2.3-pre ', 3],
-    ['v5.2.3', 5],
-    [' v8.2.3 ', 8],
-    ['\t13.2.3', 13],
-    ['=21.2.3', 21, true],
-    ['v=34.2.3', 34, true]
-  ].forEach(function (tuple) {
-    var range = tuple[0]
-    var version = tuple[1]
-    var loose = tuple[2] || false
-    var msg = 'major(' + range + ') = ' + version
-    t.equal(semver.major(range, loose), version, msg)
-  })
-  t.end()
-})
-
-test('\nminor tests', function (t) {
-  // [range, version]
-  // Version should be detectable despite extra characters
-  [
-    ['1.1.3', 1],
-    [' 1.1.3 ', 1],
-    [' 1.2.3-4 ', 2],
-    [' 1.3.3-pre ', 3],
-    ['v1.5.3', 5],
-    [' v1.8.3 ', 8],
-    ['\t1.13.3', 13],
-    ['=1.21.3', 21, true],
-    ['v=1.34.3', 34, true]
-  ].forEach(function (tuple) {
-    var range = tuple[0]
-    var version = tuple[1]
-    var loose = tuple[2] || false
-    var msg = 'minor(' + range + ') = ' + version
-    t.equal(semver.minor(range, loose), version, msg)
-  })
-  t.end()
-})
-
-test('\npatch tests', function (t) {
-  // [range, version]
-  // Version should be detectable despite extra characters
-  [
-    ['1.2.1', 1],
-    [' 1.2.1 ', 1],
-    [' 1.2.2-4 ', 2],
-    [' 1.2.3-pre ', 3],
-    ['v1.2.5', 5],
-    [' v1.2.8 ', 8],
-    ['\t1.2.13', 13],
-    ['=1.2.21', 21, true],
-    ['v=1.2.34', 34, true]
-  ].forEach(function (tuple) {
-    var range = tuple[0]
-    var version = tuple[1]
-    var loose = tuple[2] || false
-    var msg = 'patch(' + range + ') = ' + version
-    t.equal(semver.patch(range, loose), version, msg)
-  })
-  t.end()
-})
diff --git a/test/map.js b/test/map.js
new file mode 100644
index 00000000..5c36eb7d
--- /dev/null
+++ b/test/map.js
@@ -0,0 +1,46 @@
+const t = require('tap')
+const { resolve, join, relative, extname, dirname, basename } = require('path')
+const { statSync, readdirSync } = require('fs')
+const map = require('../map.js')
+const pkg = require('../package.json')
+
+const ROOT = resolve(__dirname, '..')
+const TEST = join(ROOT, 'test')
+const IGNORE_DIRS = ['fixtures', 'integration']
+
+const getFile = (f) => {
+  try {
+    if (statSync(f).isFile()) {
+      return extname(f) === '.js' ? [f] : []
+    }
+  } catch {
+    return []
+  }
+}
+
+const walk = (item, res = []) => getFile(item) || readdirSync(item)
+  .map(f => join(item, f))
+  .reduce((acc, f) => acc.concat(statSync(f).isDirectory() ? walk(f, res) : getFile(f)), [])
+  .filter(Boolean)
+
+const walkAll = (items, relativeTo) => items
+  .reduce((acc, f) => acc.concat(walk(join(ROOT, f))), [])
+  .map((f) => relative(relativeTo, f))
+  .sort()
+
+t.test('tests match system', t => {
+  const sut = walkAll([pkg.tap['coverage-map'], ...pkg.files], ROOT)
+  const tests = walkAll([basename(TEST)], TEST)
+    .filter(f => !IGNORE_DIRS.includes(dirname(f)))
+
+  t.strictSame(sut, tests, 'test files should match system files')
+
+  for (const f of tests) {
+    t.test(f, t => {
+      t.plan(1)
+      t.ok(sut.includes(map(f)), 'test covers a file')
+    })
+  }
+
+  t.end()
+})
diff --git a/test/preload.js b/test/preload.js
new file mode 100644
index 00000000..2f56aa5f
--- /dev/null
+++ b/test/preload.js
@@ -0,0 +1,4 @@
+const t = require('tap')
+const preload = require('../preload.js')
+const index = require('../index.js')
+t.equal(preload, index, 'preload and index match')
diff --git a/test/ranges/gtr.js b/test/ranges/gtr.js
new file mode 100644
index 00000000..81a1b00a
--- /dev/null
+++ b/test/ranges/gtr.js
@@ -0,0 +1,30 @@
+const { test } = require('tap')
+const gtr = require('../../ranges/gtr')
+const versionGtr = require('../fixtures/version-gt-range')
+const versionNotGtr = require('../fixtures/version-not-gt-range')
+
+test('gtr tests', (t) => {
+  // [range, version, options]
+  // Version should be greater than range
+  versionGtr.forEach((tuple) => {
+    const range = tuple[0]
+    const version = tuple[1]
+    const options = tuple[2] || false
+    const msg = `gtr(${version}, ${range}, ${options})`
+    t.ok(gtr(version, range, options), msg)
+  })
+  t.end()
+})
+
+test('negative gtr tests', (t) => {
+  // [range, version, options]
+  // Version should NOT be greater than range
+  versionNotGtr.forEach((tuple) => {
+    const range = tuple[0]
+    const version = tuple[1]
+    const options = tuple[2] || false
+    const msg = `!gtr(${version}, ${range}, ${options})`
+    t.notOk(gtr(version, range, options), msg)
+  })
+  t.end()
+})
diff --git a/test/ranges/intersects.js b/test/ranges/intersects.js
new file mode 100644
index 00000000..b23ad03d
--- /dev/null
+++ b/test/ranges/intersects.js
@@ -0,0 +1,58 @@
+const { test } = require('tap')
+const intersects = require('../../ranges/intersects')
+const Range = require('../../classes/range')
+const Comparator = require('../../classes/comparator')
+const comparatorIntersection = require('../fixtures/comparator-intersection.js')
+const rangeIntersection = require('../fixtures/range-intersection.js')
+
+test('intersect comparators', t => {
+  t.plan(comparatorIntersection.length)
+  comparatorIntersection.forEach(([c0, c1, expect, includePrerelease]) =>
+    t.test(`${c0} ${c1} ${expect}`, t => {
+      const opts = { loose: false, includePrerelease }
+      const comp0 = new Comparator(c0)
+      const comp1 = new Comparator(c1)
+
+      t.equal(intersects(comp0, comp1, opts), expect, `${c0} intersects ${c1} objects`)
+      t.equal(intersects(comp1, comp0, opts), expect, `${c1} intersects ${c0} objects`)
+      t.equal(intersects(c0, c1, opts), expect, `${c0} intersects ${c1}`)
+      t.equal(intersects(c1, c0, opts), expect, `${c1} intersects ${c0}`)
+
+      opts.loose = true
+      t.equal(intersects(comp0, comp1, opts), expect, `${c0} intersects ${c1} loose, objects`)
+      t.equal(intersects(comp1, comp0, opts), expect, `${c1} intersects ${c0} loose, objects`)
+      t.equal(intersects(c0, c1, opts), expect, `${c0} intersects ${c1} loose`)
+      t.equal(intersects(c1, c0, opts), expect, `${c1} intersects ${c0} loose`)
+      t.end()
+    }))
+})
+
+test('ranges intersect', (t) => {
+  rangeIntersection.forEach(([r0, r1, expect]) => {
+    t.test(`${r0} <~> ${r1}`, t => {
+      const range0 = new Range(r0)
+      const range1 = new Range(r1)
+
+      t.equal(intersects(r1, r0), expect, `${r0} <~> ${r1}`)
+      t.equal(intersects(r0, r1), expect, `${r1} <~> ${r0}`)
+      t.equal(intersects(r1, r0, true), expect, `${r0} <~> ${r1} loose`)
+      t.equal(intersects(r0, r1, true), expect, `${r1} <~> ${r0} loose`)
+      t.equal(intersects(range0, range1), expect, `${r0} <~> ${r1} objects`)
+      t.equal(intersects(range1, range0), expect, `${r1} <~> ${r0} objects`)
+      t.equal(intersects(range0, range1, true), expect,
+        `${r0} <~> ${r1} objects loose`)
+      t.equal(intersects(range1, range0, true), expect,
+        `${r1} <~> ${r0} objects loose`)
+      t.end()
+    })
+  })
+  t.end()
+})
+
+test('missing comparator parameter in intersect comparators', (t) => {
+  t.throws(() => {
+    new Comparator('>1.0.0').intersects()
+  }, new TypeError('a Comparator is required'),
+  'throws type error')
+  t.end()
+})
diff --git a/test/ranges/ltr.js b/test/ranges/ltr.js
new file mode 100644
index 00000000..e864a970
--- /dev/null
+++ b/test/ranges/ltr.js
@@ -0,0 +1,24 @@
+const { test } = require('tap')
+const ltr = require('../../ranges/ltr')
+const versionLtr = require('../fixtures/version-lt-range')
+const versionNotLtr = require('../fixtures/version-not-lt-range')
+
+test('ltr tests', (t) => {
+  // [range, version, options]
+  // Version should be less than range
+  versionLtr.forEach(([range, version, options = false]) => {
+    const msg = `ltr(${version}, ${range}, ${options})`
+    t.ok(ltr(version, range, options), msg)
+  })
+  t.end()
+})
+
+test('negative ltr tests', (t) => {
+  // [range, version, options]
+  // Version should NOT be less than range
+  versionNotLtr.forEach(([range, version, options = false]) => {
+    const msg = `!ltr(${version}, ${range}, ${options})`
+    t.notOk(ltr(version, range, options), msg)
+  })
+  t.end()
+})
diff --git a/test/ranges/max-satisfying.js b/test/ranges/max-satisfying.js
new file mode 100644
index 00000000..105f4faf
--- /dev/null
+++ b/test/ranges/max-satisfying.js
@@ -0,0 +1,25 @@
+const { test } = require('tap')
+const maxSatisfying = require('../../ranges/max-satisfying')
+
+test('max satisfying', (t) => {
+  [[['1.2.3', '1.2.4'], '1.2', '1.2.4'],
+    [['1.2.4', '1.2.3'], '1.2', '1.2.4'],
+    [['1.2.3', '1.2.4', '1.2.5', '1.2.6'], '~1.2.3', '1.2.6'],
+    [['1.1.0', '1.2.0', '1.2.1', '1.3.0', '2.0.0b1', '2.0.0b2', '2.0.0b3', '2.0.0', '2.1.0'],
+      '~2.0.0', '2.0.0', true],
+  ].forEach((v) => {
+    const versions = v[0]
+    const range = v[1]
+    const expect = v[2]
+    const loose = v[3]
+    const actual = maxSatisfying(versions, range, loose)
+    t.equal(actual, expect)
+  })
+  t.end()
+})
+
+test('bad ranges in max satisfying', (t) => {
+  const r = 'some frogs and sneks-v2.5.6'
+  t.equal(maxSatisfying([], r), null)
+  t.end()
+})
diff --git a/test/ranges/min-satisfying.js b/test/ranges/min-satisfying.js
new file mode 100644
index 00000000..33f670dc
--- /dev/null
+++ b/test/ranges/min-satisfying.js
@@ -0,0 +1,25 @@
+const { test } = require('tap')
+const minSatisfying = require('../../ranges/min-satisfying')
+
+test('min satisfying', (t) => {
+  [[['1.2.3', '1.2.4'], '1.2', '1.2.3'],
+    [['1.2.4', '1.2.3'], '1.2', '1.2.3'],
+    [['1.2.3', '1.2.4', '1.2.5', '1.2.6'], '~1.2.3', '1.2.3'],
+    [['1.1.0', '1.2.0', '1.2.1', '1.3.0', '2.0.0b1', '2.0.0b2', '2.0.0b3', '2.0.0', '2.1.0'],
+      '~2.0.0', '2.0.0', true],
+  ].forEach((v) => {
+    const versions = v[0]
+    const range = v[1]
+    const expect = v[2]
+    const loose = v[3]
+    const actual = minSatisfying(versions, range, loose)
+    t.equal(actual, expect)
+  })
+  t.end()
+})
+
+test('bad ranges in min satisfying', (t) => {
+  const r = 'some frogs and sneks-v2.5.6'
+  t.equal(minSatisfying([], r), null)
+  t.end()
+})
diff --git a/test/min-version.js b/test/ranges/min-version.js
similarity index 76%
rename from test/min-version.js
rename to test/ranges/min-version.js
index 54350c81..a9bdd430 100644
--- a/test/min-version.js
+++ b/test/ranges/min-version.js
@@ -1,8 +1,7 @@
-var tap = require('tap')
-var test = tap.test
-var semver = require('../semver.js')
+const { test } = require('tap')
+const minVersion = require('../../ranges/min-version')
 
-test('\nminimum version in range tests', function (t) {
+test('minimum version in range tests', (t) => {
   // [range, minimum, loose]
   [
     // Stars
@@ -34,6 +33,7 @@ test('\nminimum version in range tests', function (t) {
     ['^1.1.1', '1.1.1'],
     ['^1.1.1-beta', '1.1.1-beta'],
     ['^1.1.1 || >=2', '1.1.1'],
+    ['^2.16.2 ^2.16', '2.16.2'],
 
     // '-' operator
     ['1.1.1 - 1.8.0', '1.1.1'],
@@ -63,14 +63,17 @@ test('\nminimum version in range tests', function (t) {
     ['>2 || >1.0.0-beta', '1.0.0-beta.0'],
 
     // Impossible range
-    ['>4 <3', null]
-  ].forEach(function (tuple) {
-    var range = tuple[0]
-    var version = tuple[1]
-    var loose = tuple[2] || false
-    var msg = 'minVersion(' + range + ', ' + loose + ') = ' + version
-    var min = semver.minVersion(range, loose)
-    t.ok(min === version || (min && min.version === version), msg)
+    ['>4 <3', null],
+  ].forEach((tuple) => {
+    const range = tuple[0]
+    const version = tuple[1]
+    const loose = tuple[2] || false
+    const msg = `minVersion(${range}, ${loose}) = ${version}`
+    const min = minVersion(range, loose)
+    t.ok(min === version || (min && min.version === version), msg, {
+      found: min,
+      wanted: version,
+    })
   })
   t.end()
 })
diff --git a/test/ranges/outside.js b/test/ranges/outside.js
new file mode 100644
index 00000000..736bbb81
--- /dev/null
+++ b/test/ranges/outside.js
@@ -0,0 +1,53 @@
+const { test } = require('tap')
+const outside = require('../../ranges/outside')
+const versionGtr = require('../fixtures/version-gt-range')
+const versionNotGtr = require('../fixtures/version-not-gt-range')
+const versionLtr = require('../fixtures/version-lt-range')
+const versionNotLtr = require('../fixtures/version-not-lt-range')
+
+test('gtr tests', (t) => {
+  // [range, version, options]
+  // Version should be greater than range
+  versionGtr.forEach(([range, version, options = false]) => {
+    const msg = `outside(${version}, ${range}, > ${options})`
+    t.ok(outside(version, range, '>', options), msg)
+  })
+  t.end()
+})
+
+test('ltr tests', (t) => {
+  // [range, version, options]
+  // Version should be less than range
+  versionLtr.forEach(([range, version, options = false]) => {
+    const msg = `outside(${version}, ${range}, <, ${options})`
+    t.ok(outside(version, range, '<', options), msg)
+  })
+  t.end()
+})
+
+test('negative gtr tests', (t) => {
+  // [range, version, options]
+  // Version should NOT be greater than range
+  versionNotGtr.forEach(([range, version, options = false]) => {
+    const msg = `!outside(${version}, ${range}, > ${options})`
+    t.notOk(outside(version, range, '>', options), msg)
+  })
+  t.end()
+})
+
+test('negative ltr tests', (t) => {
+  // [range, version, options]
+  // Version should NOT be less than range
+  versionNotLtr.forEach(([range, version, options = false]) => {
+    const msg = `!outside(${version}, ${range}, < ${options})`
+    t.notOk(outside(version, range, '<', options), msg)
+  })
+  t.end()
+})
+
+test('outside with bad hilo throws', (t) => {
+  t.throws(() => {
+    outside('1.2.3', '>1.5.0', 'blerg', true)
+  }, new TypeError('Must provide a hilo val of "<" or ">"'))
+  t.end()
+})
diff --git a/test/ranges/simplify.js b/test/ranges/simplify.js
new file mode 100644
index 00000000..e8e794b6
--- /dev/null
+++ b/test/ranges/simplify.js
@@ -0,0 +1,42 @@
+const simplify = require('../../ranges/simplify.js')
+const Range = require('../../classes/range.js')
+const t = require('tap')
+const versions = [
+  '1.0.0',
+  '1.0.1',
+  '1.0.2',
+  '1.0.3',
+  '1.0.4',
+  '1.1.0',
+  '1.1.1',
+  '1.1.2',
+  '1.2.0',
+  '1.2.1',
+  '1.2.2',
+  '1.2.3',
+  '1.2.4',
+  '1.2.5',
+  '2.0.0',
+  '2.0.1',
+  '2.1.0',
+  '2.1.1',
+  '2.1.2',
+  '2.2.0',
+  '2.2.1',
+  '2.2.2',
+  '2.3.0',
+  '2.3.1',
+  '2.4.0',
+  '3.0.0',
+  '3.1.0',
+  '3.2.0',
+  '3.3.0',
+]
+
+t.equal(simplify(versions, '1.x'), '1.x')
+t.equal(simplify(versions, '1.0.0 || 1.0.1 || 1.0.2 || 1.0.3 || 1.0.4'), '<=1.0.4')
+t.equal(simplify(versions, new Range('1.0.0 || 1.0.1 || 1.0.2 || 1.0.3 || 1.0.4')), '<=1.0.4')
+t.equal(simplify(versions, '>=3.0.0 <3.1.0'), '3.0.0')
+t.equal(simplify(versions, '3.0.0 || 3.1 || 3.2 || 3.3'), '>=3.0.0')
+t.equal(simplify(versions, '1 || 2 || 3'), '*')
+t.equal(simplify(versions, '2.1 || 2.2 || 2.3'), '2.1.0 - 2.3.1')
diff --git a/test/ranges/subset.js b/test/ranges/subset.js
new file mode 100644
index 00000000..a0e3f2c1
--- /dev/null
+++ b/test/ranges/subset.js
@@ -0,0 +1,142 @@
+const t = require('tap')
+const subset = require('../../ranges/subset.js')
+const Range = require('../../classes/range')
+
+// sub, dom, expect, [options]
+const cases = [
+  ['1.2.3', '1.2.3', true],
+  ['1.2.3', '1.x', true],
+  ['1.2.3 1.2.4', '1.2.3', true],
+  ['1.2.3 1.2.4', '1.2.9', true], // null set is subset of everything
+  ['1.2.3', '>1.2.0', true],
+  ['1.2.3 2.3.4 || 2.3.4', '3', false],
+  ['^1.2.3-pre.0', '1.x', false],
+  ['^1.2.3-pre.0', '1.x', true, { includePrerelease: true }],
+  ['>2 <1', '3', true],
+  ['1 || 2 || 3', '>=1.0.0', true],
+
+  // everything is a subset of *
+  ['1.2.3', '*', true],
+  ['^1.2.3', '*', true],
+  ['^1.2.3-pre.0', '*', false],
+  ['^1.2.3-pre.0', '*', true, { includePrerelease: true }],
+  ['1 || 2 || 3', '*', true],
+
+  // prerelease edge cases
+  ['^1.2.3-pre.0', '>=1.0.0', false],
+  ['^1.2.3-pre.0', '>=1.0.0', true, { includePrerelease: true }],
+  ['^1.2.3-pre.0', '>=1.2.3-pre.0', true],
+  ['^1.2.3-pre.0', '>=1.2.3-pre.0', true, { includePrerelease: true }],
+  ['>1.2.3-pre.0', '>=1.2.3-pre.0', true],
+  ['>1.2.3-pre.0', '>1.2.3-pre.0 || 2', true],
+  ['1 >1.2.3-pre.0', '>1.2.3-pre.0', true],
+  ['1 <=1.2.3-pre.0', '>=1.0.0-0', false],
+  ['1 <=1.2.3-pre.0', '>=1.0.0-0', true, { includePrerelease: true }],
+  ['1 <=1.2.3-pre.0', '<=1.2.3-pre.0', true],
+  ['1 <=1.2.3-pre.0', '<=1.2.3-pre.0', true, { includePrerelease: true }],
+  ['<1.2.3-pre.0', '<=1.2.3-pre.0', true],
+  ['<1.2.3-pre.0', '<1.2.3-pre.0 || 2', true],
+  ['1 <1.2.3-pre.0', '<1.2.3-pre.0', true],
+
+  ['*', '*', true],
+  ['', '*', true],
+  ['*', '', true],
+  ['', '', true],
+
+  // >=0.0.0 is like * in non-prerelease mode
+  // >=0.0.0-0 is like * in prerelease mode
+  ['*', '>=0.0.0-0', true, { includePrerelease: true }],
+
+  // true because these are identical in non-PR mode
+  ['*', '>=0.0.0', true],
+
+  // false because * includes 0.0.0-0 in PR mode
+  ['*', '>=0.0.0', false, { includePrerelease: true }],
+
+  // true because * doesn't include 0.0.0-0 in non-PR mode
+  ['*', '>=0.0.0-0', true],
+
+  ['^2 || ^3 || ^4', '>=1', true],
+  ['^2 || ^3 || ^4', '>1', true],
+  ['^2 || ^3 || ^4', '>=2', true],
+  ['^2 || ^3 || ^4', '>=3', false],
+  ['>=1', '^2 || ^3 || ^4', false],
+  ['>1', '^2 || ^3 || ^4', false],
+  ['>=2', '^2 || ^3 || ^4', false],
+  ['>=3', '^2 || ^3 || ^4', false],
+  ['^1', '^2 || ^3 || ^4', false],
+  ['^2', '^2 || ^3 || ^4', true],
+  ['^3', '^2 || ^3 || ^4', true],
+  ['^4', '^2 || ^3 || ^4', true],
+  ['1.x', '^2 || ^3 || ^4', false],
+  ['2.x', '^2 || ^3 || ^4', true],
+  ['3.x', '^2 || ^3 || ^4', true],
+  ['4.x', '^2 || ^3 || ^4', true],
+
+  ['>=1.0.0 <=1.0.0 || 2.0.0', '1.0.0 || 2.0.0', true],
+  ['<=1.0.0 >=1.0.0 || 2.0.0', '1.0.0 || 2.0.0', true],
+  ['>=1.0.0', '1.0.0', false],
+  ['>=1.0.0 <2.0.0', '<2.0.0', true],
+  ['>=1.0.0 <2.0.0', '>0.0.0', true],
+  ['>=1.0.0 <=1.0.0', '1.0.0', true],
+  ['>=1.0.0 <=1.0.0', '2.0.0', false],
+  ['<2.0.0', '>=1.0.0 <2.0.0', false],
+  ['>=1.0.0', '>=1.0.0 <2.0.0', false],
+  ['>=1.0.0 <2.0.0', '<2.0.0', true],
+  ['>=1.0.0 <2.0.0', '>=1.0.0', true],
+  ['>=1.0.0 <2.0.0', '>1.0.0', false],
+  ['>=1.0.0 <=2.0.0', '<2.0.0', false],
+  ['>=1.0.0', '<1.0.0', false],
+  ['<=1.0.0', '>1.0.0', false],
+  ['<=1.0.0 >1.0.0', '>1.0.0', true],
+  ['1.0.0 >1.0.0', '>1.0.0', true],
+  ['1.0.0 <1.0.0', '>1.0.0', true],
+  ['<1 <2 <3', '<4', true],
+  ['<3 <2 <1', '<4', true],
+  ['>1 >2 >3', '>0', true],
+  ['>3 >2 >1', '>0', true],
+  ['<=1 <=2 <=3', '<4', true],
+  ['<=3 <=2 <=1', '<4', true],
+  ['>=1 >=2 >=3', '>0', true],
+  ['>=3 >=2 >=1', '>0', true],
+  ['>=3 >=2 >=1', '>=3 >=2 >=1', true],
+  ['>2.0.0', '>=2.0.0', true],
+]
+
+t.plan(cases.length + 1)
+cases.forEach(([sub, dom, expect, options]) => {
+  const msg = `${sub || "''"} ⊂ ${dom || "''"} = ${expect}` +
+    (options ? ' ' + Object.keys(options).join(',') : '')
+  t.equal(subset(sub, dom, options), expect, msg)
+})
+
+t.test('range should be subset of itself in obj or string mode', t => {
+  const range = '^1'
+  t.equal(subset(range, range), true)
+  t.equal(subset(range, new Range(range)), true)
+  t.equal(subset(new Range(range), range), true)
+  t.equal(subset(new Range(range), new Range(range)), true)
+
+  // test with using the same actual object
+  const r = new Range(range)
+  t.equal(subset(r, r), true)
+
+  // different range object with same set array
+  const r2 = new Range(range)
+  r2.set = r.set
+  t.equal(subset(r2, r), true)
+  t.equal(subset(r, r2), true)
+
+  // different range with set with same simple set arrays
+  const r3 = new Range(range)
+  r3.set = [...r.set]
+  t.equal(subset(r3, r), true)
+  t.equal(subset(r, r3), true)
+
+  // different range with set with simple sets with same comp objects
+  const r4 = new Range(range)
+  r4.set = r.set.map(s => [...s])
+  t.equal(subset(r4, r), true)
+  t.equal(subset(r, r4), true)
+  t.end()
+})
diff --git a/test/ranges/to-comparators.js b/test/ranges/to-comparators.js
new file mode 100644
index 00000000..8bde7060
--- /dev/null
+++ b/test/ranges/to-comparators.js
@@ -0,0 +1,87 @@
+const { test } = require('tap')
+const toComparators = require('../../ranges/to-comparators')
+
+test('comparators test', (t) => {
+  // [range, comparators]
+  // turn range into a set of individual comparators
+  [['1.0.0 - 2.0.0', [['>=1.0.0', '<=2.0.0']]],
+    ['1.0.0', [['1.0.0']]],
+    ['>=*', [['']]],
+    ['', [['']]],
+    ['*', [['']]],
+    ['*', [['']]],
+    ['>=1.0.0', [['>=1.0.0']]],
+    ['>=1.0.0', [['>=1.0.0']]],
+    ['>=1.0.0', [['>=1.0.0']]],
+    ['>1.0.0', [['>1.0.0']]],
+    ['>1.0.0', [['>1.0.0']]],
+    ['<=2.0.0', [['<=2.0.0']]],
+    ['1', [['>=1.0.0', '<2.0.0-0']]],
+    ['<=2.0.0', [['<=2.0.0']]],
+    ['<=2.0.0', [['<=2.0.0']]],
+    ['<2.0.0', [['<2.0.0']]],
+    ['<2.0.0', [['<2.0.0']]],
+    ['>= 1.0.0', [['>=1.0.0']]],
+    ['>=  1.0.0', [['>=1.0.0']]],
+    ['>=   1.0.0', [['>=1.0.0']]],
+    ['> 1.0.0', [['>1.0.0']]],
+    ['>  1.0.0', [['>1.0.0']]],
+    ['<=   2.0.0', [['<=2.0.0']]],
+    ['<= 2.0.0', [['<=2.0.0']]],
+    ['<=  2.0.0', [['<=2.0.0']]],
+    ['<    2.0.0', [['<2.0.0']]],
+    ['<\t2.0.0', [['<2.0.0']]],
+    ['>=0.1.97', [['>=0.1.97']]],
+    ['>=0.1.97', [['>=0.1.97']]],
+    ['0.1.20 || 1.2.4', [['0.1.20'], ['1.2.4']]],
+    ['>=0.2.3 || <0.0.1', [['>=0.2.3'], ['<0.0.1']]],
+    ['>=0.2.3 || <0.0.1', [['>=0.2.3'], ['<0.0.1']]],
+    ['>=0.2.3 || <0.0.1', [['>=0.2.3'], ['<0.0.1']]],
+    ['||', [['']]],
+    ['2.x.x', [['>=2.0.0', '<3.0.0-0']]],
+    ['1.2.x', [['>=1.2.0', '<1.3.0-0']]],
+    ['1.2.x || 2.x', [['>=1.2.0', '<1.3.0-0'], ['>=2.0.0', '<3.0.0-0']]],
+    ['1.2.x || 2.x', [['>=1.2.0', '<1.3.0-0'], ['>=2.0.0', '<3.0.0-0']]],
+    ['x', [['']]],
+    ['2.*.*', [['>=2.0.0', '<3.0.0-0']]],
+    ['1.2.*', [['>=1.2.0', '<1.3.0-0']]],
+    ['1.2.* || 2.*', [['>=1.2.0', '<1.3.0-0'], ['>=2.0.0', '<3.0.0-0']]],
+    ['1.2.* || 2.*', [['>=1.2.0', '<1.3.0-0'], ['>=2.0.0', '<3.0.0-0']]],
+    ['*', [['']]],
+    ['2', [['>=2.0.0', '<3.0.0-0']]],
+    ['2.3', [['>=2.3.0', '<2.4.0-0']]],
+    ['~2.4', [['>=2.4.0', '<2.5.0-0']]],
+    ['~2.4', [['>=2.4.0', '<2.5.0-0']]],
+    ['~>3.2.1', [['>=3.2.1', '<3.3.0-0']]],
+    ['~1', [['>=1.0.0', '<2.0.0-0']]],
+    ['~>1', [['>=1.0.0', '<2.0.0-0']]],
+    ['~> 1', [['>=1.0.0', '<2.0.0-0']]],
+    ['~1.0', [['>=1.0.0', '<1.1.0-0']]],
+    ['~ 1.0', [['>=1.0.0', '<1.1.0-0']]],
+    ['~ 1.0.3', [['>=1.0.3', '<1.1.0-0']]],
+    ['~> 1.0.3', [['>=1.0.3', '<1.1.0-0']]],
+    ['<1', [['<1.0.0-0']]],
+    ['< 1', [['<1.0.0-0']]],
+    ['>=1', [['>=1.0.0']]],
+    ['>= 1', [['>=1.0.0']]],
+    ['<1.2', [['<1.2.0-0']]],
+    ['< 1.2', [['<1.2.0-0']]],
+    ['1', [['>=1.0.0', '<2.0.0-0']]],
+    ['1 2', [['>=1.0.0', '<2.0.0-0', '>=2.0.0', '<3.0.0-0']]],
+    ['1.2 - 3.4.5', [['>=1.2.0', '<=3.4.5']]],
+    ['1.2.3 - 3.4', [['>=1.2.3', '<3.5.0-0']]],
+    ['1.2.3 - 3', [['>=1.2.3', '<4.0.0-0']]],
+    ['>*', [['<0.0.0-0']]],
+    ['<*', [['<0.0.0-0']]],
+    ['>X', [['<0.0.0-0']]],
+    ['<X', [['<0.0.0-0']]],
+    ['<x <* || >* 2.x', [['<0.0.0-0']]],
+    ['>x 2.x || * || <x', [['']]],
+  ].forEach(([pre, wanted]) => {
+    const found = toComparators(pre)
+    const jw = JSON.stringify(wanted)
+    t.same(found, wanted, `toComparators(${pre}) === ${jw}`)
+  })
+
+  t.end()
+})
diff --git a/test/ranges/valid.js b/test/ranges/valid.js
new file mode 100644
index 00000000..f1fe3960
--- /dev/null
+++ b/test/ranges/valid.js
@@ -0,0 +1,12 @@
+const { test } = require('tap')
+const validRange = require('../../ranges/valid')
+const rangeParse = require('../fixtures/range-parse.js')
+
+test('valid range test', (t) => {
+  // validRange(range) -> result
+  // translate ranges into their canonical form
+  t.plan(rangeParse.length)
+  rangeParse.forEach(([pre, wanted, options]) =>
+    t.equal(validRange(pre, options), wanted,
+      `validRange(${pre}) === ${wanted} ${JSON.stringify(options)}`))
+})