keep-a-changelog 2.5.3 → 2.6.0

package/script/std/path/windows/resolve.js

@@ -0,0 +1,181 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolve = void 0;
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+const dntShim = __importStar(require("../../../_dnt.shims.js"));
+const constants_js_1 = require("../_common/constants.js");
+const normalize_string_js_1 = require("../_common/normalize_string.js");
+const assert_path_js_1 = require("../_common/assert_path.js");
+const _util_js_1 = require("./_util.js");
+/**
+ * Resolves path segments into a `path`.
+ *
+ * @example Usage
+ * ```ts
+ * import { resolve } from "resolve.ts";
+ * import { assertEquals } from "../../assert/mod.ts";
+ *
+ * const resolved = resolve("C:\\foo\\bar", "..\\baz");
+ * assertEquals(resolved, "C:\\foo\\baz");
+ * ```
+ *
+ * @param pathSegments The path segments to process to path
+ * @returns The resolved path
+ */
+function resolve(...pathSegments) {
+    let resolvedDevice = "";
+    let resolvedTail = "";
+    let resolvedAbsolute = false;
+    for (let i = pathSegments.length - 1; i >= -1; i--) {
+        let path;
+        // deno-lint-ignore no-explicit-any
+        const { Deno } = dntShim.dntGlobalThis;
+        if (i >= 0) {
+            path = pathSegments[i];
+        }
+        else if (!resolvedDevice) {
+            if (typeof Deno?.cwd !== "function") {
+                throw new TypeError("Resolved a drive-letter-less path without a current working directory (CWD)");
+            }
+            path = Deno.cwd();
+        }
+        else {
+            if (typeof Deno?.env?.get !== "function" || typeof Deno?.cwd !== "function") {
+                throw new TypeError("Resolved a relative path without a current working directory (CWD)");
+            }
+            path = Deno.cwd();
+            // Verify that a cwd was found and that it actually points
+            // to our drive. If not, default to the drive's root.
+            if (path === undefined ||
+                path.slice(0, 3).toLowerCase() !== `${resolvedDevice.toLowerCase()}\\`) {
+                path = `${resolvedDevice}\\`;
+            }
+        }
+        (0, assert_path_js_1.assertPath)(path);
+        const len = path.length;
+        // Skip empty entries
+        if (len === 0)
+            continue;
+        let rootEnd = 0;
+        let device = "";
+        let isAbsolute = false;
+        const code = path.charCodeAt(0);
+        // Try to match a root
+        if (len > 1) {
+            if ((0, _util_js_1.isPathSeparator)(code)) {
+                // Possible UNC root
+                // If we started with a separator, we know we at least have an
+                // absolute path of some kind (UNC or otherwise)
+                isAbsolute = true;
+                if ((0, _util_js_1.isPathSeparator)(path.charCodeAt(1))) {
+                    // Matched double path separator at beginning
+                    let j = 2;
+                    let last = j;
+                    // Match 1 or more non-path separators
+                    for (; j < len; ++j) {
+                        if ((0, _util_js_1.isPathSeparator)(path.charCodeAt(j)))
+                            break;
+                    }
+                    if (j < len && j !== last) {
+                        const firstPart = path.slice(last, j);
+                        // Matched!
+                        last = j;
+                        // Match 1 or more path separators
+                        for (; j < len; ++j) {
+                            if (!(0, _util_js_1.isPathSeparator)(path.charCodeAt(j)))
+                                break;
+                        }
+                        if (j < len && j !== last) {
+                            // Matched!
+                            last = j;
+                            // Match 1 or more non-path separators
+                            for (; j < len; ++j) {
+                                if ((0, _util_js_1.isPathSeparator)(path.charCodeAt(j)))
+                                    break;
+                            }
+                            if (j === len) {
+                                // We matched a UNC root only
+                                device = `\\\\${firstPart}\\${path.slice(last)}`;
+                                rootEnd = j;
+                            }
+                            else if (j !== last) {
+                                // We matched a UNC root with leftovers
+                                device = `\\\\${firstPart}\\${path.slice(last, j)}`;
+                                rootEnd = j;
+                            }
+                        }
+                    }
+                }
+                else {
+                    rootEnd = 1;
+                }
+            }
+            else if ((0, _util_js_1.isWindowsDeviceRoot)(code)) {
+                // Possible device root
+                if (path.charCodeAt(1) === constants_js_1.CHAR_COLON) {
+                    device = path.slice(0, 2);
+                    rootEnd = 2;
+                    if (len > 2) {
+                        if ((0, _util_js_1.isPathSeparator)(path.charCodeAt(2))) {
+                            // Treat separator following drive name as an absolute path
+                            // indicator
+                            isAbsolute = true;
+                            rootEnd = 3;
+                        }
+                    }
+                }
+            }
+        }
+        else if ((0, _util_js_1.isPathSeparator)(code)) {
+            // `path` contains just a path separator
+            rootEnd = 1;
+            isAbsolute = true;
+        }
+        if (device.length > 0 &&
+            resolvedDevice.length > 0 &&
+            device.toLowerCase() !== resolvedDevice.toLowerCase()) {
+            // This path points to another device so it is not applicable
+            continue;
+        }
+        if (resolvedDevice.length === 0 && device.length > 0) {
+            resolvedDevice = device;
+        }
+        if (!resolvedAbsolute) {
+            resolvedTail = `${path.slice(rootEnd)}\\${resolvedTail}`;
+            resolvedAbsolute = isAbsolute;
+        }
+        if (resolvedAbsolute && resolvedDevice.length > 0)
+            break;
+    }
+    // At this point the path should be resolved to a full absolute path,
+    // but handle relative paths to be safe (might happen when Deno.cwd()
+    // fails)
+    // Normalize the tail path
+    resolvedTail = (0, normalize_string_js_1.normalizeString)(resolvedTail, !resolvedAbsolute, "\\", _util_js_1.isPathSeparator);
+    return resolvedDevice + (resolvedAbsolute ? "\\" : "") + resolvedTail || ".";
+}
+exports.resolve = resolve;

package/script/std/path/windows/to_file_url.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+/**
+ * Converts a path string to a file URL.
+ *
+ * @example Usage
+ * ```ts
+ * import { toFileUrl } from "to_file_url.ts";
+ * import { assertEquals } from "../../assert/mod.ts";
+ *
+ * assertEquals(toFileUrl("\\home\\foo"), new URL("file:///home/foo"));
+ * assertEquals(toFileUrl("C:\\Users\\foo"), new URL("file:///C:/Users/foo"));
+ * assertEquals(toFileUrl("\\\\127.0.0.1\\home\\foo"), new URL("file://127.0.0.1/home/foo"));
+ * ```
+ * @param path The path to convert.
+ * @returns The file URL.
+ */
+export declare function toFileUrl(path: string): URL;

package/script/std/path/windows/to_file_url.js

@@ -0,0 +1,38 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toFileUrl = void 0;
+const to_file_url_js_1 = require("../_common/to_file_url.js");
+const is_absolute_js_1 = require("./is_absolute.js");
+/**
+ * Converts a path string to a file URL.
+ *
+ * @example Usage
+ * ```ts
+ * import { toFileUrl } from "to_file_url.ts";
+ * import { assertEquals } from "../../assert/mod.ts";
+ *
+ * assertEquals(toFileUrl("\\home\\foo"), new URL("file:///home/foo"));
+ * assertEquals(toFileUrl("C:\\Users\\foo"), new URL("file:///C:/Users/foo"));
+ * assertEquals(toFileUrl("\\\\127.0.0.1\\home\\foo"), new URL("file://127.0.0.1/home/foo"));
+ * ```
+ * @param path The path to convert.
+ * @returns The file URL.
+ */
+function toFileUrl(path) {
+    if (!(0, is_absolute_js_1.isAbsolute)(path)) {
+        throw new TypeError(`Path must be absolute: received "${path}"`);
+    }
+    const [, hostname, pathname] = path.match(/^(?:[/\\]{2}([^/\\]+)(?=[/\\](?:[^/\\]|$)))?(.*)/);
+    const url = new URL("file:///");
+    url.pathname = (0, to_file_url_js_1.encodeWhitespace)(pathname.replace(/%/g, "%25"));
+    if (hostname !== undefined && hostname !== "localhost") {
+        url.hostname = hostname;
+        if (!url.hostname) {
+            throw new TypeError(`Invalid hostname: "${url.hostname}"`);
+        }
+    }
+    return url;
+}
+exports.toFileUrl = toFileUrl;

package/script/std/path/windows/to_namespaced_path.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Resolves path to a namespace path
+ *
+ * @example Usage
+ * ```ts
+ * import { toNamespacedPath } from "to_namespaced_path.ts";
+ * import { assertEquals } from "../../assert/mod.ts";
+ *
+ * const namespaced = toNamespacedPath("C:\\foo\\bar");
+ * assertEquals(namespaced, "\\\\?\\C:\\foo\\bar");
+ * ```
+ *
+ * @param path The path to resolve to namespaced path
+ * @returns The resolved namespaced path
+ */
+export declare function toNamespacedPath(path: string): string;

package/script/std/path/windows/to_namespaced_path.js

@@ -0,0 +1,53 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toNamespacedPath = void 0;
+const constants_js_1 = require("../_common/constants.js");
+const _util_js_1 = require("./_util.js");
+const resolve_js_1 = require("./resolve.js");
+/**
+ * Resolves path to a namespace path
+ *
+ * @example Usage
+ * ```ts
+ * import { toNamespacedPath } from "to_namespaced_path.ts";
+ * import { assertEquals } from "../../assert/mod.ts";
+ *
+ * const namespaced = toNamespacedPath("C:\\foo\\bar");
+ * assertEquals(namespaced, "\\\\?\\C:\\foo\\bar");
+ * ```
+ *
+ * @param path The path to resolve to namespaced path
+ * @returns The resolved namespaced path
+ */
+function toNamespacedPath(path) {
+    // Note: this will *probably* throw somewhere.
+    if (typeof path !== "string")
+        return path;
+    if (path.length === 0)
+        return "";
+    const resolvedPath = (0, resolve_js_1.resolve)(path);
+    if (resolvedPath.length >= 3) {
+        if (resolvedPath.charCodeAt(0) === constants_js_1.CHAR_BACKWARD_SLASH) {
+            // Possible UNC root
+            if (resolvedPath.charCodeAt(1) === constants_js_1.CHAR_BACKWARD_SLASH) {
+                const code = resolvedPath.charCodeAt(2);
+                if (code !== constants_js_1.CHAR_QUESTION_MARK && code !== constants_js_1.CHAR_DOT) {
+                    // Matched non-long UNC root, convert the path to a long UNC path
+                    return `\\\\?\\UNC\\${resolvedPath.slice(2)}`;
+                }
+            }
+        }
+        else if ((0, _util_js_1.isWindowsDeviceRoot)(resolvedPath.charCodeAt(0))) {
+            // Possible device root
+            if (resolvedPath.charCodeAt(1) === constants_js_1.CHAR_COLON &&
+                resolvedPath.charCodeAt(2) === constants_js_1.CHAR_BACKWARD_SLASH) {
+                // Matched device root, convert the path to a long UNC path
+                return `\\\\?\\${resolvedPath}`;
+            }
+        }
+    }
+    return path;
+}
+exports.toNamespacedPath = toNamespacedPath;

package/script/std/semver/_constants.d.ts

@@ -0,0 +1,15 @@
+import type { Comparator, SemVer } from "./types.js";
+/**
+ * The minimum valid SemVer object. Equivalent to `0.0.0`.
+ */
+export declare const MIN: SemVer;
+/**
+ * ANY is a sentinel value used by some range calculations. It is not a valid
+ * SemVer object and should not be used directly.
+ */
+export declare const ANY: SemVer;
+/**
+ * A comparator which will span all valid semantic versions
+ */
+export declare const ALL: Comparator;
+export declare const OPERATORS: readonly [undefined, "=", "!=", ">", ">=", "<", "<="];

package/script/std/semver/_constants.js

@@ -0,0 +1,41 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPERATORS = exports.ALL = exports.ANY = exports.MIN = void 0;
+/**
+ * The minimum valid SemVer object. Equivalent to `0.0.0`.
+ */
+exports.MIN = {
+    major: 0,
+    minor: 0,
+    patch: 0,
+    prerelease: [],
+    build: [],
+};
+/**
+ * ANY is a sentinel value used by some range calculations. It is not a valid
+ * SemVer object and should not be used directly.
+ */
+exports.ANY = {
+    major: Number.NaN,
+    minor: Number.NaN,
+    patch: Number.NaN,
+    prerelease: [],
+    build: [],
+};
+/**
+ * A comparator which will span all valid semantic versions
+ */
+exports.ALL = {
+    operator: undefined,
+    ...exports.ANY,
+};
+exports.OPERATORS = [
+    undefined,
+    "=",
+    "!=",
+    ">",
+    ">=",
+    "<",
+    "<=",
+];

package/script/std/semver/_shared.d.ts

@@ -0,0 +1,43 @@
+import type { Comparator } from "./types.js";
+export declare function compareNumber(a: number, b: number): 1 | 0 | -1;
+export declare function checkIdentifier(v1?: ReadonlyArray<string | number>, v2?: ReadonlyArray<string | number>): 1 | 0 | -1;
+export declare function compareIdentifier(v1?: ReadonlyArray<string | number>, v2?: ReadonlyArray<string | number>): 1 | 0 | -1;
+export declare const FULL_REGEXP: RegExp;
+/**
+ * A version that can contain wildcards.
+ * @example "x", "1.x", "1.x.x", "1.2.x", "*", "1.*", "1.*.*", "1.2.*"
+ */
+export declare const XRANGE = "[v=\\s]*(?<major>0|[1-9]\\d*|x|X|\\*)(?:\\.(?<minor>0|[1-9]\\d*|x|X|\\*)(?:\\.(?<patch>0|[1-9]\\d*|x|X|\\*)(?:-(?<prerelease>(?:0|[1-9]\\d*|\\d*[a-zA-Z-][a-zA-Z0-9-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][a-zA-Z0-9-]*))*))?(?:\\+(?<buildmetadata>[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?)?)?";
+/**
+ * An operator (`~`, `~>`, `^`, `=`, `<`, `<=`, `>`, or `>=`), followed by an x-range.
+ * @example "~1.x.x", "^1.2.*", ">=1.2.3"
+ */
+export declare const OPERATOR_XRANGE_REGEXP: RegExp;
+/**
+ * An empty string or a comparator (`=`, `<`, `<=`, `>`, or `>=`), followed by a version.
+ * @example ">1.2.3"
+ */
+export declare const COMPARATOR_REGEXP: RegExp;
+/**
+ * Returns true if the value is a valid SemVer number.
+ *
+ * Must be a number. Must not be NaN. Can be positive or negative infinity.
+ * Can be between 0 and MAX_SAFE_INTEGER.
+ * @param value The value to check
+ * @returns True if its a valid semver number
+ */
+export declare function isValidNumber(value: unknown): value is number;
+export declare const MAX_LENGTH = 256;
+/**
+ * Returns true if the value is a valid semver pre-release or build identifier.
+ *
+ * Must be a string. Must be between 1 and 256 characters long. Must match
+ * the regular expression /[0-9A-Za-z-]+/.
+ * @param value The value to check
+ * @returns True if the value is a valid semver string.
+ */
+export declare function isValidString(value: unknown): value is string;
+export declare function parsePrerelease(prerelease: string): (string | number)[];
+export declare function parseBuild(buildmetadata: string): string[];
+export declare function parseNumber(input: string, errorMessage: string): number;
+export declare function isWildcardComparator(c: Comparator): boolean;

package/script/std/semver/_shared.js

@@ -0,0 +1,174 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWildcardComparator = exports.parseNumber = exports.parseBuild = exports.parsePrerelease = exports.isValidString = exports.MAX_LENGTH = exports.isValidNumber = exports.COMPARATOR_REGEXP = exports.OPERATOR_XRANGE_REGEXP = exports.XRANGE = exports.FULL_REGEXP = exports.compareIdentifier = exports.checkIdentifier = exports.compareNumber = void 0;
+function compareNumber(a, b) {
+    if (isNaN(a) || isNaN(b)) {
+        throw new Error("Cannot compare against non-numbers");
+    }
+    return a === b ? 0 : a < b ? -1 : 1;
+}
+exports.compareNumber = compareNumber;
+function checkIdentifier(v1 = [], v2 = []) {
+    // NOT having a prerelease is > having one
+    // But NOT having a build is < having one
+    if (v1.length && !v2.length)
+        return -1;
+    if (!v1.length && v2.length)
+        return 1;
+    return 0;
+}
+exports.checkIdentifier = checkIdentifier;
+function compareIdentifier(v1 = [], v2 = []) {
+    const length = Math.max(v1.length, v2.length);
+    for (let i = 0; i < length; i++) {
+        const a = v1[i];
+        const b = v2[i];
+        // same length is equal
+        if (a === undefined && b === undefined)
+            return 0;
+        // longer > shorter
+        if (b === undefined)
+            return 1;
+        // shorter < longer
+        if (a === undefined)
+            return -1;
+        // string > number
+        if (typeof a === "string" && typeof b === "number")
+            return 1;
+        // number < string
+        if (typeof a === "number" && typeof b === "string")
+            return -1;
+        if (a < b)
+            return -1;
+        if (a > b)
+            return 1;
+        // If they're equal, continue comparing segments.
+    }
+    return 0;
+}
+exports.compareIdentifier = compareIdentifier;
+/**
+ * A single `0`, or a non-zero digit followed by zero or more digits.
+ */
+const NUMERIC_IDENTIFIER = "0|[1-9]\\d*";
+/**
+ * Zero or more digits, followed by a letter or hyphen, and then zero or more letters, digits, or hyphens.
+ */
+const NON_NUMERIC_IDENTIFIER = "\\d*[a-zA-Z-][a-zA-Z0-9-]*";
+/**
+ * Three dot-separated numeric identifiers.
+ */
+const VERSION_CORE = `(?<major>${NUMERIC_IDENTIFIER})\\.(?<minor>${NUMERIC_IDENTIFIER})\\.(?<patch>${NUMERIC_IDENTIFIER})`;
+/**
+ * A numeric identifier, or a non-numeric identifier.
+ */
+const PRERELEASE_IDENTIFIER = `(?:${NUMERIC_IDENTIFIER}|${NON_NUMERIC_IDENTIFIER})`;
+/**
+ * A hyphen, followed by one or more dot-separated pre-release version identifiers.
+ * @example "-pre.release"
+ */
+const PRERELEASE = `(?:-(?<prerelease>${PRERELEASE_IDENTIFIER}(?:\\.${PRERELEASE_IDENTIFIER})*))`;
+/**
+ * Any combination of digits, letters, or hyphens.
+ */
+const BUILD_IDENTIFIER = "[0-9A-Za-z-]+";
+/**
+ * A plus sign, followed by one or more period-separated build metadata identifiers.
+ * @example "+build.meta"
+ */
+const BUILD = `(?:\\+(?<buildmetadata>${BUILD_IDENTIFIER}(?:\\.${BUILD_IDENTIFIER})*))`;
+/**
+ * A version, followed optionally by a pre-release version and build metadata.
+ */
+const FULL_VERSION = `v?${VERSION_CORE}${PRERELEASE}?${BUILD}?`;
+exports.FULL_REGEXP = new RegExp(`^${FULL_VERSION}$`);
+/**
+ * A comparator.
+ * @example `=`, `<`, `<=`, `>`, `>=`
+ */
+const COMPARATOR = "(?:<|>)?=?";
+/**
+ * A wildcard identifier.
+ * @example "x", "X", "*"
+ */
+const WILDCARD_IDENTIFIER = `x|X|\\*`;
+const XRANGE_IDENTIFIER = `${NUMERIC_IDENTIFIER}|${WILDCARD_IDENTIFIER}`;
+/**
+ * A version that can contain wildcards.
+ * @example "x", "1.x", "1.x.x", "1.2.x", "*", "1.*", "1.*.*", "1.2.*"
+ */
+exports.XRANGE = `[v=\\s]*(?<major>${XRANGE_IDENTIFIER})(?:\\.(?<minor>${XRANGE_IDENTIFIER})(?:\\.(?<patch>${XRANGE_IDENTIFIER})${PRERELEASE}?${BUILD}?)?)?`;
+/**
+ * An operator (`~`, `~>`, `^`, `=`, `<`, `<=`, `>`, or `>=`), followed by an x-range.
+ * @example "~1.x.x", "^1.2.*", ">=1.2.3"
+ */
+exports.OPERATOR_XRANGE_REGEXP = new RegExp(`^(?<operator>~>?|\\^|${COMPARATOR})\\s*${exports.XRANGE}$`);
+/**
+ * An empty string or a comparator (`=`, `<`, `<=`, `>`, or `>=`), followed by a version.
+ * @example ">1.2.3"
+ */
+exports.COMPARATOR_REGEXP = new RegExp(`^(?<operator>${COMPARATOR})\\s*(${FULL_VERSION})$|^$`);
+/**
+ * Returns true if the value is a valid SemVer number.
+ *
+ * Must be a number. Must not be NaN. Can be positive or negative infinity.
+ * Can be between 0 and MAX_SAFE_INTEGER.
+ * @param value The value to check
+ * @returns True if its a valid semver number
+ */
+function isValidNumber(value) {
+    return (typeof value === "number" &&
+        !Number.isNaN(value) &&
+        (!Number.isFinite(value) ||
+            (0 <= value && value <= Number.MAX_SAFE_INTEGER)));
+}
+exports.isValidNumber = isValidNumber;
+exports.MAX_LENGTH = 256;
+/**
+ * Returns true if the value is a valid semver pre-release or build identifier.
+ *
+ * Must be a string. Must be between 1 and 256 characters long. Must match
+ * the regular expression /[0-9A-Za-z-]+/.
+ * @param value The value to check
+ * @returns True if the value is a valid semver string.
+ */
+function isValidString(value) {
+    return (typeof value === "string" &&
+        value.length > 0 &&
+        value.length <= exports.MAX_LENGTH &&
+        /[0-9A-Za-z-]+/.test(value));
+}
+exports.isValidString = isValidString;
+const NUMERIC_IDENTIFIER_REGEXP = new RegExp(`^${NUMERIC_IDENTIFIER}$`);
+function parsePrerelease(prerelease) {
+    return prerelease
+        .split(".")
+        .filter(Boolean)
+        .map((id) => {
+        if (NUMERIC_IDENTIFIER_REGEXP.test(id)) {
+            const number = Number(id);
+            if (isValidNumber(number))
+                return number;
+        }
+        return id;
+    });
+}
+exports.parsePrerelease = parsePrerelease;
+function parseBuild(buildmetadata) {
+    return buildmetadata.split(".").filter(Boolean);
+}
+exports.parseBuild = parseBuild;
+function parseNumber(input, errorMessage) {
+    const number = Number(input);
+    if (!isValidNumber(number))
+        throw new TypeError(errorMessage);
+    return number;
+}
+exports.parseNumber = parseNumber;
+function isWildcardComparator(c) {
+    return (Number.isNaN(c.major) && Number.isNaN(c.minor) && Number.isNaN(c.patch) &&
+        (c.prerelease === undefined || c.prerelease.length === 0) &&
+        (c.build === undefined || c.build.length === 0));
+}
+exports.isWildcardComparator = isWildcardComparator;

package/script/std/semver/_test_comparator_set.d.ts

@@ -0,0 +1,2 @@
+import type { Comparator, SemVer } from "./types.js";
+export declare function testComparatorSet(version: SemVer, set: Comparator[]): boolean;

package/script/std/semver/_test_comparator_set.js

@@ -0,0 +1,62 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testComparatorSet = void 0;
+const _shared_js_1 = require("./_shared.js");
+const compare_js_1 = require("./compare.js");
+function testComparator(version, comparator) {
+    if ((0, _shared_js_1.isWildcardComparator)(comparator)) {
+        return true;
+    }
+    const cmp = (0, compare_js_1.compare)(version, comparator);
+    switch (comparator.operator) {
+        case "=":
+        case undefined: {
+            return cmp === 0;
+        }
+        case "!=": {
+            return cmp !== 0;
+        }
+        case ">": {
+            return cmp > 0;
+        }
+        case "<": {
+            return cmp < 0;
+        }
+        case ">=": {
+            return cmp >= 0;
+        }
+        case "<=": {
+            return cmp <= 0;
+        }
+    }
+}
+function testComparatorSet(version, set) {
+    for (const comparator of set) {
+        if (!testComparator(version, comparator)) {
+            return false;
+        }
+    }
+    if (version.prerelease && version.prerelease.length > 0) {
+        // Find the comparator that is allowed to have prereleases
+        // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
+        // That should allow `1.2.3-pr.2` to pass.
+        // However, `1.2.4-alpha.notready` should NOT be allowed,
+        // even though it's within the range set by the comparators.
+        for (const comparator of set) {
+            if ((0, _shared_js_1.isWildcardComparator)(comparator)) {
+                continue;
+            }
+            const { major, minor, patch, prerelease } = comparator;
+            if (prerelease && prerelease.length > 0) {
+                if (version.major === major && version.minor === minor &&
+                    version.patch === patch) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    return true;
+}
+exports.testComparatorSet = testComparatorSet;

package/script/std/semver/can_parse.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Returns true if the string can be parsed as SemVer.
+ *
+ * @example Usage
+ * ```ts
+ * import { canParse } from "can_parse.ts";
+ * import { assert, assertFalse } from "../assert/mod.ts";
+ *
+ * assert(canParse("1.2.3"));
+ * assertFalse(canParse("invalid"));
+ * ```
+ *
+ * @param value The version string to check
+ * @returns `true` if the string can be parsed as SemVer, `false` otherwise
+ */
+export declare function canParse(value: string): boolean;