minigame

node_modules/compare-versions/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2021 Ole Michelsen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/compare-versions/README.md

@@ -0,0 +1,113 @@
+# compare-versions
+
+![Build Status](https://github.com/omichelsen/compare-versions/actions/workflows/ci.yml/badge.svg)
+[![Coverage Status](https://coveralls.io/repos/omichelsen/compare-versions/badge.svg?branch=master&service=github)](https://coveralls.io/github/omichelsen/compare-versions?branch=master)
+[![npm bundle size (minified + gzip)](https://img.shields.io/bundlephobia/minzip/compare-versions.svg)](https://bundlephobia.com/result?p=compare-versions)
+
+Compare [semver](https://semver.org/) version strings to find greater, equal or lesser. Runs in the browser as well as Node.js/React Native etc. Has no dependencies and is tiny.
+
+Supports the full semver specification including versions with different number of digits like `1.0.0`, `1.0`, `1` and pre-releases like `1.0.0-alpha`. Additionally supports the following variations:
+
+- Wildcards for minor and patch version like `1.0.x` or `1.0.*`.
+- [Chromium version numbers](https://www.chromium.org/developers/version-numbers) with 4 parts, e.g. version `25.0.1364.126`.
+- Any leading `v` is ignored, e.g. `v1.0` is interpreted as `1.0`.
+- Leading zero is ignored, e.g. `1.01.1` is interpreted as `1.1.1`.
+
+## Install
+
+```bash
+$ npm install compare-versions
+```
+
+__Note__: Starting from v5 the main export is now _named_ like so: `import { compareVersions } from 'compare-versions'`.
+
+__Note__: Starting from v4 this library includes a ESM version which will automatically be selected by your bundler (webpack, parcel etc). The CJS/UMD version is `lib/umd/index.js` and the new ESM version is `lib/esm/index.js`.
+
+## Usage
+
+Will return `1` if first version is greater, `0` if versions are equal, and `-1` if the second version is greater:
+
+```js
+import { compareVersions } from 'compare-versions';
+
+compareVersions('11.1.1', '10.0.0'); //  1
+compareVersions('10.0.0', '10.0.0'); //  0
+compareVersions('10.0.0', '11.1.1'); // -1
+```
+
+Can also be used for sorting:
+
+```js
+const versions = [
+  '1.5.19',
+  '1.2.3',
+  '1.5.5'
+]
+const sorted = versions.sort(compareVersions);
+/*
+[
+  '1.2.3',
+  '1.5.5',
+  '1.5.19'
+]
+*/
+```
+
+### "Human Readable" Compare
+
+The alternative `compare` function accepts an operator which will be more familiar to humans:
+
+```js
+import { compare } from 'compare-versions';
+
+compare('10.1.8', '10.0.4', '>');  // true
+compare('10.0.1', '10.0.1', '=');  // true
+compare('10.1.1', '10.2.2', '<');  // true
+compare('10.1.1', '10.2.2', '<='); // true
+compare('10.1.1', '10.2.2', '>='); // false
+```
+
+### Version ranges
+
+The `satisfies` function accepts a range to compare, compatible with [npm package versioning](https://docs.npmjs.com/cli/v6/using-npm/semver):
+
+```js
+import { satisfies } from 'compare-versions';
+
+satisfies('10.0.1', '~10.0.0');  // true
+satisfies('10.1.0', '~10.0.0');  // false
+satisfies('10.1.2', '^10.0.0');  // true
+satisfies('11.0.0', '^10.0.0');  // false
+satisfies('10.1.8', '>10.0.4');  // true
+satisfies('10.0.1', '=10.0.1');  // true
+satisfies('10.1.1', '<10.2.2');  // true
+satisfies('10.1.1', '<=10.2.2'); // true
+satisfies('10.1.1', '>=10.2.2'); // false
+```
+
+### Validate version numbers
+
+Applies the same rules used comparing version numbers and returns a boolean:
+
+```js
+import { validate } from 'compare-versions';
+
+validate('1.0.0-rc.1'); // true
+validate('1.0-rc.1');   // false
+validate('foo');        // false
+```
+
+### Browser
+
+If included directly in the browser, the functions above are available on the global window under the `compareVersions` object:
+
+```html
+<script src=https://unpkg.com/compare-versions/lib/umd/index.js></script>
+<script>
+  const { compareVersions, compare, satisfies, validate } = window.compareVersions
+  console.log(compareVersions('11.0.0', '10.0.0'))
+  console.log(compare('11.0.0', '10.0.0', '>'))
+  console.log(satisfies('1.2.0', '^1.0.0'))
+  console.log(validate('11.0.0'))
+</script>
+```

node_modules/compare-versions/lib/esm/index.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Compare [semver](https://semver.org/) version strings to find greater, equal or lesser.
+ * This library supports the full semver specification, including comparing versions with different number of digits like `1.0.0`, `1.0`, `1`, and pre-release versions like `1.0.0-alpha`.
+ * @param v1 - First version to compare
+ * @param v2 - Second version to compare
+ * @returns Numeric value compatible with the [Array.sort(fn) interface](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#Parameters).
+ */
+export declare const compareVersions: (v1: string, v2: string) => 0 | 1 | -1;
+/**
+ * Validate [semver](https://semver.org/) version strings.
+ *
+ * @param version Version number to validate
+ * @returns `true` if the version number is a valid semver version number, `false` otherwise.
+ *
+ * @example
+ * ```
+ * validate('1.0.0-rc.1'); // return true
+ * validate('1.0-rc.1'); // return false
+ * validate('foo'); // return false
+ * ```
+ */
+export declare const validate: (version: string) => boolean;
+/**
+ * Allowed arithmetic operators
+ */
+export type CompareOperator = '>' | '>=' | '=' | '<' | '<=';
+/**
+ * Compare [semver](https://semver.org/) version strings using the specified operator.
+ *
+ * @param v1 First version to compare
+ * @param v2 Second version to compare
+ * @param operator Allowed arithmetic operator to use
+ * @returns `true` if the comparison between the firstVersion and the secondVersion satisfies the operator, `false` otherwise.
+ *
+ * @example
+ * ```
+ * compare('10.1.8', '10.0.4', '>'); // return true
+ * compare('10.0.1', '10.0.1', '='); // return true
+ * compare('10.1.1', '10.2.2', '<'); // return true
+ * compare('10.1.1', '10.2.2', '<='); // return true
+ * compare('10.1.1', '10.2.2', '>='); // return false
+ * ```
+ */
+export declare const compare: (v1: string, v2: string, operator: CompareOperator) => boolean;
+/**
+ * Match [npm semver](https://docs.npmjs.com/cli/v6/using-npm/semver) version range.
+ *
+ * @param version Version number to match
+ * @param range Range pattern for version
+ * @returns `true` if the version number is within the range, `false` otherwise.
+ *
+ * @example
+ * ```
+ * satisfies('1.1.0', '^1.0.0'); // return true
+ * satisfies('1.1.0', '~1.0.0'); // return false
+ * ```
+ */
+export declare const satisfies: (version: string, range: string) => boolean;

node_modules/compare-versions/lib/esm/index.js

@@ -0,0 +1,165 @@
+/**
+ * Compare [semver](https://semver.org/) version strings to find greater, equal or lesser.
+ * This library supports the full semver specification, including comparing versions with different number of digits like `1.0.0`, `1.0`, `1`, and pre-release versions like `1.0.0-alpha`.
+ * @param v1 - First version to compare
+ * @param v2 - Second version to compare
+ * @returns Numeric value compatible with the [Array.sort(fn) interface](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#Parameters).
+ */
+export const compareVersions = (v1, v2) => {
+    // validate input and split into segments
+    const n1 = validateAndParse(v1);
+    const n2 = validateAndParse(v2);
+    // pop off the patch
+    const p1 = n1.pop();
+    const p2 = n2.pop();
+    // validate numbers
+    const r = compareSegments(n1, n2);
+    if (r !== 0)
+        return r;
+    // validate pre-release
+    if (p1 && p2) {
+        return compareSegments(p1.split('.'), p2.split('.'));
+    }
+    else if (p1 || p2) {
+        return p1 ? -1 : 1;
+    }
+    return 0;
+};
+/**
+ * Validate [semver](https://semver.org/) version strings.
+ *
+ * @param version Version number to validate
+ * @returns `true` if the version number is a valid semver version number, `false` otherwise.
+ *
+ * @example
+ * ```
+ * validate('1.0.0-rc.1'); // return true
+ * validate('1.0-rc.1'); // return false
+ * validate('foo'); // return false
+ * ```
+ */
+export const validate = (version) => typeof version === 'string' && /^[v\d]/.test(version) && semver.test(version);
+/**
+ * Compare [semver](https://semver.org/) version strings using the specified operator.
+ *
+ * @param v1 First version to compare
+ * @param v2 Second version to compare
+ * @param operator Allowed arithmetic operator to use
+ * @returns `true` if the comparison between the firstVersion and the secondVersion satisfies the operator, `false` otherwise.
+ *
+ * @example
+ * ```
+ * compare('10.1.8', '10.0.4', '>'); // return true
+ * compare('10.0.1', '10.0.1', '='); // return true
+ * compare('10.1.1', '10.2.2', '<'); // return true
+ * compare('10.1.1', '10.2.2', '<='); // return true
+ * compare('10.1.1', '10.2.2', '>='); // return false
+ * ```
+ */
+export const compare = (v1, v2, operator) => {
+    // validate input operator
+    assertValidOperator(operator);
+    // since result of compareVersions can only be -1 or 0 or 1
+    // a simple map can be used to replace switch
+    const res = compareVersions(v1, v2);
+    return operatorResMap[operator].includes(res);
+};
+/**
+ * Match [npm semver](https://docs.npmjs.com/cli/v6/using-npm/semver) version range.
+ *
+ * @param version Version number to match
+ * @param range Range pattern for version
+ * @returns `true` if the version number is within the range, `false` otherwise.
+ *
+ * @example
+ * ```
+ * satisfies('1.1.0', '^1.0.0'); // return true
+ * satisfies('1.1.0', '~1.0.0'); // return false
+ * ```
+ */
+export const satisfies = (version, range) => {
+    // if no range operator then "="
+    const m = range.match(/^([<>=~^]+)/);
+    const op = m ? m[1] : '=';
+    // if gt/lt/eq then operator compare
+    if (op !== '^' && op !== '~')
+        return compare(version, range, op);
+    // else range of either "~" or "^" is assumed
+    const [v1, v2, v3, , vp] = validateAndParse(version);
+    const [r1, r2, r3, , rp] = validateAndParse(range);
+    const v = [v1, v2, v3];
+    const r = [r1, r2 !== null && r2 !== void 0 ? r2 : 'x', r3 !== null && r3 !== void 0 ? r3 : 'x'];
+    // validate pre-release
+    if (rp) {
+        if (!vp)
+            return false;
+        if (compareSegments(v, r) !== 0)
+            return false;
+        if (compareSegments(vp.split('.'), rp.split('.')) === -1)
+            return false;
+    }
+    // first non-zero number
+    const nonZero = r.findIndex((v) => v !== '0') + 1;
+    // pointer to where segments can be >=
+    const i = op === '~' ? 2 : nonZero > 1 ? nonZero : 1;
+    // before pointer must be equal
+    if (compareSegments(v.slice(0, i), r.slice(0, i)) !== 0)
+        return false;
+    // after pointer must be >=
+    if (compareSegments(v.slice(i), r.slice(i)) === -1)
+        return false;
+    return true;
+};
+const semver = /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i;
+const validateAndParse = (version) => {
+    if (typeof version !== 'string') {
+        throw new TypeError('Invalid argument expected string');
+    }
+    const match = version.match(semver);
+    if (!match) {
+        throw new Error(`Invalid argument not valid semver ('${version}' received)`);
+    }
+    match.shift();
+    return match;
+};
+const isWildcard = (s) => s === '*' || s === 'x' || s === 'X';
+const tryParse = (v) => {
+    const n = parseInt(v, 10);
+    return isNaN(n) ? v : n;
+};
+const forceType = (a, b) => typeof a !== typeof b ? [String(a), String(b)] : [a, b];
+const compareStrings = (a, b) => {
+    if (isWildcard(a) || isWildcard(b))
+        return 0;
+    const [ap, bp] = forceType(tryParse(a), tryParse(b));
+    if (ap > bp)
+        return 1;
+    if (ap < bp)
+        return -1;
+    return 0;
+};
+const compareSegments = (a, b) => {
+    for (let i = 0; i < Math.max(a.length, b.length); i++) {
+        const r = compareStrings(a[i] || '0', b[i] || '0');
+        if (r !== 0)
+            return r;
+    }
+    return 0;
+};
+const operatorResMap = {
+    '>': [1],
+    '>=': [0, 1],
+    '=': [0],
+    '<=': [-1, 0],
+    '<': [-1],
+};
+const allowedOperators = Object.keys(operatorResMap);
+const assertValidOperator = (op) => {
+    if (typeof op !== 'string') {
+        throw new TypeError(`Invalid operator type, expected string but got ${typeof op}`);
+    }
+    if (allowedOperators.indexOf(op) === -1) {
+        throw new Error(`Invalid operator, expected one of ${allowedOperators.join('|')}`);
+    }
+};
+//# sourceMappingURL=index.js.map

node_modules/compare-versions/lib/umd/index.js

@@ -0,0 +1,178 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.compareVersions = {}));
+})(this, (function (exports) { 'use strict';
+
+    /**
+     * Compare [semver](https://semver.org/) version strings to find greater, equal or lesser.
+     * This library supports the full semver specification, including comparing versions with different number of digits like `1.0.0`, `1.0`, `1`, and pre-release versions like `1.0.0-alpha`.
+     * @param v1 - First version to compare
+     * @param v2 - Second version to compare
+     * @returns Numeric value compatible with the [Array.sort(fn) interface](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#Parameters).
+     */
+    const compareVersions = (v1, v2) => {
+        // validate input and split into segments
+        const n1 = validateAndParse(v1);
+        const n2 = validateAndParse(v2);
+        // pop off the patch
+        const p1 = n1.pop();
+        const p2 = n2.pop();
+        // validate numbers
+        const r = compareSegments(n1, n2);
+        if (r !== 0)
+            return r;
+        // validate pre-release
+        if (p1 && p2) {
+            return compareSegments(p1.split('.'), p2.split('.'));
+        }
+        else if (p1 || p2) {
+            return p1 ? -1 : 1;
+        }
+        return 0;
+    };
+    /**
+     * Validate [semver](https://semver.org/) version strings.
+     *
+     * @param version Version number to validate
+     * @returns `true` if the version number is a valid semver version number, `false` otherwise.
+     *
+     * @example
+     * ```
+     * validate('1.0.0-rc.1'); // return true
+     * validate('1.0-rc.1'); // return false
+     * validate('foo'); // return false
+     * ```
+     */
+    const validate = (version) => typeof version === 'string' && /^[v\d]/.test(version) && semver.test(version);
+    /**
+     * Compare [semver](https://semver.org/) version strings using the specified operator.
+     *
+     * @param v1 First version to compare
+     * @param v2 Second version to compare
+     * @param operator Allowed arithmetic operator to use
+     * @returns `true` if the comparison between the firstVersion and the secondVersion satisfies the operator, `false` otherwise.
+     *
+     * @example
+     * ```
+     * compare('10.1.8', '10.0.4', '>'); // return true
+     * compare('10.0.1', '10.0.1', '='); // return true
+     * compare('10.1.1', '10.2.2', '<'); // return true
+     * compare('10.1.1', '10.2.2', '<='); // return true
+     * compare('10.1.1', '10.2.2', '>='); // return false
+     * ```
+     */
+    const compare = (v1, v2, operator) => {
+        // validate input operator
+        assertValidOperator(operator);
+        // since result of compareVersions can only be -1 or 0 or 1
+        // a simple map can be used to replace switch
+        const res = compareVersions(v1, v2);
+        return operatorResMap[operator].includes(res);
+    };
+    /**
+     * Match [npm semver](https://docs.npmjs.com/cli/v6/using-npm/semver) version range.
+     *
+     * @param version Version number to match
+     * @param range Range pattern for version
+     * @returns `true` if the version number is within the range, `false` otherwise.
+     *
+     * @example
+     * ```
+     * satisfies('1.1.0', '^1.0.0'); // return true
+     * satisfies('1.1.0', '~1.0.0'); // return false
+     * ```
+     */
+    const satisfies = (version, range) => {
+        // if no range operator then "="
+        const m = range.match(/^([<>=~^]+)/);
+        const op = m ? m[1] : '=';
+        // if gt/lt/eq then operator compare
+        if (op !== '^' && op !== '~')
+            return compare(version, range, op);
+        // else range of either "~" or "^" is assumed
+        const [v1, v2, v3, , vp] = validateAndParse(version);
+        const [r1, r2, r3, , rp] = validateAndParse(range);
+        const v = [v1, v2, v3];
+        const r = [r1, r2 !== null && r2 !== void 0 ? r2 : 'x', r3 !== null && r3 !== void 0 ? r3 : 'x'];
+        // validate pre-release
+        if (rp) {
+            if (!vp)
+                return false;
+            if (compareSegments(v, r) !== 0)
+                return false;
+            if (compareSegments(vp.split('.'), rp.split('.')) === -1)
+                return false;
+        }
+        // first non-zero number
+        const nonZero = r.findIndex((v) => v !== '0') + 1;
+        // pointer to where segments can be >=
+        const i = op === '~' ? 2 : nonZero > 1 ? nonZero : 1;
+        // before pointer must be equal
+        if (compareSegments(v.slice(0, i), r.slice(0, i)) !== 0)
+            return false;
+        // after pointer must be >=
+        if (compareSegments(v.slice(i), r.slice(i)) === -1)
+            return false;
+        return true;
+    };
+    const semver = /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i;
+    const validateAndParse = (version) => {
+        if (typeof version !== 'string') {
+            throw new TypeError('Invalid argument expected string');
+        }
+        const match = version.match(semver);
+        if (!match) {
+            throw new Error(`Invalid argument not valid semver ('${version}' received)`);
+        }
+        match.shift();
+        return match;
+    };
+    const isWildcard = (s) => s === '*' || s === 'x' || s === 'X';
+    const tryParse = (v) => {
+        const n = parseInt(v, 10);
+        return isNaN(n) ? v : n;
+    };
+    const forceType = (a, b) => typeof a !== typeof b ? [String(a), String(b)] : [a, b];
+    const compareStrings = (a, b) => {
+        if (isWildcard(a) || isWildcard(b))
+            return 0;
+        const [ap, bp] = forceType(tryParse(a), tryParse(b));
+        if (ap > bp)
+            return 1;
+        if (ap < bp)
+            return -1;
+        return 0;
+    };
+    const compareSegments = (a, b) => {
+        for (let i = 0; i < Math.max(a.length, b.length); i++) {
+            const r = compareStrings(a[i] || '0', b[i] || '0');
+            if (r !== 0)
+                return r;
+        }
+        return 0;
+    };
+    const operatorResMap = {
+        '>': [1],
+        '>=': [0, 1],
+        '=': [0],
+        '<=': [-1, 0],
+        '<': [-1],
+    };
+    const allowedOperators = Object.keys(operatorResMap);
+    const assertValidOperator = (op) => {
+        if (typeof op !== 'string') {
+            throw new TypeError(`Invalid operator type, expected string but got ${typeof op}`);
+        }
+        if (allowedOperators.indexOf(op) === -1) {
+            throw new Error(`Invalid operator, expected one of ${allowedOperators.join('|')}`);
+        }
+    };
+
+    exports.compare = compare;
+    exports.compareVersions = compareVersions;
+    exports.satisfies = satisfies;
+    exports.validate = validate;
+
+}));
+//# sourceMappingURL=index.js.map

node_modules/compare-versions/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "compare-versions",
+  "version": "5.0.3",
+  "description": "Compare semver version strings to find greater, equal or lesser.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/omichelsen/compare-versions.git"
+  },
+  "author": "Ole Michelsen",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/omichelsen/compare-versions/issues"
+  },
+  "homepage": "https://github.com/omichelsen/compare-versions#readme",
+  "keywords": [
+    "semver",
+    "version",
+    "compare",
+    "browser",
+    "node"
+  ],
+  "scripts": {
+    "build": "npm run build:esm && npm run build:umd",
+    "build:esm": "tsc --module esnext --target es2017 --outDir lib/esm",
+    "build:umd": "rollup lib/esm/index.js --format umd --name compareVersions --sourcemap -o lib/umd/index.js",
+    "test": "c8 --reporter=lcov mocha -r ts-node/register test/**/*.ts"
+  },
+  "main": "./lib/umd/index.js",
+  "module": "./lib/esm/index.js",
+  "types": "./lib/esm/index.d.ts",
+  "sideEffects": false,
+  "files": [
+    "lib",
+    "src"
+  ],
+  "devDependencies": {
+    "@types/mocha": "^10.0.1",
+    "c8": "^7.10.0",
+    "mocha": "^10.0.0",
+    "rollup": "^3.7.4",
+    "ts-node": "^10.7.0",
+    "typescript": "^4.6.3"
+  }
+}

node_modules/compare-versions/src/index.ts

@@ -0,0 +1,197 @@
+/**
+ * Compare [semver](https://semver.org/) version strings to find greater, equal or lesser.
+ * This library supports the full semver specification, including comparing versions with different number of digits like `1.0.0`, `1.0`, `1`, and pre-release versions like `1.0.0-alpha`.
+ * @param v1 - First version to compare
+ * @param v2 - Second version to compare
+ * @returns Numeric value compatible with the [Array.sort(fn) interface](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#Parameters).
+ */
+export const compareVersions = (v1: string, v2: string) => {
+  // validate input and split into segments
+  const n1 = validateAndParse(v1);
+  const n2 = validateAndParse(v2);
+
+  // pop off the patch
+  const p1 = n1.pop();
+  const p2 = n2.pop();
+
+  // validate numbers
+  const r = compareSegments(n1, n2);
+  if (r !== 0) return r;
+
+  // validate pre-release
+  if (p1 && p2) {
+    return compareSegments(p1.split('.'), p2.split('.'));
+  } else if (p1 || p2) {
+    return p1 ? -1 : 1;
+  }
+
+  return 0;
+};
+
+/**
+ * Validate [semver](https://semver.org/) version strings.
+ *
+ * @param version Version number to validate
+ * @returns `true` if the version number is a valid semver version number, `false` otherwise.
+ *
+ * @example
+ * ```
+ * validate('1.0.0-rc.1'); // return true
+ * validate('1.0-rc.1'); // return false
+ * validate('foo'); // return false
+ * ```
+ */
+export const validate = (version: string) =>
+  typeof version === 'string' && /^[v\d]/.test(version) && semver.test(version);
+
+/**
+ * Allowed arithmetic operators
+ */
+export type CompareOperator = '>' | '>=' | '=' | '<' | '<=';
+
+/**
+ * Compare [semver](https://semver.org/) version strings using the specified operator.
+ *
+ * @param v1 First version to compare
+ * @param v2 Second version to compare
+ * @param operator Allowed arithmetic operator to use
+ * @returns `true` if the comparison between the firstVersion and the secondVersion satisfies the operator, `false` otherwise.
+ *
+ * @example
+ * ```
+ * compare('10.1.8', '10.0.4', '>'); // return true
+ * compare('10.0.1', '10.0.1', '='); // return true
+ * compare('10.1.1', '10.2.2', '<'); // return true
+ * compare('10.1.1', '10.2.2', '<='); // return true
+ * compare('10.1.1', '10.2.2', '>='); // return false
+ * ```
+ */
+export const compare = (v1: string, v2: string, operator: CompareOperator) => {
+  // validate input operator
+  assertValidOperator(operator);
+
+  // since result of compareVersions can only be -1 or 0 or 1
+  // a simple map can be used to replace switch
+  const res = compareVersions(v1, v2);
+
+  return operatorResMap[operator].includes(res);
+};
+
+/**
+ * Match [npm semver](https://docs.npmjs.com/cli/v6/using-npm/semver) version range.
+ *
+ * @param version Version number to match
+ * @param range Range pattern for version
+ * @returns `true` if the version number is within the range, `false` otherwise.
+ *
+ * @example
+ * ```
+ * satisfies('1.1.0', '^1.0.0'); // return true
+ * satisfies('1.1.0', '~1.0.0'); // return false
+ * ```
+ */
+export const satisfies = (version: string, range: string) => {
+  // if no range operator then "="
+  const m = range.match(/^([<>=~^]+)/);
+  const op = m ? m[1] : '=';
+
+  // if gt/lt/eq then operator compare
+  if (op !== '^' && op !== '~')
+    return compare(version, range, op as CompareOperator);
+
+  // else range of either "~" or "^" is assumed
+  const [v1, v2, v3, , vp] = validateAndParse(version);
+  const [r1, r2, r3, , rp] = validateAndParse(range);
+  const v = [v1, v2, v3];
+  const r = [r1, r2 ?? 'x', r3 ?? 'x'];
+
+  // validate pre-release
+  if (rp) {
+    if (!vp) return false;
+    if (compareSegments(v, r) !== 0) return false;
+    if (compareSegments(vp.split('.'), rp.split('.')) === -1) return false;
+  }
+
+  // first non-zero number
+  const nonZero = r.findIndex((v) => v !== '0') + 1;
+
+  // pointer to where segments can be >=
+  const i = op === '~' ? 2 : nonZero > 1 ? nonZero : 1;
+
+  // before pointer must be equal
+  if (compareSegments(v.slice(0, i), r.slice(0, i)) !== 0) return false;
+
+  // after pointer must be >=
+  if (compareSegments(v.slice(i), r.slice(i)) === -1) return false;
+
+  return true;
+};
+
+const semver =
+  /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i;
+
+const validateAndParse = (version: string) => {
+  if (typeof version !== 'string') {
+    throw new TypeError('Invalid argument expected string');
+  }
+  const match = version.match(semver);
+  if (!match) {
+    throw new Error(
+      `Invalid argument not valid semver ('${version}' received)`
+    );
+  }
+  match.shift();
+  return match;
+};
+
+const isWildcard = (s: string) => s === '*' || s === 'x' || s === 'X';
+
+const tryParse = (v: string) => {
+  const n = parseInt(v, 10);
+  return isNaN(n) ? v : n;
+};
+
+const forceType = (a: string | number, b: string | number) =>
+  typeof a !== typeof b ? [String(a), String(b)] : [a, b];
+
+const compareStrings = (a: string, b: string) => {
+  if (isWildcard(a) || isWildcard(b)) return 0;
+  const [ap, bp] = forceType(tryParse(a), tryParse(b));
+  if (ap > bp) return 1;
+  if (ap < bp) return -1;
+  return 0;
+};
+
+const compareSegments = (
+  a: string | string[] | RegExpMatchArray,
+  b: string | string[] | RegExpMatchArray
+) => {
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    const r = compareStrings(a[i] || '0', b[i] || '0');
+    if (r !== 0) return r;
+  }
+  return 0;
+};
+
+const operatorResMap = {
+  '>': [1],
+  '>=': [0, 1],
+  '=': [0],
+  '<=': [-1, 0],
+  '<': [-1],
+};
+
+const allowedOperators = Object.keys(operatorResMap);
+
+const assertValidOperator = (op: string) => {
+  if (typeof op !== 'string') {
+    throw new TypeError(
+      `Invalid operator type, expected string but got ${typeof op}`
+    );
+  }
+  if (allowedOperators.indexOf(op) === -1) {
+    throw new Error(
+      `Invalid operator, expected one of ${allowedOperators.join('|')}`
+    );
+  }
+};