@based/schema 5.0.0 → 5.0.1

package/dist/parse/semver/format_range.js

@@ -0,0 +1,29 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { format } from './format.js';
+import { isWildcardComparator } from './_shared.js';
+function formatComparator(comparator) {
+    const { operator } = comparator;
+    return `${operator === undefined ? '' : operator}${isWildcardComparator(comparator) ? '*' : format(comparator)}`;
+}
+/**
+ * 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 function formatRange(range) {
+    return range
+        .map((c) => c.map((c) => formatComparator(c)).join(' '))
+        .join('||');
+}
+//# sourceMappingURL=format_range.js.map

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

@@ -0,0 +1,25 @@
+import type { SemVer } from './types.js';
+/**
+ * Greater than or equal to comparison for two SemVers.
+ *
+ * This is equal to `compare(version1, version2) >= 0`.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, greaterOrEqual } from "@std/semver";
+ * import { assert } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ *
+ * assert(greaterOrEqual(version2, version1));
+ * assert(!greaterOrEqual(version1, version2));
+ * assert(greaterOrEqual(version1, version1));
+ * ```
+ *
+ * @param version1 The first version to compare
+ * @param version2 The second version to compare
+ * @returns `true` if `version1` is greater than or equal to `version2`, `false` otherwise
+ */
+export declare function greaterOrEqual(version1: SemVer, version2: SemVer): boolean;
+//# sourceMappingURL=greater_or_equal.d.ts.map

package/dist/parse/semver/greater_or_equal.js

@@ -0,0 +1,27 @@
+import { compare } from './compare.js';
+/**
+ * Greater than or equal to comparison for two SemVers.
+ *
+ * This is equal to `compare(version1, version2) >= 0`.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, greaterOrEqual } from "@std/semver";
+ * import { assert } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ *
+ * assert(greaterOrEqual(version2, version1));
+ * assert(!greaterOrEqual(version1, version2));
+ * assert(greaterOrEqual(version1, version1));
+ * ```
+ *
+ * @param version1 The first version to compare
+ * @param version2 The second version to compare
+ * @returns `true` if `version1` is greater than or equal to `version2`, `false` otherwise
+ */
+export function greaterOrEqual(version1, version2) {
+    return compare(version1, version2) >= 0;
+}
+//# sourceMappingURL=greater_or_equal.js.map

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

@@ -0,0 +1,25 @@
+import type { SemVer } from './types.js';
+/**
+ * Greater than comparison for two SemVers.
+ *
+ * This is equal to `compare(version1, version2) > 0`.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, greaterThan } from "@std/semver";
+ * import { assert } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ *
+ * assert(greaterThan(version2, version1));
+ * assert(!greaterThan(version1, version2));
+ * assert(!greaterThan(version1, version1));
+ * ```
+ *
+ * @param version1 The first version to compare
+ * @param version2 The second version to compare
+ * @returns `true` if `version1` is greater than `version2`, `false` otherwise
+ */
+export declare function greaterThan(version1: SemVer, version2: SemVer): boolean;
+//# sourceMappingURL=greater_than.d.ts.map

package/dist/parse/semver/greater_than.js

@@ -0,0 +1,29 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { compare } from './compare.js';
+/**
+ * Greater than comparison for two SemVers.
+ *
+ * This is equal to `compare(version1, version2) > 0`.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, greaterThan } from "@std/semver";
+ * import { assert } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ *
+ * assert(greaterThan(version2, version1));
+ * assert(!greaterThan(version1, version2));
+ * assert(!greaterThan(version1, version1));
+ * ```
+ *
+ * @param version1 The first version to compare
+ * @param version2 The second version to compare
+ * @returns `true` if `version1` is greater than `version2`, `false` otherwise
+ */
+export function greaterThan(version1, version2) {
+    return compare(version1, version2) > 0;
+}
+//# sourceMappingURL=greater_than.js.map

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

@@ -0,0 +1,23 @@
+import type { Range, SemVer } from './types.js';
+/**
+ * Check if the SemVer is greater than the range.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, parseRange, greaterThanRange } from "@std/semver";
+ * import { assert } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ * const range = parseRange(">=1.2.3 <1.2.4");
+ *
+ * assert(!greaterThanRange(version1, range));
+ * assert(greaterThanRange(version2, range));
+ * ```
+ *
+ * @param version The version to check.
+ * @param range The range to check against.
+ * @returns `true` if the semver is greater than the range, `false` otherwise.
+ */
+export declare function greaterThanRange(version: SemVer, range: Range): boolean;
+//# sourceMappingURL=greater_than_range.d.ts.map

package/dist/parse/semver/greater_than_range.js

@@ -0,0 +1,59 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { testComparatorSet } from './_test_comparator_set.js';
+import { isWildcardComparator } from './_shared.js';
+import { compare } from './compare.js';
+/**
+ * Check if the SemVer is greater than the range.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, parseRange, greaterThanRange } from "@std/semver";
+ * import { assert } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ * const range = parseRange(">=1.2.3 <1.2.4");
+ *
+ * assert(!greaterThanRange(version1, range));
+ * assert(greaterThanRange(version2, range));
+ * ```
+ *
+ * @param version The version to check.
+ * @param range The range to check against.
+ * @returns `true` if the semver is greater than the range, `false` otherwise.
+ */
+export function greaterThanRange(version, range) {
+    return range.every((comparatorSet) => greaterThanComparatorSet(version, comparatorSet));
+}
+function greaterThanComparatorSet(version, comparatorSet) {
+    // If the comparator set contains wildcard, then the semver is not greater than the range.
+    if (comparatorSet.some(isWildcardComparator))
+        return false;
+    // If the semver satisfies the comparator set, then it's not greater than the range.
+    if (testComparatorSet(version, comparatorSet))
+        return false;
+    // If the semver is less than any of the comparator set, then it's not greater than the range.
+    if (comparatorSet.some((comparator) => lessThanComparator(version, comparator)))
+        return false;
+    return true;
+}
+function lessThanComparator(version, comparator) {
+    const cmp = compare(version, comparator);
+    switch (comparator.operator) {
+        case '=':
+        case undefined:
+            return cmp < 0;
+        case '!=':
+            return false;
+        case '>':
+            return cmp <= 0;
+        case '<':
+            return false;
+        case '>=':
+            return cmp < 0;
+        case '<=':
+            return false;
+    }
+}
+//# sourceMappingURL=greater_than_range.js.map

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

@@ -0,0 +1,51 @@
+import type { ReleaseType, SemVer } from './types.js';
+/** Options for {@linkcode increment}. */
+export interface IncrementOptions {
+    /** The pre-release metadata of the new version. */
+    prerelease?: string;
+    /** The build metadata of the new version. */
+    build?: string;
+}
+/**
+ * Returns the new SemVer resulting from an increment by release type.
+ *
+ * `premajor`, `preminor` and `prepatch` will bump the version up to the next version,
+ * based on the type, and will also add prerelease metadata.
+ *
+ * If called from a non-prerelease version, the `prerelease` will work the same as
+ * `prepatch`. The patch version is incremented and then is made into a prerelease. If
+ * the input version is already a prerelease it will simply increment the prerelease
+ * metadata.
+ *
+ * If a prerelease identifier is specified without a number then a number will be added.
+ * For example `pre` will result in `pre.0`. If the existing version already has a
+ * prerelease with a number and its the same prerelease identifier then the number
+ * will be incremented. If the identifier differs from the new identifier then the new
+ * identifier is applied and the number is reset to `0`.
+ *
+ * If the input version has build metadata it will be preserved on the resulting version
+ * unless a new build parameter is specified. Specifying `""` will unset existing build
+ * metadata.
+ *
+ * @example Usage
+ * ```ts
+ * import { increment, parse } from "@std/semver";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const version = parse("1.2.3");
+ * assertEquals(increment(version, "major"), parse("2.0.0"));
+ * assertEquals(increment(version, "minor"), parse("1.3.0"));
+ * assertEquals(increment(version, "patch"), parse("1.2.4"));
+ * assertEquals(increment(version, "prerelease"), parse("1.2.4-0"));
+ *
+ * const prerelease = parse("1.2.3-beta.0");
+ * assertEquals(increment(prerelease, "prerelease"), parse("1.2.3-beta.1"));
+ * ```
+ *
+ * @param version The version to increment
+ * @param release The type of increment to perform
+ * @param options Additional options
+ * @returns The new version
+ */
+export declare function increment(version: SemVer, release: ReleaseType, options?: IncrementOptions): SemVer;
+//# sourceMappingURL=increment.d.ts.map

package/dist/parse/semver/increment.js

@@ -0,0 +1,175 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { parseBuild } from './_shared.js';
+function bumpPrereleaseNumber(prerelease = []) {
+    const values = [...prerelease];
+    let index = values.length;
+    while (index >= 0) {
+        const value = values[index];
+        if (typeof value === 'number') {
+            values[index] = value + 1;
+            break;
+        }
+        index -= 1;
+    }
+    // if no number was bumped
+    if (index === -1)
+        values.push(0);
+    return values;
+}
+function bumpPrerelease(prerelease = [], identifier) {
+    let values = bumpPrereleaseNumber(prerelease);
+    if (!identifier)
+        return values;
+    // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
+    // 1.2.0-beta.foobar or 1.2.0-beta bumps to 1.2.0-beta.0
+    if (values[0] !== identifier || isNaN(values[1])) {
+        values = [identifier, 0];
+    }
+    return values;
+}
+/**
+ * Returns the new SemVer resulting from an increment by release type.
+ *
+ * `premajor`, `preminor` and `prepatch` will bump the version up to the next version,
+ * based on the type, and will also add prerelease metadata.
+ *
+ * If called from a non-prerelease version, the `prerelease` will work the same as
+ * `prepatch`. The patch version is incremented and then is made into a prerelease. If
+ * the input version is already a prerelease it will simply increment the prerelease
+ * metadata.
+ *
+ * If a prerelease identifier is specified without a number then a number will be added.
+ * For example `pre` will result in `pre.0`. If the existing version already has a
+ * prerelease with a number and its the same prerelease identifier then the number
+ * will be incremented. If the identifier differs from the new identifier then the new
+ * identifier is applied and the number is reset to `0`.
+ *
+ * If the input version has build metadata it will be preserved on the resulting version
+ * unless a new build parameter is specified. Specifying `""` will unset existing build
+ * metadata.
+ *
+ * @example Usage
+ * ```ts
+ * import { increment, parse } from "@std/semver";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const version = parse("1.2.3");
+ * assertEquals(increment(version, "major"), parse("2.0.0"));
+ * assertEquals(increment(version, "minor"), parse("1.3.0"));
+ * assertEquals(increment(version, "patch"), parse("1.2.4"));
+ * assertEquals(increment(version, "prerelease"), parse("1.2.4-0"));
+ *
+ * const prerelease = parse("1.2.3-beta.0");
+ * assertEquals(increment(prerelease, "prerelease"), parse("1.2.3-beta.1"));
+ * ```
+ *
+ * @param version The version to increment
+ * @param release The type of increment to perform
+ * @param options Additional options
+ * @returns The new version
+ */
+export function increment(version, release, options = {}) {
+    const build = options.build !== undefined
+        ? parseBuild(options.build)
+        : (version.build ?? []);
+    switch (release) {
+        case 'premajor':
+            return {
+                major: version.major + 1,
+                minor: 0,
+                patch: 0,
+                prerelease: bumpPrerelease(version.prerelease, options.prerelease),
+                build,
+            };
+        case 'preminor':
+            return {
+                major: version.major,
+                minor: version.minor + 1,
+                patch: 0,
+                prerelease: bumpPrerelease(version.prerelease, options.prerelease),
+                build,
+            };
+        case 'prepatch':
+            return {
+                major: version.major,
+                minor: version.minor,
+                patch: version.patch + 1,
+                prerelease: bumpPrerelease(version.prerelease, options.prerelease),
+                build,
+            };
+        case 'prerelease': {
+            // If the input is a non-prerelease version, this acts the same as prepatch.
+            const isPrerelease = (version.prerelease ?? []).length === 0;
+            const patch = isPrerelease ? version.patch + 1 : version.patch;
+            return {
+                major: version.major,
+                minor: version.minor,
+                patch,
+                prerelease: bumpPrerelease(version.prerelease, options.prerelease),
+                build,
+            };
+        }
+        case 'major': {
+            // If this is a pre-major version, bump up to the same major version. Otherwise increment major.
+            // 1.0.0-5 bumps to 1.0.0
+            // 1.1.0 bumps to 2.0.0
+            const isPrerelease = (version.prerelease ?? []).length === 0;
+            const major = isPrerelease || version.minor !== 0 || version.patch !== 0
+                ? version.major + 1
+                : version.major;
+            return {
+                major,
+                minor: 0,
+                patch: 0,
+                prerelease: [],
+                build,
+            };
+        }
+        case 'minor': {
+            // If this is a pre-minor version, bump up to the same minor version. Otherwise increment minor.
+            // 1.2.0-5 bumps to 1.2.0
+            // 1.2.1 bumps to 1.3.0
+            const isPrerelease = (version.prerelease ?? []).length === 0;
+            const minor = isPrerelease || version.patch !== 0 ? version.minor + 1 : version.minor;
+            return {
+                major: version.major,
+                minor,
+                patch: 0,
+                prerelease: [],
+                build,
+            };
+        }
+        case 'patch': {
+            // If this is not a pre-release version, it will increment the patch.
+            // If it is a pre-release it will bump up to the same patch version.
+            // 1.2.0-5 patches to 1.2.0
+            // 1.2.0 patches to 1.2.1
+            const isPrerelease = (version.prerelease ?? []).length === 0;
+            const patch = isPrerelease ? version.patch + 1 : version.patch;
+            return {
+                major: version.major,
+                minor: version.minor,
+                patch,
+                prerelease: [],
+                build,
+            };
+        }
+        case 'pre': {
+            // 1.0.0 "pre" would become 1.0.0-0
+            // 1.0.0-0 would become 1.0.0-1
+            // 1.0.0-beta.0 would be come 1.0.0-beta.1
+            // switching the pre identifier resets the number to 0
+            return {
+                major: version.major,
+                minor: version.minor,
+                patch: version.patch,
+                prerelease: bumpPrerelease(version.prerelease, options.prerelease),
+                build,
+            };
+        }
+        default:
+            throw new TypeError(`Cannot increment version: invalid argument ${release}`);
+    }
+}
+//# sourceMappingURL=increment.js.map

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

@@ -0,0 +1,23 @@
+import type { Range } from './types.js';
+/**
+ * Does a deep check on the object to determine if its a valid range.
+ *
+ * Objects with extra fields are still considered valid if they have at
+ * least the correct fields.
+ *
+ * Adds a type assertion if true.
+ *
+ * @example Usage
+ * ```ts
+ * import { isRange } from "@std/semver/is-range";
+ * import { assert } from "@std/assert";
+ *
+ * const range = [[{ major: 1, minor: 2, patch: 3 }]];
+ * assert(isRange(range));
+ * assert(!isRange({}));
+ * ```
+ * @param value The value to check if its a valid Range
+ * @returns True if its a valid Range otherwise false.
+ */
+export declare function isRange(value: unknown): value is Range;
+//# sourceMappingURL=is_range.d.ts.map

package/dist/parse/semver/is_range.js

@@ -0,0 +1,39 @@
+import { OPERATORS } from './_constants.js';
+import { ALL } from './_constants.js';
+import { isSemVer } from './is_semver.js';
+function isComparator(value) {
+    if (value === null ||
+        value === undefined ||
+        Array.isArray(value) ||
+        typeof value !== 'object')
+        return false;
+    if (value === ALL)
+        return true;
+    const { operator } = value;
+    return ((operator === undefined || OPERATORS.includes(operator)) && isSemVer(value));
+}
+/**
+ * Does a deep check on the object to determine if its a valid range.
+ *
+ * Objects with extra fields are still considered valid if they have at
+ * least the correct fields.
+ *
+ * Adds a type assertion if true.
+ *
+ * @example Usage
+ * ```ts
+ * import { isRange } from "@std/semver/is-range";
+ * import { assert } from "@std/assert";
+ *
+ * const range = [[{ major: 1, minor: 2, patch: 3 }]];
+ * assert(isRange(range));
+ * assert(!isRange({}));
+ * ```
+ * @param value The value to check if its a valid Range
+ * @returns True if its a valid Range otherwise false.
+ */
+export function isRange(value) {
+    return (Array.isArray(value) &&
+        value.every((r) => Array.isArray(r) && r.every((c) => isComparator(c))));
+}
+//# sourceMappingURL=is_range.js.map

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

@@ -0,0 +1,34 @@
+import type { SemVer } from './types.js';
+/**
+ * Checks to see if value is a valid SemVer object. It does a check
+ * into each field including prerelease and build.
+ *
+ * Some invalid SemVer sentinels can still return true such as ANY and INVALID.
+ * An object which has the same value as a sentinel but isn't reference equal
+ * will still fail.
+ *
+ * Objects which are valid SemVer objects but have _extra_ fields are still
+ * considered SemVer objects and this will return true.
+ *
+ * A type assertion is added to the value.
+ *
+ * @example Usage
+ * ```ts
+ * import { isSemVer } from "@std/semver/is-semver";
+ * import { assert } from "@std/assert";
+ *
+ * const value = {
+ *   major: 1,
+ *   minor: 2,
+ *   patch: 3,
+ * };
+ *
+ * assert(isSemVer(value));
+ * assert(!isSemVer({ major: 1, minor: 2 }));
+ * ```
+ *
+ * @param value The value to check to see if its a valid SemVer object
+ * @returns True if value is a valid SemVer otherwise false
+ */
+export declare function isSemVer(value: unknown): value is SemVer;
+//# sourceMappingURL=is_semver.d.ts.map

package/dist/parse/semver/is_semver.js

@@ -0,0 +1,54 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { ANY } from './_constants.js';
+import { isValidNumber, isValidString } from './_shared.js';
+/**
+ * Checks to see if value is a valid SemVer object. It does a check
+ * into each field including prerelease and build.
+ *
+ * Some invalid SemVer sentinels can still return true such as ANY and INVALID.
+ * An object which has the same value as a sentinel but isn't reference equal
+ * will still fail.
+ *
+ * Objects which are valid SemVer objects but have _extra_ fields are still
+ * considered SemVer objects and this will return true.
+ *
+ * A type assertion is added to the value.
+ *
+ * @example Usage
+ * ```ts
+ * import { isSemVer } from "@std/semver/is-semver";
+ * import { assert } from "@std/assert";
+ *
+ * const value = {
+ *   major: 1,
+ *   minor: 2,
+ *   patch: 3,
+ * };
+ *
+ * assert(isSemVer(value));
+ * assert(!isSemVer({ major: 1, minor: 2 }));
+ * ```
+ *
+ * @param value The value to check to see if its a valid SemVer object
+ * @returns True if value is a valid SemVer otherwise false
+ */
+export function isSemVer(value) {
+    if (value === null || value === undefined)
+        return false;
+    if (Array.isArray(value))
+        return false;
+    if (typeof value !== 'object')
+        return false;
+    if (value === ANY)
+        return true;
+    const { major, minor, patch, build = [], prerelease = [], } = value;
+    return (isValidNumber(major) &&
+        isValidNumber(minor) &&
+        isValidNumber(patch) &&
+        Array.isArray(prerelease) &&
+        prerelease.every((v) => isValidString(v) || isValidNumber(v)) &&
+        Array.isArray(build) &&
+        build.every(isValidString));
+}
+//# sourceMappingURL=is_semver.js.map

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

@@ -0,0 +1,25 @@
+import type { SemVer } from './types.js';
+/**
+ * Less than or equal to comparison for two SemVers.
+ *
+ * This is equal to `compare(version1, version2) <= 0`.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, lessOrEqual } from "@std/semver";
+ * import { assert } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ *
+ * assert(lessOrEqual(version1, version2));
+ * assert(!lessOrEqual(version2, version1));
+ * assert(lessOrEqual(version1, version1));
+ * ```
+ *
+ * @param version1 the first version to compare
+ * @param version2 the second version to compare
+ * @returns `true` if `version1` is less than or equal to `version2`, `false` otherwise
+ */
+export declare function lessOrEqual(version1: SemVer, version2: SemVer): boolean;
+//# sourceMappingURL=less_or_equal.d.ts.map

package/dist/parse/semver/less_or_equal.js

@@ -0,0 +1,27 @@
+import { compare } from './compare.js';
+/**
+ * Less than or equal to comparison for two SemVers.
+ *
+ * This is equal to `compare(version1, version2) <= 0`.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, lessOrEqual } from "@std/semver";
+ * import { assert } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ *
+ * assert(lessOrEqual(version1, version2));
+ * assert(!lessOrEqual(version2, version1));
+ * assert(lessOrEqual(version1, version1));
+ * ```
+ *
+ * @param version1 the first version to compare
+ * @param version2 the second version to compare
+ * @returns `true` if `version1` is less than or equal to `version2`, `false` otherwise
+ */
+export function lessOrEqual(version1, version2) {
+    return compare(version1, version2) <= 0;
+}
+//# sourceMappingURL=less_or_equal.js.map