@based/schema 5.0.0-alpha.9 → 5.0.1

package/dist/parse/props.js

@@ -1,7 +1,12 @@
+import { convertToTimestamp } from '@based/utils';
+import { NUMBER, TYPE_INDEX_MAP } from '../def/types.js';
+import { VALIDATION_MAP } from '../def/validation.js';
 import { stringFormats, dateDisplays, numberDisplays, } from '../types.js';
-import { expectBoolean, expectFloat32Array, expectFunction, expectNumber, expectObject, expectString, } from './assert.js';
-import { EXPECTED_ARR, EXPECTED_DATE, EXPECTED_OBJ, EXPECTED_PRIMITIVE, EXPECTED_VALUE_IN_ENUM, INVALID_VALUE, MIN_MAX, MISSING_TYPE, OUT_OF_RANGE, TEXT_REQUIRES_LOCALES, TYPE_MISMATCH, UNKNOWN_PROP, NOT_ALLOWED_IN_ITEMS, } from './errors.js';
+import { expectBoolean, expectFunction, expectNumber, expectObject, expectString, } from './assert.js';
+import { EXPECTED_ARR, EXPECTED_OBJ, EXPECTED_PRIMITIVE, INVALID_VALUE, MIN_MAX, MISSING_TYPE, TEXT_REQUIRES_LOCALES, TYPE_MISMATCH, UNKNOWN_PROP, NOT_ALLOWED_IN_ITEMS, } from './errors.js';
 import { getPropType } from './utils.js';
+import { DEFAULT_MAP } from '../def/defaultMap.js';
+import { parseMinMaxStep } from '../def/utils.js';
 let stringFormatsSet;
 let numberDisplaysSet;
 let dateDisplaysSet;
@@ -38,16 +43,29 @@ const shared = {
             throw Error(TYPE_MISMATCH);
         }
     },
-    title(val) { },
-    description(val) { },
-    readOnly(val) { },
-    examples(val) { },
+    title(val) {
+        expectString(val);
+    },
+    description(val) {
+        expectString(val);
+    },
+    readOnly(val) {
+        expectBoolean(val);
+    },
+    examples(val) {
+        expectString(val);
+    },
+    validation(val) {
+        expectFunction(val);
+    },
 };
 function propParser(required, optional, allowShorthand) {
     return (prop, ctx) => {
         if (typeof prop === 'string') {
             // allow string
             if (allowShorthand === 0) {
+                // @ts-ignore
+                required?.type?.(prop, { type: prop }, ctx);
                 return;
             }
             throw Error(EXPECTED_OBJ);
@@ -91,9 +109,67 @@ function propParser(required, optional, allowShorthand) {
     };
 }
 const p = {};
+export const isDefault = (val, prop, ctx) => {
+    let typeIndex;
+    typeIndex = TYPE_INDEX_MAP[prop.type];
+    if ('enum' in prop) {
+        typeIndex = TYPE_INDEX_MAP['enum'];
+    }
+    if (prop.type === 'timestamp') {
+        val = convertToTimestamp(val);
+    }
+    const validation = prop.validation || VALIDATION_MAP[typeIndex];
+    const propDef = {
+        typeIndex,
+        __isPropDef: true,
+        start: 0,
+        path: [],
+        prop: 0,
+        len: 0,
+        separate: false,
+        enum: prop.enum,
+        validation,
+        default: DEFAULT_MAP[typeIndex],
+        step: parseMinMaxStep((prop.step ?? typeIndex === NUMBER) ? 0 : 1),
+        max: parseMinMaxStep(prop.max),
+        min: parseMinMaxStep(prop.min),
+    };
+    if (prop.type === 'text') {
+        if (typeof val === 'object') {
+            for (const key in val) {
+                if (!ctx.schema.locales || !(key in ctx.schema.locales)) {
+                    throw new Error(`Incorrect default for type "text" lang "${key}"`);
+                }
+                if (!validation(val[key], propDef)) {
+                    throw new Error(`Incorrect default for type "text" lang "${key}"`);
+                }
+            }
+        }
+        else {
+            if (!validation(val, propDef)) {
+                throw new Error(`Incorrect default for type "text"`);
+            }
+            val = {};
+            for (const key in ctx.schema.locales) {
+                val[key] = ctx.schema.locales[key];
+            }
+        }
+        return val;
+    }
+    if (!validation(val, propDef)) {
+        throw new Error(`Incorrect default for type "${prop.type ?? 'enum'}"`);
+    }
+    if ('enum' in prop) {
+        if (val === undefined) {
+            return 0;
+        }
+        return prop.enum.findIndex((v) => v === val) + 1;
+    }
+    return val;
+};
 p.boolean = propParser(STUB, {
-    default(val) {
-        expectBoolean(val);
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
     },
 }, 0);
 p.vector = propParser({
@@ -101,8 +177,49 @@ p.vector = propParser({
         expectNumber(val);
     },
 }, {
-    default(val) {
-        expectFloat32Array(val);
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
+    },
+    baseType(val, prop, ctx) {
+        if (![
+            'number',
+            'int8',
+            ,
+            'uint8',
+            'int16',
+            'uint16',
+            'int32',
+            'uint32',
+            'float32',
+            'float64',
+        ].includes(val)) {
+            throw Error(INVALID_VALUE);
+        }
+    },
+}, 0);
+p.colvec = propParser({
+    size(val) {
+        expectNumber(val);
+    },
+}, {
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
+    },
+    baseType(val, prop, ctx) {
+        if (![
+            'number',
+            'int8',
+            ,
+            'uint8',
+            'int16',
+            'uint16',
+            'int32',
+            'uint32',
+            'float32',
+            'float64',
+        ].includes(val)) {
+            throw Error(INVALID_VALUE);
+        }
     },
 }, 0);
 p.enum = propParser({
@@ -120,10 +237,8 @@ p.enum = propParser({
         }
     },
 }, {
-    default(val, prop) {
-        if (!prop.enum.includes(val)) {
-            throw Error(EXPECTED_VALUE_IN_ENUM);
-        }
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
     },
 }, 1);
 const numberOpts = {
@@ -146,18 +261,8 @@ const numberOpts = {
             throw Error(INVALID_VALUE);
         }
     },
-    default(val, prop) {
-        expectNumber(val);
-        if (val > prop.max || val < prop.min) {
-            throw Error(OUT_OF_RANGE);
-        }
-        if (prop.step !== 'any') {
-            const min = typeof prop.min !== 'number' || prop.min === Infinity ? 0 : prop.min;
-            const v = val - min;
-            if (~~(v / prop.step) * prop.step !== v) {
-                throw Error(INVALID_VALUE);
-            }
-        }
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
     },
 };
 p.number = propParser(STUB, numberOpts, 0);
@@ -168,14 +273,10 @@ p.uint16 = propParser(STUB, numberOpts, 0);
 p.int32 = propParser(STUB, numberOpts, 0);
 p.uint32 = propParser(STUB, numberOpts, 0);
 p.object = propParser({
-    props(val, prop, ctx) {
+    props(val, _prop, ctx) {
         ctx.parseProps(val, ctx.type);
     },
-}, {
-    default(val) {
-        console.warn('TODO object default value');
-    },
-});
+}, {});
 p.set = propParser({
     items(items, prop, ctx) {
         expectObject(items);
@@ -218,16 +319,13 @@ p.references = propParser({
         }
     },
 }, {
-    default(val, prop) {
-        console.warn('TODO SET DEFAULT VALUE');
-        // if (typeof val === 'object') {
-        //   throwErr(ERRORS.EXPECTED_PRIMITIVE, prop, 'default')
-        // }
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
     },
 });
 const binaryOpts = {
-    default(val) {
-        expectString(val);
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
     },
     format(val) {
         expectString(val);
@@ -270,9 +368,12 @@ p.text = propParser({
         throw Error(TEXT_REQUIRES_LOCALES);
     },
 }, {
+    compression(val) {
+        return val;
+    },
     format: binaryOpts.format,
-    default(val, prop) {
-        console.warn('MAKE DEFAULT VALUE FOR TEXT');
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
     },
 }, 0);
 p.timestamp = propParser(STUB, {
@@ -281,11 +382,27 @@ p.timestamp = propParser(STUB, {
         dateDisplaysSet ??= new Set(dateDisplays);
         dateDisplaysSet.has(val);
     },
-    default(val) {
-        if (typeof val !== 'number' && !(val instanceof Date)) {
-            throw Error(EXPECTED_DATE);
+    min(val) {
+        if (typeof val !== 'string' && typeof val !== 'number') {
+            throw Error(INVALID_VALUE);
         }
     },
+    max(val) {
+        if (typeof val !== 'string' && typeof val !== 'number') {
+            throw Error(INVALID_VALUE);
+        }
+    },
+    step(val) {
+        if (typeof val !== 'string' && typeof val !== 'number') {
+            throw Error(INVALID_VALUE);
+        }
+        if (typeof val === 'string' && val.includes('now')) {
+            throw Error(INVALID_VALUE);
+        }
+    },
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
+    },
     on(val) {
         if (val !== 'create' && val !== 'update') {
             throw Error(INVALID_VALUE);
@@ -298,7 +415,7 @@ p.reference = propParser({
             throw Error(MISSING_TYPE);
         }
     },
-    prop(propKey, prop, { schema, type, inQuery, path }) {
+    prop(propKey, prop, { schema, type, inQuery, path, lvl }) {
         const propAllowed = type && !inQuery;
         if (propAllowed) {
             expectString(propKey);
@@ -316,7 +433,7 @@ p.reference = propParser({
             if (create) {
                 const ref = path[1];
                 let prop = '';
-                for (let i = 3; i < path.length - 1; i += 2) {
+                for (let i = 3; i < lvl; i += 2) {
                     prop += prop ? `.${path[i]}` : path[i];
                 }
                 targetProp.readOnly = true;
@@ -349,8 +466,8 @@ p.reference = propParser({
     },
 }, {
     mime: binaryOpts.mime,
-    default(val) {
-        expectString(val);
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
     },
     edge(val, prop, ctx, key) {
         const edgeAllowed = ctx.type && !ctx.inQuery;
@@ -378,19 +495,19 @@ p.reference = propParser({
     },
 });
 p.alias = propParser(STUB, {
-    default(val) {
-        expectString(val);
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
     },
     format: binaryOpts.format,
 }, 0);
 p.cardinality = propParser(STUB, {
-    default(val) {
-        expectNumber(val);
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
     },
 }, 0);
 p.json = propParser(STUB, {
-    default(val) {
-        expectObject(val);
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
     },
 }, 0);
 export default p;

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