@bleedingdev/modern-js-utils 3.2.0-ultramodern.0

package/dist/compiled/ora/index.js.LICENSE.txt

@@ -0,0 +1 @@
+/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */

package/dist/compiled/ora/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+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.

package/dist/compiled/ora/package.json

@@ -0,0 +1 @@
+{"name":"ora","author":{"name":"Sindre Sorhus","email":"sindresorhus@gmail.com","url":"https://sindresorhus.com"},"version":"5.4.1","funding":"https://github.com/sponsors/sindresorhus","license":"MIT"}

package/dist/compiled/pkg-up/index.d.ts

@@ -0,0 +1,48 @@
+declare namespace pkgUp {
+	interface Options {
+		/**
+		Directory to start from.
+
+		@default process.cwd()
+		*/
+		readonly cwd?: string;
+	}
+}
+
+declare const pkgUp: {
+	/**
+	Find the closest `package.json` file.
+
+	@returns The filepath, or `null` if it couldn't be found.
+
+	@example
+	```
+	// /
+	// └── Users
+	//     └── sindresorhus
+	//         └── foo
+	//             ├── package.json
+	//             └── bar
+	//                 ├── baz
+	//                 └── example.js
+
+	// example.js
+	import pkgUp = require('./pkg-up');
+
+	(async () => {
+		console.log(await pkgUp());
+		//=> '/Users/sindresorhus/foo/package.json'
+	})();
+	```
+	*/
+	(options?: pkgUp.Options): Promise<string | null>;
+
+	/**
+	Synchronously find the closest `package.json` file.
+
+	@returns The filepath, or `null` if it couldn't be found.
+	*/
+	sync(options?: pkgUp.Options): string | null;
+};
+
+export = pkgUp;

package/dist/compiled/pkg-up/index.js

@@ -0,0 +1,15 @@
+const path = require('path');
+const fs = require('fs');
+const findPackage = (cwd)=>{
+    let current = path.resolve(cwd || process.cwd());
+    const { root } = path.parse(current);
+    while(true){
+        const packagePath = path.join(current, 'package.json');
+        if (fs.existsSync(packagePath)) return packagePath;
+        if (current === root) return null;
+        current = path.dirname(current);
+    }
+};
+const pkgUp = async (options)=>findPackage(options && options.cwd);
+pkgUp.sync = (options)=>findPackage(options && options.cwd);
+module.exports = pkgUp;

package/dist/compiled/pkg-up/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+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.

package/dist/compiled/pkg-up/package.json

@@ -0,0 +1 @@
+{"name":"@modern-js/compiled-pkg-up","version":"0.0.0","private":true}

package/dist/compiled/semver/classes/comparator.d.ts

@@ -0,0 +1,17 @@
+import semver = require('../index');
+import SemVer = require('./semver');
+
+declare class Comparator {
+    constructor(comp: string | Comparator, optionsOrLoose?: boolean | semver.Options);
+
+    semver: SemVer;
+    operator: '' | '=' | '<' | '>' | '<=' | '>=';
+    value: string;
+    loose: boolean;
+    options: semver.Options;
+    parse(comp: string): void;
+    test(version: string | SemVer): boolean;
+    intersects(comp: Comparator, optionsOrLoose?: boolean | semver.Options): boolean;
+}
+
+export = Comparator;

package/dist/compiled/semver/classes/range.d.ts

@@ -0,0 +1,21 @@
+import semver = require('../index');
+import Comparator = require('./comparator');
+import SemVer = require('./semver');
+
+declare class Range {
+    constructor(range: string | Range, optionsOrLoose?: boolean | semver.Options);
+
+    range: string;
+    raw: string;
+    loose: boolean;
+    options: semver.Options;
+    includePrerelease: boolean;
+    format(): string;
+    inspect(): string;
+
+    set: ReadonlyArray<ReadonlyArray<Comparator>>;
+    parseRange(range: string): ReadonlyArray<Comparator>;
+    test(version: string | SemVer): boolean;
+    intersects(range: Range, optionsOrLoose?: boolean | semver.Options): boolean;
+}
+export = Range;

package/dist/compiled/semver/classes/semver.d.ts

@@ -0,0 +1,62 @@
+import semver = require('../index');
+
+declare class SemVer {
+    constructor(version: string | SemVer, optionsOrLoose?: boolean | semver.Options);
+
+    raw: string;
+    loose: boolean;
+    options: semver.Options;
+    format(): string;
+    inspect(): string;
+
+    major: number;
+    minor: number;
+    patch: number;
+    version: string;
+    build: ReadonlyArray<string>;
+    prerelease: ReadonlyArray<string | number>;
+
+    /**
+     * Compares two versions excluding build identifiers (the bit after `+` in the semantic version string).
+     *
+     * @return
+     * - `0` if `this` == `other`
+     * - `1` if `this` is greater
+     * - `-1` if `other` is greater.
+     */
+    compare(other: string | SemVer): 1 | 0 | -1;
+
+    /**
+     * Compares the release portion of two versions.
+     *
+     * @return
+     * - `0` if `this` == `other`
+     * - `1` if `this` is greater
+     * - `-1` if `other` is greater.
+     */
+    compareMain(other: string | SemVer): 1 | 0 | -1;
+
+    /**
+     * Compares the prerelease portion of two versions.
+     *
+     * @return
+     * - `0` if `this` == `other`
+     * - `1` if `this` is greater
+     * - `-1` if `other` is greater.
+     */
+    comparePre(other: string | SemVer): 1 | 0 | -1;
+
+    /**
+     * Compares the build identifier of two versions.
+     *
+     * @return
+     * - `0` if `this` == `other`
+     * - `1` if `this` is greater
+     * - `-1` if `other` is greater.
+     */
+    compareBuild(other: string | SemVer): 1 | 0 | -1;
+
+    inc(release: semver.ReleaseType, identifier?: string): SemVer;
+}
+
+export = SemVer;

package/dist/compiled/semver/functions/clean.d.ts

@@ -0,0 +1,8 @@
+import semver = require('../index');
+
+/**
+ * Returns cleaned (removed leading/trailing whitespace, remove '=v' prefix) and parsed version, or null if version is invalid.
+ */
+declare function clean(version: string, optionsOrLoose?: boolean | semver.Options): string | null;
+
+export = clean;

package/dist/compiled/semver/functions/cmp.d.ts

@@ -0,0 +1,16 @@
+import semver = require('../index');
+import SemVer = require('../classes/semver');
+
+/**
+ * Pass in a comparison string, and it'll call the corresponding semver comparison function.
+ * "===" and "!==" do simple string comparison, but are included for completeness.
+ * Throws if an invalid comparison string is provided.
+ */
+declare function cmp(
+    v1: string | SemVer,
+    operator: semver.Operator,
+    v2: string | SemVer,
+    optionsOrLoose?: boolean | semver.Options,
+): boolean;
+
+export = cmp;

package/dist/compiled/semver/functions/coerce.d.ts

@@ -0,0 +1,12 @@
+import semver = require('../index');
+import SemVer = require('../classes/semver');
+
+/**
+ * Coerces a string to SemVer if possible
+ */
+declare function coerce(
+    version: string | number | SemVer | null | undefined,
+    options?: semver.CoerceOptions,
+): SemVer | null;
+
+export = coerce;

package/dist/compiled/semver/functions/compare-build.d.ts

@@ -0,0 +1,16 @@
+import SemVer = require('../classes/semver');
+
+/**
+ * Compares two versions including build identifiers (the bit after `+` in the semantic version string).
+ *
+ * Sorts in ascending order when passed to `Array.sort()`.
+ *
+ * @return
+ * - `0` if `v1` == `v2`
+ * - `1` if `v1` is greater
+ * - `-1` if `v2` is greater.
+ *
+ * @since 6.1.0
+ */
+declare function compareBuild(a: string | SemVer, b: string | SemVer): 1 | 0 | -1;
+export = compareBuild;

package/dist/compiled/semver/functions/compare-loose.d.ts

@@ -0,0 +1,5 @@
+import SemVer = require('../classes/semver');
+
+declare function compareLoose(v1: string | SemVer, v2: string | SemVer): 1 | 0 | -1;
+
+export = compareLoose;

package/dist/compiled/semver/functions/compare.d.ts

@@ -0,0 +1,20 @@
+import semver = require('../index');
+import SemVer = require('../classes/semver');
+
+/**
+ * Compares two versions excluding build identifiers (the bit after `+` in the semantic version string).
+ *
+ * Sorts in ascending order when passed to `Array.sort()`.
+ *
+ * @return
+ * - `0` if `v1` == `v2`
+ * - `1` if `v1` is greater
+ * - `-1` if `v2` is greater.
+ */
+declare function compare(
+    v1: string | SemVer,
+    v2: string | SemVer,
+    optionsOrLoose?: boolean | semver.Options,
+): 1 | 0 | -1;
+
+export = compare;

package/dist/compiled/semver/functions/diff.d.ts

@@ -0,0 +1,13 @@
+import semver = require('../index');
+import SemVer = require('../classes/semver');
+
+/**
+ * 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.
+ */
+declare function diff(
+    v1: string | SemVer,
+    v2: string | SemVer,
+    optionsOrLoose?: boolean | semver.Options,
+): semver.ReleaseType | null;
+
+export = diff;

package/dist/compiled/semver/functions/eq.d.ts

@@ -0,0 +1,9 @@
+import SemVer = require('../classes/semver');
+import semver = require('../index');
+
+/**
+ * v1 == v2 This is true if they're logically equivalent, even if they're not the exact same string. You already know how to compare strings.
+ */
+declare function eq(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | semver.Options): boolean;
+
+export = eq;

package/dist/compiled/semver/functions/gt.d.ts

@@ -0,0 +1,9 @@
+import SemVer = require('../classes/semver');
+import semver = require('../index');
+
+/**
+ * v1 > v2
+ */
+declare function gt(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | semver.Options): boolean;
+
+export = gt;

package/dist/compiled/semver/functions/gte.d.ts

@@ -0,0 +1,9 @@
+import SemVer = require('../classes/semver');
+import semver = require('../index');
+
+/**
+ * v1 >= v2
+ */
+declare function gte(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | semver.Options): boolean;
+
+export = gte;

package/dist/compiled/semver/functions/inc.d.ts

@@ -0,0 +1,15 @@
+import SemVer = require('../classes/semver');
+import semver = require('../index');
+
+/**
+ * Return the version incremented by the release type (major, minor, patch, or prerelease), or null if it's not valid.
+ */
+declare function inc(
+    version: string | SemVer,
+    release: semver.ReleaseType,
+    optionsOrLoose?: boolean | semver.Options,
+    identifier?: string,
+): string | null;
+declare function inc(version: string | SemVer, release: semver.ReleaseType, identifier?: string): string | null;
+
+export = inc;

package/dist/compiled/semver/functions/lt.d.ts

@@ -0,0 +1,9 @@
+import SemVer = require('../classes/semver');
+import semver = require('../index');
+
+/**
+ * v1 < v2
+ */
+declare function lt(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | semver.Options): boolean;
+
+export = lt;

package/dist/compiled/semver/functions/lte.d.ts

@@ -0,0 +1,8 @@
+import SemVer = require('../classes/semver');
+import semver = require('../index');
+
+/**
+ * v1 <= v2
+ */
+declare function lte(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | semver.Options): boolean;
+export = lte;

package/dist/compiled/semver/functions/major.d.ts

@@ -0,0 +1,9 @@
+import SemVer = require('../classes/semver');
+import semver = require('../index');
+
+/**
+ * Return the major version number.
+ */
+declare function major(version: string | SemVer, optionsOrLoose?: boolean | semver.Options): number;
+
+export = major;

package/dist/compiled/semver/functions/minor.d.ts

@@ -0,0 +1,9 @@
+import SemVer = require('../classes/semver');
+import semver = require('../index');
+
+/**
+ * Return the minor version number.
+ */
+declare function minor(version: string | SemVer, optionsOrLoose?: boolean | semver.Options): number;
+
+export = minor;

package/dist/compiled/semver/functions/neq.d.ts

@@ -0,0 +1,9 @@
+import SemVer = require('../classes/semver');
+import semver = require('../index');
+
+/**
+ * v1 != v2 The opposite of eq.
+ */
+declare function neq(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | semver.Options): boolean;
+
+export = neq;

package/dist/compiled/semver/functions/parse.d.ts

@@ -0,0 +1,12 @@
+import SemVer = require('../classes/semver');
+import semver = require('../index');
+
+/**
+ * Return the parsed version as a SemVer object, or null if it's not valid.
+ */
+declare function parse(
+    version: string | SemVer | null | undefined,
+    optionsOrLoose?: boolean | semver.Options,
+): SemVer | null;
+
+export = parse;

package/dist/compiled/semver/functions/patch.d.ts

@@ -0,0 +1,9 @@
+import SemVer = require('../classes/semver');
+import semver = require('../index');
+
+/**
+ * Return the patch version number.
+ */
+declare function patch(version: string | SemVer, optionsOrLoose?: boolean | semver.Options): number;
+
+export = patch;

package/dist/compiled/semver/functions/prerelease.d.ts

@@ -0,0 +1,12 @@
+import SemVer = require('../classes/semver');
+import semver = require('../index');
+
+/**
+ * Returns an array of prerelease components, or null if none exist.
+ */
+declare function prerelease(
+    version: string | SemVer,
+    optionsOrLoose?: boolean | semver.Options,
+): ReadonlyArray<string | number> | null;
+
+export = prerelease;

package/dist/compiled/semver/functions/rcompare.d.ts

@@ -0,0 +1,15 @@
+import SemVer = require('../classes/semver');
+import semver = require('../index');
+
+/**
+ * The reverse of compare.
+ *
+ * Sorts in descending order when passed to `Array.sort()`.
+ */
+declare function rcompare(
+    v1: string | SemVer,
+    v2: string | SemVer,
+    optionsOrLoose?: boolean | semver.Options,
+): 1 | 0 | -1;
+
+export = rcompare;

package/dist/compiled/semver/functions/rsort.d.ts

@@ -0,0 +1,9 @@
+import SemVer = require('../classes/semver');
+import semver = require('../index');
+
+/**
+ * Sorts an array of semver entries in descending order using `compareBuild()`.
+ */
+declare function rsort<T extends string | SemVer>(list: T[], optionsOrLoose?: boolean | semver.Options): T[];
+
+export = rsort;

package/dist/compiled/semver/functions/satisfies.d.ts

@@ -0,0 +1,14 @@
+import Range = require('../classes/range');
+import SemVer = require('../classes/semver');
+import semver = require('../index');
+
+/**
+ * Return true if the version satisfies the range.
+ */
+declare function satisfies(
+    version: string | SemVer,
+    range: string | Range,
+    optionsOrLoose?: boolean | semver.Options,
+): boolean;
+
+export = satisfies;

package/dist/compiled/semver/functions/sort.d.ts

@@ -0,0 +1,9 @@
+import SemVer = require('../classes/semver');
+import semver = require('../index');
+
+/**
+ * Sorts an array of semver entries in ascending order using `compareBuild()`.
+ */
+declare function sort<T extends string | SemVer>(list: T[], optionsOrLoose?: boolean | semver.Options): T[];
+
+export = sort;

package/dist/compiled/semver/functions/valid.d.ts

@@ -0,0 +1,11 @@
+import semver = require('../index');
+import SemVer = require('../classes/semver');
+/**
+ * Return the parsed version as a string, or null if it's not valid.
+ */
+declare function valid(
+    version: string | SemVer | null | undefined,
+    optionsOrLoose?: boolean | semver.Options,
+): string | null;
+
+export = valid;

package/dist/compiled/semver/index.d.ts

@@ -0,0 +1,133 @@
+// Type definitions for semver 7.3
+// Project: https://github.com/npm/node-semver
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+//                 BendingBender <https://github.com/BendingBender>
+//                 Lucian Buzzo <https://github.com/LucianBuzzo>
+//                 Klaus Meinhardt <https://github.com/ajafff>
+//                 ExE Boss <https://github.com/ExE-Boss>
+//                 Piotr Błażejewicz <https://github.com/peterblazejewicz>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+// re-exports for index file
+
+// functions for working with versions
+import semverParse = require('./functions/parse');
+import semverValid = require('./functions/valid');
+import semverClean = require('./functions/clean');
+import semverInc = require('./functions/inc');
+import semverDiff = require('./functions/diff');
+import semverMajor = require('./functions/major');
+import semverMinor = require('./functions/minor');
+import semverPatch = require('./functions/patch');
+import semverPrerelease = require('./functions/prerelease');
+import semverCompare = require('./functions/compare');
+import semverRcompare = require('./functions/rcompare');
+import semverCompareLoose = require('./functions/compare-loose');
+import semverCompareBuild = require('./functions/compare-build');
+import semverSort = require('./functions/sort');
+import semverRsort = require('./functions/rsort');
+
+export {
+    semverParse as parse,
+    semverValid as valid,
+    semverClean as clean,
+    semverInc as inc,
+    semverDiff as diff,
+    semverMajor as major,
+    semverMinor as minor,
+    semverPatch as patch,
+    semverPrerelease as prerelease,
+    semverCompare as compare,
+    semverRcompare as rcompare,
+    semverCompareLoose as compareLoose,
+    semverCompareBuild as compareBuild,
+    semverSort as sort,
+    semverRsort as rsort,
+};
+
+// low-level comparators between versions
+import semverGt = require('./functions/gt');
+import semverLt = require('./functions/lt');
+import semverEq = require('./functions/eq');
+import semverNeq = require('./functions/neq');
+import semverGte = require('./functions/gte');
+import semverLte = require('./functions/lte');
+import semverCmp = require('./functions/cmp');
+import semverCoerce = require('./functions/coerce');
+
+export {
+    semverGt as gt,
+    semverLt as lt,
+    semverEq as eq,
+    semverNeq as neq,
+    semverGte as gte,
+    semverLte as lte,
+    semverCmp as cmp,
+    semverCoerce as coerce,
+};
+
+// working with ranges
+import semverSatisfies = require('./functions/satisfies');
+import semverMaxSatisfying = require('./ranges/max-satisfying');
+import semverMinSatisfying = require('./ranges/min-satisfying');
+import semverToComparators = require('./ranges/to-comparators');
+import semverMinVersion = require('./ranges/min-version');
+import semverValidRange = require('./ranges/valid');
+import semverOutside = require('./ranges/outside');
+import semverGtr = require('./ranges/gtr');
+import semverLtr = require('./ranges/ltr');
+import semverIntersects = require('./ranges/intersects');
+import simplify = require('./ranges/simplify');
+import rangeSubset = require('./ranges/subset');
+
+export {
+    semverSatisfies as satisfies,
+    semverMaxSatisfying as maxSatisfying,
+    semverMinSatisfying as minSatisfying,
+    semverToComparators as toComparators,
+    semverMinVersion as minVersion,
+    semverValidRange as validRange,
+    semverOutside as outside,
+    semverGtr as gtr,
+    semverLtr as ltr,
+    semverIntersects as intersects,
+    simplify as simplifyRange,
+    rangeSubset as subset,
+};
+
+// classes
+import SemVer = require('./classes/semver');
+import Range = require('./classes/range');
+import Comparator = require('./classes/comparator');
+
+export { SemVer, Range, Comparator };
+
+// internals
+import identifiers = require('./internals/identifiers');
+export import compareIdentifiers = identifiers.compareIdentifiers;
+export import rcompareIdentifiers = identifiers.rcompareIdentifiers;
+
+export const SEMVER_SPEC_VERSION: '2.0.0';
+
+export type ReleaseType = 'major' | 'premajor' | 'minor' | 'preminor' | 'patch' | 'prepatch' | 'prerelease';
+
+export interface Options {
+    loose?: boolean | undefined;
+    includePrerelease?: boolean | undefined;
+}
+export interface CoerceOptions extends Options {
+    /**
+     * Used by `coerce()` to coerce from right to left.
+     *
+     * @default false
+     *
+     * @example
+     * coerce('1.2.3.4', { rtl: true });
+     * // => SemVer { version: '2.3.4', ... }
+     *
+     * @since 6.2.0
+     */
+    rtl?: boolean | undefined;
+}
+
+export type Operator = '===' | '!==' | '' | '=' | '==' | '!=' | '>' | '>=' | '<' | '<=';