keep-a-changelog 2.6.0 → 2.6.2

package/esm/std/semver/parse.js

@@ -1,44 +0,0 @@
-import { parseBuild, parseNumber, parsePrerelease } from "./_shared.js";
-import { FULL_REGEXP, MAX_LENGTH } from "./_shared.js";
-/**
- * Attempt to parse a string as a semantic version, returning a SemVer object.
- *
- * @example Usage
- * ```ts
- * import { parse } from "parse.ts";
- * import { assertEquals } from "../assert/mod.ts";
- *
- * const version = parse("1.2.3");
- * assertEquals(version, {
- *   major: 1,
- *   minor: 2,
- *   patch: 3,
- *   prerelease: [],
- *   build: [],
- * });
- * ```
- *
- * @throws {TypeError} If the input string is invalid.
- * @param value The version string to parse
- * @returns A valid SemVer
- */
-export function parse(value) {
-    if (typeof value !== "string") {
-        throw new TypeError(`Cannot parse version as version must be a string: received ${typeof value}`);
-    }
-    if (value.length > MAX_LENGTH) {
-        throw new TypeError(`Cannot parse version as version length is too long: length is ${value.length}, max length is ${MAX_LENGTH}`);
-    }
-    value = value.trim();
-    const groups = value.match(FULL_REGEXP)?.groups;
-    if (!groups)
-        throw new TypeError(`Cannot parse version: ${value}`);
-    const major = parseNumber(groups.major, `Cannot parse version ${value}: invalid major version`);
-    const minor = parseNumber(groups.minor, `Cannot parse version ${value}: invalid minor version`);
-    const patch = parseNumber(groups.patch, `Cannot parse version ${value}: invalid patch version`);
-    const prerelease = groups.prerelease
-        ? parsePrerelease(groups.prerelease)
-        : [];
-    const build = groups.buildmetadata ? parseBuild(groups.buildmetadata) : [];
-    return { major, minor, patch, prerelease, build };
-}

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

@@ -1,26 +0,0 @@
-import type { Range } from "./types.js";
-/**
- * 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 declare function parseRange(value: string): Range;

package/esm/std/semver/parse_range.js

@@ -1,358 +0,0 @@
-// 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

@@ -1,24 +0,0 @@
-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

@@ -1,89 +0,0 @@
-// 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

@@ -1,23 +0,0 @@
-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

@@ -1,26 +0,0 @@
-// 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

@@ -1,20 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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;