@based/schema 5.0.0 → 5.0.2

package/dist/index.d.ts

@@ -4,4 +4,5 @@ export * from './lang.js';
 export * from './def/validation.js';
 export * from './serialize.js';
 export * from './infer.js';
+export * as semver from './parse/semver/mod.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -4,4 +4,5 @@ export * from './lang.js';
 export * from './def/validation.js';
 export * from './serialize.js';
 export * from './infer.js';
+export * as semver from './parse/semver/mod.js';
 //# sourceMappingURL=index.js.map

package/dist/parse/assert.d.ts

@@ -1,4 +1,4 @@
-import { type SemVer } from '@std/semver';
+import { SemVer } from './semver/types.js';
 export declare const expectVersion: (obj: any) => SemVer;
 export declare const expectObject: (obj: any, msg?: string) => void;
 export declare const expectArray: (obj: any) => void;

package/dist/parse/assert.js

@@ -1,5 +1,5 @@
-import { parse } from '@std/semver';
 import { EXPECTED_ARR, EXPECTED_BOOL, EXPECTED_FN, EXPECTED_NUM, EXPECTED_OBJ, EXPECTED_STR, } from './errors.js';
+import { parse } from './semver/parse.js';
 export const expectVersion = (obj) => {
     try {
         return parse(obj);

package/dist/parse/index.js

@@ -4,7 +4,10 @@ import propParsers from './props.js';
 import pc from 'picocolors';
 import { expectArray, expectBoolean, expectFunction, expectObject, expectTimezoneName, expectVersion, } from './assert.js';
 import { deepCopy } from '@based/utils';
-import { satisfies, parseRange, parse as parseVersion, rangeIntersects, } from '@std/semver';
+import { parse as parseVersion } from './semver/parse.js';
+import { parseRange } from './semver/parse_range.js';
+import { satisfies } from './semver/satisfies.js';
+import { rangeIntersects } from './semver/range_intersects.js';
 export { getPropType };
 export class SchemaParser {
     constructor(schema) {

package/dist/parse/semver/_constants.d.ts

@@ -0,0 +1,12 @@
+import type { Comparator, SemVer } from './types.js';
+/**
+ * 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 [any, "=", "!=", ">", ">=", "<", "<="];
+//# sourceMappingURL=_constants.d.ts.map

package/dist/parse/semver/_constants.js

@@ -0,0 +1,21 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+/**
+ * ANY is a sentinel value used by some range calculations. It is not a valid
+ * SemVer object and should not be used directly.
+ */
+export const ANY = {
+    major: Number.NaN,
+    minor: Number.NaN,
+    patch: Number.NaN,
+    prerelease: [],
+    build: [],
+};
+/**
+ * A comparator which will span all valid semantic versions
+ */
+export const ALL = {
+    operator: undefined,
+    ...ANY,
+};
+export const OPERATORS = [undefined, '=', '!=', '>', '>=', '<', '<='];
+//# sourceMappingURL=_constants.js.map

package/dist/parse/semver/_shared.d.ts

@@ -0,0 +1,44 @@
+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;
+//# sourceMappingURL=_shared.d.ts.map

package/dist/parse/semver/_shared.js

@@ -0,0 +1,165 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+export 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;
+}
+export 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;
+}
+export 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;
+}
+/**
+ * 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}?`;
+export const 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.*"
+ */
+export const 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"
+ */
+export const OPERATOR_XRANGE_REGEXP = new RegExp(`^(?<operator>~>?|\\^|${COMPARATOR})\\s*${XRANGE}$`);
+/**
+ * An empty string or a comparator (`=`, `<`, `<=`, `>`, or `>=`), followed by a version.
+ * @example ">1.2.3"
+ */
+export const 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
+ */
+export function isValidNumber(value) {
+    return (typeof value === 'number' &&
+        !Number.isNaN(value) &&
+        (!Number.isFinite(value) ||
+            (0 <= value && value <= Number.MAX_SAFE_INTEGER)));
+}
+export 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 function isValidString(value) {
+    return (typeof value === 'string' &&
+        value.length > 0 &&
+        value.length <= MAX_LENGTH &&
+        /[0-9A-Za-z-]+/.test(value));
+}
+const NUMERIC_IDENTIFIER_REGEXP = new RegExp(`^${NUMERIC_IDENTIFIER}$`);
+export 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;
+    });
+}
+export function parseBuild(buildmetadata) {
+    return buildmetadata.split('.').filter(Boolean);
+}
+export function parseNumber(input, errorMessage) {
+    const number = Number(input);
+    if (!isValidNumber(number))
+        throw new TypeError(errorMessage);
+    return number;
+}
+export 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));
+}
+//# sourceMappingURL=_shared.js.map

package/dist/parse/semver/_test_comparator_set.d.ts

@@ -0,0 +1,3 @@
+import type { Comparator, SemVer } from './types.js';
+export declare function testComparatorSet(version: SemVer, set: Comparator[]): boolean;
+//# sourceMappingURL=_test_comparator_set.d.ts.map

package/dist/parse/semver/_test_comparator_set.js

@@ -0,0 +1,60 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+import { isWildcardComparator } from './_shared.js';
+import { compare } from './compare.js';
+function testComparator(version, comparator) {
+    if (isWildcardComparator(comparator)) {
+        return true;
+    }
+    const cmp = 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;
+        }
+    }
+}
+export 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 (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;
+}
+//# sourceMappingURL=_test_comparator_set.js.map

package/dist/parse/semver/can_parse.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Returns true if the string can be parsed as SemVer.
+ *
+ * @example Usage
+ * ```ts
+ * import { canParse } from "@std/semver/can-parse";
+ * import { assert, assertFalse } from "@std/assert";
+ *
+ * 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;
+//# sourceMappingURL=can_parse.d.ts.map

package/dist/parse/semver/can_parse.js

@@ -0,0 +1,28 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { parse } from './parse.js';
+/**
+ * Returns true if the string can be parsed as SemVer.
+ *
+ * @example Usage
+ * ```ts
+ * import { canParse } from "@std/semver/can-parse";
+ * import { assert, assertFalse } from "@std/assert";
+ *
+ * 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 function canParse(value) {
+    try {
+        parse(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=can_parse.js.map

package/dist/parse/semver/compare.d.ts

@@ -0,0 +1,28 @@
+import type { SemVer } from './types.js';
+/**
+ * Compare two SemVers.
+ *
+ * Returns `0` if `version1` equals `version2`, or `1` if `version1` is greater, or `-1` if `version2` is
+ * greater.
+ *
+ * Sorts in ascending order if passed to {@linkcode Array.sort}.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, compare } from "@std/semver";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ *
+ * assertEquals(compare(version1, version2), -1);
+ * assertEquals(compare(version2, version1), 1);
+ * assertEquals(compare(version1, version1), 0);
+ * ```
+ *
+ * @param version1 The first SemVer to compare
+ * @param version2 The second SemVer to compare
+ * @returns `1` if `version1` is greater, `0` if equal, or `-1` if `version2` is greater
+ */
+export declare function compare(version1: SemVer, version2: SemVer): 1 | 0 | -1;
+//# sourceMappingURL=compare.d.ts.map

package/dist/parse/semver/compare.js

@@ -0,0 +1,36 @@
+import { checkIdentifier, compareIdentifier, compareNumber } from './_shared.js';
+/**
+ * Compare two SemVers.
+ *
+ * Returns `0` if `version1` equals `version2`, or `1` if `version1` is greater, or `-1` if `version2` is
+ * greater.
+ *
+ * Sorts in ascending order if passed to {@linkcode Array.sort}.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, compare } from "@std/semver";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ *
+ * assertEquals(compare(version1, version2), -1);
+ * assertEquals(compare(version2, version1), 1);
+ * assertEquals(compare(version1, version1), 0);
+ * ```
+ *
+ * @param version1 The first SemVer to compare
+ * @param version2 The second SemVer to compare
+ * @returns `1` if `version1` is greater, `0` if equal, or `-1` if `version2` is greater
+ */
+export function compare(version1, version2) {
+    if (version1 === version2)
+        return 0;
+    return (compareNumber(version1.major, version2.major) ||
+        compareNumber(version1.minor, version2.minor) ||
+        compareNumber(version1.patch, version2.patch) ||
+        checkIdentifier(version1.prerelease, version2.prerelease) ||
+        compareIdentifier(version1.prerelease, version2.prerelease));
+}
+//# sourceMappingURL=compare.js.map

package/dist/parse/semver/difference.d.ts

@@ -0,0 +1,27 @@
+import type { ReleaseType, SemVer } from './types.js';
+/**
+ * Returns difference between two SemVers by the release type,
+ * or `undefined` if the SemVers are the same.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, difference } from "@std/semver";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ * const version3 = parse("1.3.0");
+ * const version4 = parse("2.0.0");
+ *
+ * assertEquals(difference(version1, version2), "patch");
+ * assertEquals(difference(version1, version3), "minor");
+ * assertEquals(difference(version1, version4), "major");
+ * assertEquals(difference(version1, version1), undefined);
+ * ```
+ *
+ * @param version1 The first SemVer to compare
+ * @param version2 The second SemVer to compare
+ * @returns The release type difference or `undefined` if the versions are the same
+ */
+export declare function difference(version1: SemVer, version2: SemVer): ReleaseType | undefined;
+//# sourceMappingURL=difference.d.ts.map

package/dist/parse/semver/difference.js

@@ -0,0 +1,41 @@
+import { compareIdentifier } from './_shared.js';
+/**
+ * Returns difference between two SemVers by the release type,
+ * or `undefined` if the SemVers are the same.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, difference } from "@std/semver";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ * const version3 = parse("1.3.0");
+ * const version4 = parse("2.0.0");
+ *
+ * assertEquals(difference(version1, version2), "patch");
+ * assertEquals(difference(version1, version3), "minor");
+ * assertEquals(difference(version1, version4), "major");
+ * assertEquals(difference(version1, version1), undefined);
+ * ```
+ *
+ * @param version1 The first SemVer to compare
+ * @param version2 The second SemVer to compare
+ * @returns The release type difference or `undefined` if the versions are the same
+ */
+export function difference(version1, version2) {
+    const hasPrerelease = version1.prerelease?.length || version2.prerelease?.length;
+    if (version1.major !== version2.major) {
+        return hasPrerelease ? 'premajor' : 'major';
+    }
+    if (version1.minor !== version2.minor) {
+        return hasPrerelease ? 'preminor' : 'minor';
+    }
+    if (version1.patch !== version2.patch) {
+        return hasPrerelease ? 'prepatch' : 'patch';
+    }
+    if (compareIdentifier(version1.prerelease, version2.prerelease) !== 0) {
+        return 'prerelease';
+    }
+}
+//# sourceMappingURL=difference.js.map

package/dist/parse/semver/equals.d.ts

@@ -0,0 +1,24 @@
+import type { SemVer } from './types.js';
+/**
+ * Returns `true` if both SemVers are equivalent.
+ *
+ * This is equal to `compare(version1, version2) === 0`.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, equals } from "@std/semver";
+ * import { assert } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.3");
+ *
+ * assert(equals(version1, version2));
+ * assert(!equals(version1, parse("1.2.4")));
+ * ```
+ *
+ * @param version1 The first SemVer to compare
+ * @param version2 The second SemVer to compare
+ * @returns `true` if `version1` is equal to `version2`, `false` otherwise
+ */
+export declare function equals(version1: SemVer, version2: SemVer): boolean;
+//# sourceMappingURL=equals.d.ts.map

package/dist/parse/semver/equals.js

@@ -0,0 +1,28 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { compare } from './compare.js';
+/**
+ * Returns `true` if both SemVers are equivalent.
+ *
+ * This is equal to `compare(version1, version2) === 0`.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, equals } from "@std/semver";
+ * import { assert } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.3");
+ *
+ * assert(equals(version1, version2));
+ * assert(!equals(version1, parse("1.2.4")));
+ * ```
+ *
+ * @param version1 The first SemVer to compare
+ * @param version2 The second SemVer to compare
+ * @returns `true` if `version1` is equal to `version2`, `false` otherwise
+ */
+export function equals(version1, version2) {
+    return compare(version1, version2) === 0;
+}
+//# sourceMappingURL=equals.js.map

package/dist/parse/semver/format.d.ts

@@ -0,0 +1,22 @@
+import type { SemVer } from './types.js';
+/**
+ * Format a SemVer object into a string.
+ *
+ * @example Usage
+ * ```ts
+ * import { format } from "@std/semver/format";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const semver = {
+ *   major: 1,
+ *   minor: 2,
+ *   patch: 3,
+ * };
+ * assertEquals(format(semver), "1.2.3");
+ * ```
+ *
+ * @param version The SemVer to format
+ * @returns The string representation of a semantic version.
+ */
+export declare function format(version: SemVer): string;
+//# sourceMappingURL=format.d.ts.map

package/dist/parse/semver/format.js

@@ -0,0 +1,33 @@
+function formatNumber(value) {
+    return value.toFixed(0);
+}
+/**
+ * Format a SemVer object into a string.
+ *
+ * @example Usage
+ * ```ts
+ * import { format } from "@std/semver/format";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const semver = {
+ *   major: 1,
+ *   minor: 2,
+ *   patch: 3,
+ * };
+ * assertEquals(format(semver), "1.2.3");
+ * ```
+ *
+ * @param version The SemVer to format
+ * @returns The string representation of a semantic version.
+ */
+export function format(version) {
+    const major = formatNumber(version.major);
+    const minor = formatNumber(version.minor);
+    const patch = formatNumber(version.patch);
+    const pre = version.prerelease?.join('.') ?? '';
+    const build = version.build?.join('.') ?? '';
+    const primary = `${major}.${minor}.${patch}`;
+    const release = [primary, pre].filter((v) => v).join('-');
+    return [release, build].filter((v) => v).join('+');
+}
+//# sourceMappingURL=format.js.map

package/dist/parse/semver/format_range.d.ts

@@ -0,0 +1,18 @@
+import type { Range } from './types.js';
+/**
+ * Formats the SemVerrange into a string.
+ *
+ * @example Usage
+ * ```ts
+ * import { formatRange, parseRange } from "@std/semver";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const range = parseRange(">=1.2.3 <1.2.4");
+ * assertEquals(formatRange(range), ">=1.2.3 <1.2.4");
+ * ```
+ *
+ * @param range The range to format
+ * @returns A string representation of the SemVer range
+ */
+export declare function formatRange(range: Range): string;
+//# sourceMappingURL=format_range.d.ts.map