keep-a-changelog 2.5.3 → 2.6.0

package/esm/std/semver/parse_range.js

@@ -0,0 +1,358 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { COMPARATOR_REGEXP, OPERATOR_XRANGE_REGEXP, parseBuild, parseNumber, parsePrerelease, XRANGE, } from "./_shared.js";
+import { ALL, ANY } from "./_constants.js";
+function parseComparator(comparator) {
+    const match = comparator.match(COMPARATOR_REGEXP);
+    const groups = match?.groups;
+    if (!groups)
+        return null;
+    const { operator, prerelease, buildmetadata } = groups;
+    const semver = groups.major
+        ? {
+            major: parseNumber(groups.major, `Cannot parse comparator ${comparator}: invalid major version`),
+            minor: parseNumber(groups.minor, `Cannot parse comparator ${comparator}: invalid minor version`),
+            patch: parseNumber(groups.patch, `Cannot parse comparator ${comparator}: invalid patch version`),
+            prerelease: prerelease ? parsePrerelease(prerelease) : [],
+            build: buildmetadata ? parseBuild(buildmetadata) : [],
+        }
+        : ANY;
+    return { operator: operator || undefined, ...semver };
+}
+function isWildcard(id) {
+    return !id || id.toLowerCase() === "x" || id === "*";
+}
+function handleLeftHyphenRangeGroups(leftGroup) {
+    if (isWildcard(leftGroup.major))
+        return;
+    if (isWildcard(leftGroup.minor)) {
+        return {
+            operator: ">=",
+            major: +leftGroup.major,
+            minor: 0,
+            patch: 0,
+            prerelease: [],
+            build: [],
+        };
+    }
+    if (isWildcard(leftGroup.patch)) {
+        return {
+            operator: ">=",
+            major: +leftGroup.major,
+            minor: +leftGroup.minor,
+            patch: 0,
+            prerelease: [],
+            build: [],
+        };
+    }
+    return {
+        operator: ">=",
+        major: +leftGroup.major,
+        minor: +leftGroup.minor,
+        patch: +leftGroup.patch,
+        prerelease: leftGroup.prerelease
+            ? parsePrerelease(leftGroup.prerelease)
+            : [],
+        build: [],
+    };
+}
+function handleRightHyphenRangeGroups(rightGroups) {
+    if (isWildcard(rightGroups.major)) {
+        return;
+    }
+    if (isWildcard(rightGroups.minor)) {
+        return {
+            operator: "<",
+            major: +rightGroups.major + 1,
+            minor: 0,
+            patch: 0,
+            prerelease: [],
+            build: [],
+        };
+    }
+    if (isWildcard(rightGroups.patch)) {
+        return {
+            operator: "<",
+            major: +rightGroups.major,
+            minor: +rightGroups.minor + 1,
+            patch: 0,
+            prerelease: [],
+            build: [],
+        };
+    }
+    if (rightGroups.prerelease) {
+        return {
+            operator: "<=",
+            major: +rightGroups.major,
+            minor: +rightGroups.minor,
+            patch: +rightGroups.patch,
+            prerelease: parsePrerelease(rightGroups.prerelease),
+            build: [],
+        };
+    }
+    return {
+        operator: "<=",
+        major: +rightGroups.major,
+        minor: +rightGroups.minor,
+        patch: +rightGroups.patch,
+        prerelease: [],
+        build: [],
+    };
+}
+function parseHyphenRange(range) {
+    const leftMatch = range.match(new RegExp(`^${XRANGE}`));
+    const leftGroup = leftMatch?.groups;
+    if (!leftGroup)
+        return null;
+    const leftLength = leftMatch[0].length;
+    const hyphenMatch = range.slice(leftLength).match(/^\s+-\s+/);
+    if (!hyphenMatch)
+        return null;
+    const hyphenLength = hyphenMatch[0].length;
+    const rightMatch = range.slice(leftLength + hyphenLength).match(new RegExp(`^${XRANGE}\\s*$`));
+    const rightGroups = rightMatch?.groups;
+    if (!rightGroups)
+        return null;
+    const from = handleLeftHyphenRangeGroups(leftGroup);
+    const to = handleRightHyphenRangeGroups(rightGroups);
+    return [from, to].filter(Boolean);
+}
+function handleCaretOperator(groups) {
+    const majorIsWildcard = isWildcard(groups.major);
+    const minorIsWildcard = isWildcard(groups.minor);
+    const patchIsWildcard = isWildcard(groups.patch);
+    const major = +groups.major;
+    const minor = +groups.minor;
+    const patch = +groups.patch;
+    if (majorIsWildcard)
+        return [ALL];
+    if (minorIsWildcard) {
+        return [
+            { operator: ">=", major, minor: 0, patch: 0 },
+            { operator: "<", major: major + 1, minor: 0, patch: 0 },
+        ];
+    }
+    if (patchIsWildcard) {
+        if (major === 0) {
+            return [
+                { operator: ">=", major, minor, patch: 0 },
+                { operator: "<", major, minor: minor + 1, patch: 0 },
+            ];
+        }
+        return [
+            { operator: ">=", major, minor, patch: 0 },
+            { operator: "<", major: major + 1, minor: 0, patch: 0 },
+        ];
+    }
+    const prerelease = parsePrerelease(groups.prerelease ?? "");
+    if (major === 0) {
+        if (minor === 0) {
+            return [
+                { operator: ">=", major, minor, patch, prerelease },
+                { operator: "<", major, minor, patch: patch + 1 },
+            ];
+        }
+        return [
+            { operator: ">=", major, minor, patch, prerelease },
+            { operator: "<", major, minor: minor + 1, patch: 0 },
+        ];
+    }
+    return [
+        { operator: ">=", major, minor, patch, prerelease },
+        { operator: "<", major: major + 1, minor: 0, patch: 0 },
+    ];
+}
+function handleTildeOperator(groups) {
+    const majorIsWildcard = isWildcard(groups.major);
+    const minorIsWildcard = isWildcard(groups.minor);
+    const patchIsWildcard = isWildcard(groups.patch);
+    const major = +groups.major;
+    const minor = +groups.minor;
+    const patch = +groups.patch;
+    if (majorIsWildcard)
+        return [ALL];
+    if (minorIsWildcard) {
+        return [
+            { operator: ">=", major, minor: 0, patch: 0 },
+            { operator: "<", major: major + 1, minor: 0, patch: 0 },
+        ];
+    }
+    if (patchIsWildcard) {
+        return [
+            { operator: ">=", major, minor, patch: 0 },
+            { operator: "<", major, minor: minor + 1, patch: 0 },
+        ];
+    }
+    const prerelease = parsePrerelease(groups.prerelease ?? "");
+    return [
+        { operator: ">=", major, minor, patch, prerelease },
+        { operator: "<", major, minor: minor + 1, patch: 0 },
+    ];
+}
+function handleLessThanOperator(groups) {
+    const majorIsWildcard = isWildcard(groups.major);
+    const minorIsWildcard = isWildcard(groups.minor);
+    const patchIsWildcard = isWildcard(groups.patch);
+    const major = +groups.major;
+    const minor = +groups.minor;
+    const patch = +groups.patch;
+    if (majorIsWildcard)
+        return [{ operator: "<", major: 0, minor: 0, patch: 0 }];
+    if (minorIsWildcard) {
+        if (patchIsWildcard)
+            return [{ operator: "<", major, minor: 0, patch: 0 }];
+        return [{ operator: "<", major, minor: 0, patch: 0 }];
+    }
+    if (patchIsWildcard)
+        return [{ operator: "<", major, minor, patch: 0 }];
+    const prerelease = parsePrerelease(groups.prerelease ?? "");
+    const build = parseBuild(groups.build ?? "");
+    return [{ operator: "<", major, minor, patch, prerelease, build }];
+}
+function handleLessThanOrEqualOperator(groups) {
+    const minorIsWildcard = isWildcard(groups.minor);
+    const patchIsWildcard = isWildcard(groups.patch);
+    const major = +groups.major;
+    const minor = +groups.minor;
+    const patch = +groups.patch;
+    if (minorIsWildcard) {
+        if (patchIsWildcard) {
+            return [{ operator: "<", major: major + 1, minor: 0, patch: 0 }];
+        }
+        return [{ operator: "<", major, minor: minor + 1, patch: 0 }];
+    }
+    if (patchIsWildcard) {
+        return [{ operator: "<", major, minor: minor + 1, patch: 0 }];
+    }
+    const prerelease = parsePrerelease(groups.prerelease ?? "");
+    const build = parseBuild(groups.build ?? "");
+    return [{ operator: "<=", major, minor, patch, prerelease, build }];
+}
+function handleGreaterThanOperator(groups) {
+    const majorIsWildcard = isWildcard(groups.major);
+    const minorIsWildcard = isWildcard(groups.minor);
+    const patchIsWildcard = isWildcard(groups.patch);
+    const major = +groups.major;
+    const minor = +groups.minor;
+    const patch = +groups.patch;
+    if (majorIsWildcard)
+        return [{ operator: "<", major: 0, minor: 0, patch: 0 }];
+    if (minorIsWildcard) {
+        return [{ operator: ">=", major: major + 1, minor: 0, patch: 0 }];
+    }
+    if (patchIsWildcard) {
+        return [{ operator: ">=", major, minor: minor + 1, patch: 0 }];
+    }
+    const prerelease = parsePrerelease(groups.prerelease ?? "");
+    const build = parseBuild(groups.build ?? "");
+    return [{ operator: ">", major, minor, patch, prerelease, build }];
+}
+function handleGreaterOrEqualOperator(groups) {
+    const majorIsWildcard = isWildcard(groups.major);
+    const minorIsWildcard = isWildcard(groups.minor);
+    const patchIsWildcard = isWildcard(groups.patch);
+    const major = +groups.major;
+    const minor = +groups.minor;
+    const patch = +groups.patch;
+    if (majorIsWildcard)
+        return [ALL];
+    if (minorIsWildcard) {
+        if (patchIsWildcard)
+            return [{ operator: ">=", major, minor: 0, patch: 0 }];
+        return [{ operator: ">=", major, minor: 0, patch: 0 }];
+    }
+    if (patchIsWildcard)
+        return [{ operator: ">=", major, minor, patch: 0 }];
+    const prerelease = parsePrerelease(groups.prerelease ?? "");
+    const build = parseBuild(groups.build ?? "");
+    return [{ operator: ">=", major, minor, patch, prerelease, build }];
+}
+function handleEqualOperator(groups) {
+    const majorIsWildcard = isWildcard(groups.major);
+    const minorIsWildcard = isWildcard(groups.minor);
+    const patchIsWildcard = isWildcard(groups.patch);
+    const major = +groups.major;
+    const minor = +groups.minor;
+    const patch = +groups.patch;
+    if (majorIsWildcard)
+        return [ALL];
+    if (minorIsWildcard) {
+        return [
+            { operator: ">=", major, minor: 0, patch: 0 },
+            { operator: "<", major: major + 1, minor: 0, patch: 0 },
+        ];
+    }
+    if (patchIsWildcard) {
+        return [
+            { operator: ">=", major, minor, patch: 0 },
+            { operator: "<", major, minor: minor + 1, patch: 0 },
+        ];
+    }
+    const prerelease = parsePrerelease(groups.prerelease ?? "");
+    const build = parseBuild(groups.build ?? "");
+    return [{ operator: undefined, major, minor, patch, prerelease, build }];
+}
+function parseOperatorRange(string) {
+    const groups = string.match(OPERATOR_XRANGE_REGEXP)
+        ?.groups;
+    if (!groups)
+        return parseComparator(string);
+    switch (groups.operator) {
+        case "^":
+            return handleCaretOperator(groups);
+        case "~":
+        case "~>":
+            return handleTildeOperator(groups);
+        case "<":
+            return handleLessThanOperator(groups);
+        case "<=":
+            return handleLessThanOrEqualOperator(groups);
+        case ">":
+            return handleGreaterThanOperator(groups);
+        case ">=":
+            return handleGreaterOrEqualOperator(groups);
+        case "=":
+        case "":
+            return handleEqualOperator(groups);
+        default:
+            throw new Error(`Cannot parse version range: '${groups.operator}' is not a valid operator`);
+    }
+}
+function parseOperatorRanges(string) {
+    return string.split(/\s+/).flatMap(parseOperatorRange);
+}
+/**
+ * Parses a range string into a {@linkcode Range} object.
+ *
+ * @example Usage
+ * ```ts
+ * import { parseRange } from "parse_range.ts";
+ * import { assertEquals } from "../assert/mod.ts";
+ *
+ * const range = parseRange(">=1.0.0 <2.0.0 || >=3.0.0");
+ * assertEquals(range, [
+ *   [
+ *     { operator: ">=", major: 1, minor: 0, patch: 0, prerelease: [], build: [] },
+ *     { operator: "<", major: 2, minor: 0, patch: 0, prerelease: [], build: [] },
+ *   ],
+ *   [
+ *     { operator: ">=", major: 3, minor: 0, patch: 0, prerelease: [], build: [] },
+ *   ]
+ * ]);
+ * ```
+ *
+ * @throws {TypeError} If the input range is invalid.
+ * @param value The range set string
+ * @returns A valid SemVer range
+ */
+export function parseRange(value) {
+    const result = value
+        // remove spaces between operators and versions
+        .replaceAll(/(?<=<|>|=|~|\^)(\s+)/g, "")
+        .split(/\s*\|\|\s*/)
+        .map((string) => parseHyphenRange(string) || parseOperatorRanges(string));
+    if (result.some((r) => r.includes(null))) {
+        throw new TypeError(`Cannot parse version range: range "${value}" is invalid`);
+    }
+    return result;
+}

package/esm/std/semver/range_intersects.d.ts

@@ -0,0 +1,24 @@
+import type { Range } from "./types.js";
+/**
+ * The ranges intersect every range of AND comparators intersects with a least
+ * one range of OR ranges.
+ *
+ * @example Usage
+ * ```ts
+ * import { parseRange, rangeIntersects } from "mod.ts";
+ * import { assert } from "../assert/mod.ts";
+ *
+ * const range1 = parseRange(">=1.0.0 <2.0.0");
+ * const range2 = parseRange(">=1.0.0 <1.2.3");
+ * const range3 = parseRange(">=1.2.3 <2.0.0");
+ *
+ * assert(rangeIntersects(range1, range2));
+ * assert(rangeIntersects(range1, range3));
+ * assert(!rangeIntersects(range2, range3));
+ * ```
+ *
+ * @param range1 range 0
+ * @param range2 range 1
+ * @returns returns true if the given ranges intersect, false otherwise
+ */
+export declare function rangeIntersects(range1: Range, range2: Range): boolean;

package/esm/std/semver/range_intersects.js

@@ -0,0 +1,89 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { isWildcardComparator } from "./_shared.js";
+import { compare } from "./compare.js";
+import { satisfies } from "./satisfies.js";
+function comparatorIntersects(comparator1, comparator2) {
+    const op0 = comparator1.operator;
+    const op1 = comparator2.operator;
+    if (op0 === undefined) {
+        // if comparator1 is empty comparator, then returns true
+        if (isWildcardComparator(comparator1))
+            return true;
+        return satisfies(comparator1, [[comparator2]]);
+    }
+    if (op1 === undefined) {
+        if (isWildcardComparator(comparator2))
+            return true;
+        return satisfies(comparator2, [[comparator1]]);
+    }
+    const cmp = compare(comparator1, comparator2);
+    const sameDirectionIncreasing = (op0 === ">=" || op0 === ">") &&
+        (op1 === ">=" || op1 === ">");
+    const sameDirectionDecreasing = (op0 === "<=" || op0 === "<") &&
+        (op1 === "<=" || op1 === "<");
+    const sameSemVer = cmp === 0;
+    const differentDirectionsInclusive = (op0 === ">=" || op0 === "<=") &&
+        (op1 === ">=" || op1 === "<=");
+    const oppositeDirectionsLessThan = cmp === -1 &&
+        (op0 === ">=" || op0 === ">") &&
+        (op1 === "<=" || op1 === "<");
+    const oppositeDirectionsGreaterThan = cmp === 1 &&
+        (op0 === "<=" || op0 === "<") &&
+        (op1 === ">=" || op1 === ">");
+    return sameDirectionIncreasing ||
+        sameDirectionDecreasing ||
+        (sameSemVer && differentDirectionsInclusive) ||
+        oppositeDirectionsLessThan ||
+        oppositeDirectionsGreaterThan;
+}
+function rangesSatisfiable(ranges) {
+    return ranges.every((r) => {
+        // For each OR at least one AND must be satisfiable
+        return r.some((comparators) => comparatorsSatisfiable(comparators));
+    });
+}
+function comparatorsSatisfiable(comparators) {
+    // Comparators are satisfiable if they all intersect with each other
+    for (let i = 0; i < comparators.length - 1; i++) {
+        const comparator1 = comparators[i];
+        for (const comparator2 of comparators.slice(i + 1)) {
+            if (!comparatorIntersects(comparator1, comparator2)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+/**
+ * The ranges intersect every range of AND comparators intersects with a least
+ * one range of OR ranges.
+ *
+ * @example Usage
+ * ```ts
+ * import { parseRange, rangeIntersects } from "mod.ts";
+ * import { assert } from "../assert/mod.ts";
+ *
+ * const range1 = parseRange(">=1.0.0 <2.0.0");
+ * const range2 = parseRange(">=1.0.0 <1.2.3");
+ * const range3 = parseRange(">=1.2.3 <2.0.0");
+ *
+ * assert(rangeIntersects(range1, range2));
+ * assert(rangeIntersects(range1, range3));
+ * assert(!rangeIntersects(range2, range3));
+ * ```
+ *
+ * @param range1 range 0
+ * @param range2 range 1
+ * @returns returns true if the given ranges intersect, false otherwise
+ */
+export function rangeIntersects(range1, range2) {
+    return rangesSatisfiable([range1, range2]) &&
+        range1.some((range10) => {
+            return range2.some((r11) => {
+                return range10.every((comparator1) => {
+                    return r11.every((comparator2) => comparatorIntersects(comparator1, comparator2));
+                });
+            });
+        });
+}

package/esm/std/semver/satisfies.d.ts

@@ -0,0 +1,23 @@
+import type { Range, SemVer } from "./types.js";
+/**
+ * Test to see if the SemVer satisfies the range.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, parseRange, satisfies } from "mod.ts";
+ * import { assert } from "../assert/mod.ts";
+ *
+ * const version = parse("1.2.3");
+ * const range0 = parseRange(">=1.0.0 <2.0.0");
+ * const range1 = parseRange(">=1.0.0 <1.3.0");
+ * const range2 = parseRange(">=1.0.0 <1.2.3");
+ *
+ * assert(satisfies(version, range0));
+ * assert(satisfies(version, range1));
+ * assert(!satisfies(version, range2));
+ * ```
+ * @param version The version to test
+ * @param range The range to check
+ * @returns true if the version is in the range
+ */
+export declare function satisfies(version: SemVer, range: Range): boolean;

package/esm/std/semver/satisfies.js

@@ -0,0 +1,26 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+import { testComparatorSet } from "./_test_comparator_set.js";
+/**
+ * Test to see if the SemVer satisfies the range.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, parseRange, satisfies } from "mod.ts";
+ * import { assert } from "../assert/mod.ts";
+ *
+ * const version = parse("1.2.3");
+ * const range0 = parseRange(">=1.0.0 <2.0.0");
+ * const range1 = parseRange(">=1.0.0 <1.3.0");
+ * const range2 = parseRange(">=1.0.0 <1.2.3");
+ *
+ * assert(satisfies(version, range0));
+ * assert(satisfies(version, range1));
+ * assert(!satisfies(version, range2));
+ * ```
+ * @param version The version to test
+ * @param range The range to check
+ * @returns true if the version is in the range
+ */
+export function satisfies(version, range) {
+    return range.some((set) => testComparatorSet(version, set));
+}

package/esm/std/semver/try_parse.d.ts

@@ -0,0 +1,20 @@
+import type { SemVer } from "./types.js";
+/**
+ * Returns the parsed SemVer, or `undefined` if it's not valid.
+ *
+ * @example Usage
+ * ```ts
+ * import { tryParse } from "try_parse.ts";
+ * import { assertEquals } from "../assert/mod.ts";
+ *
+ * assertEquals(tryParse("1.2.3"), { major: 1, minor: 2, patch: 3, prerelease: [], build: [] });
+ * assertEquals(tryParse("1.2.3-alpha"), { major: 1, minor: 2, patch: 3, prerelease: ["alpha"], build: [] });
+ * assertEquals(tryParse("1.2.3+build"), { major: 1, minor: 2, patch: 3, prerelease: [], build: ["build"] });
+ * assertEquals(tryParse("1.2.3-alpha.1+build.1"), { major: 1, minor: 2, patch: 3, prerelease: ["alpha", 1], build: ["build", "1"] });
+ * assertEquals(tryParse(" invalid "), undefined);
+ * ```
+ *
+ * @param value The version string to parse
+ * @returns A valid SemVer or `undefined`
+ */
+export declare function tryParse(value: string): SemVer | undefined;

package/esm/std/semver/try_parse.js

@@ -0,0 +1,27 @@
+import { parse } from "./parse.js";
+/**
+ * Returns the parsed SemVer, or `undefined` if it's not valid.
+ *
+ * @example Usage
+ * ```ts
+ * import { tryParse } from "try_parse.ts";
+ * import { assertEquals } from "../assert/mod.ts";
+ *
+ * assertEquals(tryParse("1.2.3"), { major: 1, minor: 2, patch: 3, prerelease: [], build: [] });
+ * assertEquals(tryParse("1.2.3-alpha"), { major: 1, minor: 2, patch: 3, prerelease: ["alpha"], build: [] });
+ * assertEquals(tryParse("1.2.3+build"), { major: 1, minor: 2, patch: 3, prerelease: [], build: ["build"] });
+ * assertEquals(tryParse("1.2.3-alpha.1+build.1"), { major: 1, minor: 2, patch: 3, prerelease: ["alpha", 1], build: ["build", "1"] });
+ * assertEquals(tryParse(" invalid "), undefined);
+ * ```
+ *
+ * @param value The version string to parse
+ * @returns A valid SemVer or `undefined`
+ */
+export function tryParse(value) {
+    try {
+        return parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}

package/esm/std/semver/try_parse_range.d.ts

@@ -0,0 +1,22 @@
+import type { Range } from "./types.js";
+/**
+ * Parses the given range string and returns a Range object. If the range string
+ * is invalid, `undefined` is returned.
+ *
+ * @example Usage
+ * ```ts
+ * import { tryParseRange } from "mod.ts";
+ * import { assertEquals } from "../assert/mod.ts";
+ *
+ * assertEquals(tryParseRange(">=1.2.3 <1.2.4"), [
+ *  [
+ *    { operator: ">=", major: 1, minor: 2, patch: 3, prerelease: [], build: [] },
+ *    { operator: "<", major: 1, minor: 2, patch: 4, prerelease: [], build: [] },
+ *  ],
+ * ]);
+ * ```
+ *
+ * @param value The range string
+ * @returns A Range object if valid otherwise `undefined`
+ */
+export declare function tryParseRange(value: string): Range | undefined;

package/esm/std/semver/try_parse_range.js

@@ -0,0 +1,33 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { parseRange } from "./parse_range.js";
+/**
+ * Parses the given range string and returns a Range object. If the range string
+ * is invalid, `undefined` is returned.
+ *
+ * @example Usage
+ * ```ts
+ * import { tryParseRange } from "mod.ts";
+ * import { assertEquals } from "../assert/mod.ts";
+ *
+ * assertEquals(tryParseRange(">=1.2.3 <1.2.4"), [
+ *  [
+ *    { operator: ">=", major: 1, minor: 2, patch: 3, prerelease: [], build: [] },
+ *    { operator: "<", major: 1, minor: 2, patch: 4, prerelease: [], build: [] },
+ *  ],
+ * ]);
+ * ```
+ *
+ * @param value The range string
+ * @returns A Range object if valid otherwise `undefined`
+ */
+export function tryParseRange(value) {
+    try {
+        // Return '*' instead of '' so that truthiness works.
+        // This will throw if it's invalid anyway
+        return parseRange(value);
+    }
+    catch {
+        return undefined;
+    }
+}

package/esm/std/semver/types.d.ts

@@ -0,0 +1,57 @@
+/**
+ * The possible release types are used as an operator for the
+ * increment function and as a result of the difference function.
+ */
+export type ReleaseType = "pre" | "major" | "premajor" | "minor" | "preminor" | "patch" | "prepatch" | "prerelease";
+/**
+ * SemVer comparison operators.
+ */
+export type Operator = undefined | "=" | "!=" | ">" | ">=" | "<" | "<=";
+/**
+ * The shape of a valid SemVer comparator.
+ *
+ * @example Usage
+ * ```ts
+ * import type { Comparator } from "types.ts";
+ *
+ * const comparator: Comparator = {
+ *   operator: ">",
+ *   major: 1,
+ *   minor: 2,
+ *   patch: 3,
+ * }
+ * ```
+ */
+export interface Comparator extends SemVer {
+    /** The operator */
+    operator?: Operator;
+}
+/**
+ * A SemVer object parsed into its constituent parts.
+ */
+export interface SemVer {
+    /** The major version */
+    major: number;
+    /** The minor version */
+    minor: number;
+    /** The patch version */
+    patch: number;
+    /**
+     * The prerelease version
+     *
+     * @default {[]}
+     */
+    prerelease?: (string | number)[];
+    /**
+     * The build metadata
+     *
+     * @default {[]}
+     */
+    build?: string[];
+}
+/**
+ * A type representing a semantic version range. The ranges consist of
+ * a nested array, which represents a set of OR comparisons while the
+ * inner array represents AND comparisons.
+ */
+export type Range = Comparator[][];

package/esm/std/semver/types.js

@@ -0,0 +1,3 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+export {};