Initalize

node_modules/es-semver/index.d.ts

@@ -0,0 +1,304 @@
+// Type definitions for semver 5.5
+// 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>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/semver
+
+export const SEMVER_SPEC_VERSION: "2.0.0";
+
+export type ReleaseType =
+  | "major"
+  | "premajor"
+  | "minor"
+  | "preminor"
+  | "patch"
+  | "prepatch"
+  | "prerelease";
+
+/**
+ * Return the parsed version as a SemVer object, or null if it's not valid.
+ */
+export function parse(v: string | SemVer, loose?: boolean): SemVer | null;
+/**
+ * Return the parsed version, or null if it's not valid.
+ */
+export function valid(v: string | SemVer, loose?: boolean): string | null;
+/**
+ * Returns cleaned (removed leading/trailing whitespace, remove '=v' prefix) and parsed version, or null if version is invalid.
+ */
+export function clean(version: string, loose?: boolean): string | null;
+/**
+ * Return the version incremented by the release type (major, minor, patch, or prerelease), or null if it's not valid.
+ */
+export function inc(
+  v: string | SemVer,
+  release: ReleaseType,
+  loose?: boolean,
+  identifier?: string
+): string | null;
+/**
+ * Return the major version number.
+ */
+export function major(v: string | SemVer, loose?: boolean): number;
+/**
+ * Return the minor version number.
+ */
+export function minor(v: string | SemVer, loose?: boolean): number;
+/**
+ * Return the patch version number.
+ */
+export function patch(v: string | SemVer, loose?: boolean): number;
+/**
+ * Returns an array of prerelease components, or null if none exist.
+ */
+export function prerelease(
+  v: string | SemVer,
+  loose?: boolean
+): string[] | null;
+
+// Comparison
+/**
+ * v1 > v2
+ */
+export function gt(
+  v1: string | SemVer,
+  v2: string | SemVer,
+  loose?: boolean
+): boolean;
+/**
+ * v1 >= v2
+ */
+export function gte(
+  v1: string | SemVer,
+  v2: string | SemVer,
+  loose?: boolean
+): boolean;
+/**
+ * v1 < v2
+ */
+export function lt(
+  v1: string | SemVer,
+  v2: string | SemVer,
+  loose?: boolean
+): boolean;
+/**
+ * v1 <= v2
+ */
+export function lte(
+  v1: string | SemVer,
+  v2: string | SemVer,
+  loose?: boolean
+): boolean;
+/**
+ * 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.
+ */
+export function eq(
+  v1: string | SemVer,
+  v2: string | SemVer,
+  loose?: boolean
+): boolean;
+/**
+ * v1 != v2 The opposite of eq.
+ */
+export function neq(
+  v1: string | SemVer,
+  v2: string | SemVer,
+  loose?: boolean
+): boolean;
+
+/**
+ * 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.
+ */
+export function cmp(
+  v1: string | SemVer,
+  operator: Operator,
+  v2: string | SemVer,
+  loose?: boolean
+): boolean;
+export type Operator =
+  | "==="
+  | "!=="
+  | ""
+  | "="
+  | "=="
+  | "!="
+  | ">"
+  | ">="
+  | "<"
+  | "<=";
+
+/**
+ * Return 0 if v1 == v2, or 1 if v1 is greater, or -1 if v2 is greater. Sorts in ascending order if passed to Array.sort().
+ */
+export function compare(
+  v1: string | SemVer,
+  v2: string | SemVer,
+  loose?: boolean
+): 1 | 0 | -1;
+/**
+ * The reverse of compare. Sorts an array of versions in descending order when passed to Array.sort().
+ */
+export function rcompare(
+  v1: string | SemVer,
+  v2: string | SemVer,
+  loose?: boolean
+): 1 | 0 | -1;
+
+/**
+ * Compares two identifiers, must be numeric strings or truthy/falsy values. Sorts in ascending order if passed to Array.sort().
+ */
+export function compareIdentifiers(
+  a: string | null,
+  b: string | null
+): 1 | 0 | -1;
+/**
+ * The reverse of compareIdentifiers. Sorts in descending order when passed to Array.sort().
+ */
+export function rcompareIdentifiers(
+  a: string | null,
+  b: string | null
+): 1 | 0 | -1;
+
+/**
+ * Sorts an array of semver entries in ascending order.
+ */
+export function sort(
+  list: Array<string | SemVer>,
+  loose?: boolean
+): Array<string | SemVer>;
+/**
+ * Sorts an array of semver entries in descending order.
+ */
+export function rsort(
+  list: Array<string | SemVer>,
+  loose?: boolean
+): Array<string | 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.
+ */
+export function diff(
+  v1: string,
+  v2: string,
+  loose?: boolean
+): ReleaseType | null;
+
+// Ranges
+/**
+ * Return the valid range or null if it's not valid
+ */
+export function validRange(range: string | Range, loose?: boolean): string;
+/**
+ * Return true if the version satisfies the range.
+ */
+export function satisfies(
+  version: string | SemVer,
+  range: string | Range,
+  loose?: boolean
+): boolean;
+/**
+ * Return the highest version in the list that satisfies the range, or null if none of them do.
+ */
+export function maxSatisfying(
+  versions: Array<string | SemVer>,
+  range: string | Range,
+  loose?: boolean
+): string;
+/**
+ * Return the lowest version in the list that satisfies the range, or null if none of them do.
+ */
+export function minSatisfying(
+  versions: Array<string | SemVer>,
+  range: string,
+  loose?: boolean
+): string;
+/**
+ * Return true if version is greater than all the versions possible in the range.
+ */
+export function gtr(
+  version: string | SemVer,
+  range: string | Range,
+  loose?: boolean
+): boolean;
+/**
+ * Return true if version is less than all the versions possible in the range.
+ */
+export function ltr(
+  version: string | SemVer,
+  range: string | Range,
+  loose?: boolean
+): boolean;
+/**
+ * Return true if the version is outside the bounds of the range in either the high or low direction.
+ * The hilo argument must be either the string '>' or '<'. (This is the function called by gtr and ltr.)
+ */
+export function outside(
+  version: string | SemVer,
+  range: string | Range,
+  hilo: ">" | "<",
+  loose?: boolean
+): boolean;
+/**
+ * Return true if any of the ranges comparators intersect
+ */
+export function intersects(
+  range1: string | Range,
+  range2: string | Range,
+  loose?: boolean
+): boolean;
+
+// Coercion
+/**
+ * Coerces a string to semver if possible
+ */
+export function coerce(version: string | SemVer): SemVer | null;
+
+export class SemVer {
+  constructor(version: string | SemVer, loose?: boolean);
+
+  raw: string;
+  loose: boolean;
+  format(): string;
+  inspect(): string;
+
+  major: number;
+  minor: number;
+  patch: number;
+  version: string;
+  build: string[];
+  prerelease: string[];
+
+  compare(other: string | SemVer): 1 | 0 | -1;
+  compareMain(other: string | SemVer): 1 | 0 | -1;
+  comparePre(other: string | SemVer): 1 | 0 | -1;
+  inc(release: ReleaseType, identifier?: string): SemVer;
+}
+
+export class Comparator {
+  constructor(comp: string | Comparator, loose?: boolean);
+
+  semver: SemVer;
+  operator: string;
+  value: boolean;
+  parse(comp: string): void;
+  test(version: string | SemVer): boolean;
+  intersects(comp: Comparator, loose?: boolean): boolean;
+}
+
+export class Range {
+  constructor(range: string | Range, loose?: boolean);
+
+  range: string;
+  raw: string;
+  loose: boolean;
+  format(): string;
+  inspect(): string;
+
+  set: Comparator[][];
+  parseRange(range: string): Comparator[];
+  test(version: string | SemVer): boolean;
+  intersects(range: Range, loose?: boolean): boolean;
+}