xo 0.52.4 → 0.53.1

package/cli.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+/* eslint-disable unicorn/prefer-top-level-await */
 import process from 'node:process';
 import getStdin from 'get-stdin';
 import meow from 'meow';

package/index.js

@@ -53,7 +53,7 @@ const lintText = async (string, options) => {
 		filePath
 		&& (
 			micromatch.isMatch(path.relative(cwd, filePath), ignorePatterns)
-			|| isGitIgnoredSync({cwd, ignore: ignorePatterns})(filePath)
+			|| isGitIgnoredSync({cwd})(filePath)
 		)
 	) {
 		return getIgnoredReport(filePath);
@@ -87,16 +87,11 @@ const lintFiles = async (patterns, options) => {
 				for (const options of filesWithOptions) {
 					const {filePath, eslintOptions} = options;
 					const {cwd, baseConfig: {ignorePatterns}} = eslintOptions;
-					if (filePath
-						&& (
-							micromatch.isMatch(path.relative(cwd, filePath), ignorePatterns)
-							|| isGitIgnoredSync({cwd, ignore: ignorePatterns})(filePath)
-						)) {
-						continue;
-					}
-
-					// eslint-disable-next-line no-await-in-loop
-					if ((await eslint.isPathIgnored(filePath))) {
+					if (
+						micromatch.isMatch(path.relative(cwd, filePath), ignorePatterns)
+						// eslint-disable-next-line no-await-in-loop
+						|| await eslint.isPathIgnored(filePath)
+					) {
 						continue;
 					}
 

package/node_modules/@types/semver/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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/node_modules/@types/semver/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/semver`
+
+# Summary
+This package contains type definitions for semver (https://github.com/npm/node-semver).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/semver.
+
+### Additional Details
+ * Last updated: Wed, 26 Oct 2022 20:03:05 GMT
+ * Dependencies: none
+ * Global values: none
+
+# Credits
+These definitions were written 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), and [Piotr Błażejewicz](https://github.com/peterblazejewicz).

package/node_modules/@types/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/node_modules/@types/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.RangeOptions);
+
+    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/node_modules/@types/semver/classes/semver.d.ts

@@ -0,0 +1,62 @@
+import semver = require('../index');
+
+declare class SemVer {
+    constructor(version: string | SemVer, optionsOrLoose?: boolean | semver.RangeOptions);
+
+    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/node_modules/@types/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/node_modules/@types/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/node_modules/@types/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/node_modules/@types/semver/functions/compare-build.d.ts

@@ -0,0 +1,21 @@
+import semver = require('../index');
+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,
+    optionsOrLoose?: boolean | semver.Options,
+): 1 | 0 | -1;
+export = compareBuild;

package/node_modules/@types/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/node_modules/@types/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/node_modules/@types/semver/functions/diff.d.ts

@@ -0,0 +1,9 @@
+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): semver.ReleaseType | null;
+
+export = diff;

package/node_modules/@types/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/node_modules/@types/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/node_modules/@types/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/node_modules/@types/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/node_modules/@types/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/node_modules/@types/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/node_modules/@types/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/node_modules/@types/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/node_modules/@types/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/node_modules/@types/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/node_modules/@types/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/node_modules/@types/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/node_modules/@types/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/node_modules/@types/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/node_modules/@types/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.RangeOptions,
+): boolean;
+
+export = satisfies;

package/node_modules/@types/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/node_modules/@types/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/node_modules/@types/semver/index.d.ts

@@ -0,0 +1,136 @@
+// 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;
+}
+
+export interface RangeOptions extends Options {
+    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 = '===' | '!==' | '' | '=' | '==' | '!=' | '>' | '>=' | '<' | '<=';

package/node_modules/@types/semver/internals/identifiers.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Compares two identifiers, must be numeric strings or truthy/falsy values.
+ *
+ * Sorts in ascending order when passed to `Array.sort()`.
+ */
+export function compareIdentifiers(a: string | null | undefined, b: string | null | undefined): 1 | 0 | -1;
+
+/**
+ * The reverse of compareIdentifiers.
+ *
+ * Sorts in descending order when passed to `Array.sort()`.
+ */
+export function rcompareIdentifiers(a: string | null | undefined, b: string | null | undefined): 1 | 0 | -1;