@sinclair/typebox 0.29.6 → 0.30.0-dev-1

package/value/cast.d.ts

@@ -24,7 +24,8 @@ export declare class ValueCastDereferenceError extends Error {
     readonly schema: Types.TRef | Types.TThis;
     constructor(schema: Types.TRef | Types.TThis);
 }
-export declare namespace ValueCast {
-    function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): any;
-    function Cast<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): Types.Static<T>;
-}
+export declare function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): any;
+/** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
+export declare function Cast<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): Types.Static<T>;
+/** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
+export declare function Cast<T extends Types.TSchema>(schema: T, value: unknown): Types.Static<T>;

package/value/cast.js

@@ -27,14 +27,15 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueCast = exports.ValueCastDereferenceError = exports.ValueCastUnknownTypeError = exports.ValueCastRecursiveTypeError = exports.ValueCastNeverTypeError = exports.ValueCastArrayUniqueItemsTypeError = exports.ValueCastReferenceTypeError = void 0;
+exports.Cast = exports.Visit = exports.ValueCastDereferenceError = exports.ValueCastUnknownTypeError = exports.ValueCastRecursiveTypeError = exports.ValueCastNeverTypeError = exports.ValueCastArrayUniqueItemsTypeError = exports.ValueCastReferenceTypeError = void 0;
 const Types = require("../typebox");
-const create_1 = require("./create");
-const check_1 = require("./check");
-const clone_1 = require("./clone");
-// ----------------------------------------------------------------------------------------------
+const ValueCreate = require("./create");
+const ValueCheck = require("./check");
+const ValueClone = require("./clone");
+const ValueGuard = require("./guard");
+// --------------------------------------------------------------------------
 // Errors
-// ----------------------------------------------------------------------------------------------
+// --------------------------------------------------------------------------
 class ValueCastReferenceTypeError extends Error {
     constructor(schema) {
         super(`ValueCast: Cannot locate referenced schema with $id '${schema.$ref}'`);
@@ -78,29 +79,30 @@ class ValueCastDereferenceError extends Error {
     }
 }
 exports.ValueCastDereferenceError = ValueCastDereferenceError;
-// ----------------------------------------------------------------------------------------------
-// The following will score a schema against a value. For objects, the score is the tally of
-// points awarded for each property of the value. Property points are (1.0 / propertyCount)
-// to prevent large property counts biasing results. Properties that match literal values are
-// maximally awarded as literals are typically used as union discriminator fields.
-// ----------------------------------------------------------------------------------------------
+// --------------------------------------------------------------------------
+// The following will score a schema against a value. For objects, the score
+// is the tally of points awarded for each property of the value. Property
+// points are (1.0 / propertyCount) to prevent large property counts biasing
+// results. Properties that match literal values are maximally awarded as
+// literals are typically used as union discriminator fields.
+// --------------------------------------------------------------------------
 var UnionCastCreate;
 (function (UnionCastCreate) {
     function Score(schema, references, value) {
-        if (schema[Types.Kind] === 'Object' && typeof value === 'object' && value !== null) {
+        if (schema[Types.Kind] === 'Object' && typeof value === 'object' && !ValueGuard.IsNull(value)) {
             const object = schema;
-            const keys = Object.keys(value);
-            const entries = globalThis.Object.entries(object.properties);
+            const keys = Object.getOwnPropertyNames(value);
+            const entries = Object.entries(object.properties);
             const [point, max] = [1 / entries.length, entries.length];
             return entries.reduce((acc, [key, schema]) => {
                 const literal = schema[Types.Kind] === 'Literal' && schema.const === value[key] ? max : 0;
-                const checks = check_1.ValueCheck.Check(schema, references, value[key]) ? point : 0;
+                const checks = ValueCheck.Check(schema, references, value[key]) ? point : 0;
                 const exists = keys.includes(key) ? point : 0;
                 return acc + (literal + checks + exists);
             }, 0);
         }
         else {
-            return check_1.ValueCheck.Check(schema, references, value) ? 1 : 0;
+            return ValueCheck.Check(schema, references, value) ? 1 : 0;
         }
     }
     function Select(union, references, value) {
@@ -115,258 +117,251 @@ var UnionCastCreate;
         return select;
     }
     function Create(union, references, value) {
-        if (union.default !== undefined) {
+        if ('default' in union) {
             return union.default;
         }
         else {
             const schema = Select(union, references, value);
-            return ValueCast.Cast(schema, references, value);
+            return Cast(schema, references, value);
         }
     }
     UnionCastCreate.Create = Create;
 })(UnionCastCreate || (UnionCastCreate = {}));
-var ValueCast;
-(function (ValueCast) {
-    // ----------------------------------------------------------------------------------------------
-    // Guards
-    // ----------------------------------------------------------------------------------------------
-    function IsObject(value) {
-        return typeof value === 'object' && value !== null && !globalThis.Array.isArray(value);
-    }
-    function IsArray(value) {
-        return typeof value === 'object' && globalThis.Array.isArray(value);
-    }
-    function IsNumber(value) {
-        return typeof value === 'number' && !isNaN(value);
-    }
-    function IsString(value) {
-        return typeof value === 'string';
-    }
-    // ----------------------------------------------------------------------------------------------
-    // Cast
-    // ----------------------------------------------------------------------------------------------
-    function Any(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
-    }
-    function Array(schema, references, value) {
-        if (check_1.ValueCheck.Check(schema, references, value))
-            return clone_1.ValueClone.Clone(value);
-        const created = IsArray(value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
-        const minimum = IsNumber(schema.minItems) && created.length < schema.minItems ? [...created, ...globalThis.Array.from({ length: schema.minItems - created.length }, () => null)] : created;
-        const maximum = IsNumber(schema.maxItems) && minimum.length > schema.maxItems ? minimum.slice(0, schema.maxItems) : minimum;
-        const casted = maximum.map((value) => Visit(schema.items, references, value));
-        if (schema.uniqueItems !== true)
-            return casted;
-        const unique = [...new Set(casted)];
-        if (!check_1.ValueCheck.Check(schema, references, unique))
-            throw new ValueCastArrayUniqueItemsTypeError(schema, unique);
-        return unique;
-    }
-    function BigInt(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
-    }
-    function Boolean(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
-    }
-    function Constructor(schema, references, value) {
-        if (check_1.ValueCheck.Check(schema, references, value))
-            return create_1.ValueCreate.Create(schema, references);
-        const required = new Set(schema.returns.required || []);
-        const result = function () { };
-        for (const [key, property] of globalThis.Object.entries(schema.returns.properties)) {
-            if (!required.has(key) && value.prototype[key] === undefined)
-                continue;
-            result.prototype[key] = Visit(property, references, value.prototype[key]);
-        }
-        return result;
-    }
-    function Date(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
-    }
-    function Function(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
-    }
-    function Integer(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
-    }
-    function Intersect(schema, references, value) {
-        const created = create_1.ValueCreate.Create(schema, references);
-        const mapped = IsObject(created) && IsObject(value) ? { ...created, ...value } : value;
-        return check_1.ValueCheck.Check(schema, references, mapped) ? mapped : create_1.ValueCreate.Create(schema, references);
-    }
-    function Literal(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
-    }
-    function Never(schema, references, value) {
-        throw new ValueCastNeverTypeError(schema);
-    }
-    function Not(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
-    }
-    function Null(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
-    }
-    function Number(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
-    }
-    function Object(schema, references, value) {
-        if (check_1.ValueCheck.Check(schema, references, value))
-            return value;
-        if (value === null || typeof value !== 'object')
-            return create_1.ValueCreate.Create(schema, references);
-        const required = new Set(schema.required || []);
-        const result = {};
-        for (const [key, property] of globalThis.Object.entries(schema.properties)) {
-            if (!required.has(key) && value[key] === undefined)
+// --------------------------------------------------------------------------
+// Cast
+// --------------------------------------------------------------------------
+function TAny(schema, references, value) {
+    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references);
+}
+function TArray(schema, references, value) {
+    if (ValueCheck.Check(schema, references, value))
+        return ValueClone.Clone(value);
+    const created = ValueGuard.IsArray(value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references);
+    const minimum = ValueGuard.IsNumber(schema.minItems) && created.length < schema.minItems ? [...created, ...Array.from({ length: schema.minItems - created.length }, () => null)] : created;
+    const maximum = ValueGuard.IsNumber(schema.maxItems) && minimum.length > schema.maxItems ? minimum.slice(0, schema.maxItems) : minimum;
+    const casted = maximum.map((value) => Visit(schema.items, references, value));
+    if (schema.uniqueItems !== true)
+        return casted;
+    const unique = [...new Set(casted)];
+    if (!ValueCheck.Check(schema, references, unique))
+        throw new ValueCastArrayUniqueItemsTypeError(schema, unique);
+    return unique;
+}
+function TAsyncIterator(schema, references, value) {
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references);
+}
+function TBigInt(schema, references, value) {
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references);
+}
+function TBoolean(schema, references, value) {
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references);
+}
+function TConstructor(schema, references, value) {
+    if (ValueCheck.Check(schema, references, value))
+        return ValueCreate.Create(schema, references);
+    const required = new Set(schema.returns.required || []);
+    const result = function () { };
+    for (const [key, property] of Object.entries(schema.returns.properties)) {
+        if (!required.has(key) && value.prototype[key] === undefined)
+            continue;
+        result.prototype[key] = Visit(property, references, value.prototype[key]);
+    }
+    return result;
+}
+function TDate(schema, references, value) {
+    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references);
+}
+function TFunction(schema, references, value) {
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references);
+}
+function TInteger(schema, references, value) {
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references);
+}
+function TIntersect(schema, references, value) {
+    const created = ValueCreate.Create(schema, references);
+    const mapped = ValueGuard.IsPlainObject(created) && ValueGuard.IsPlainObject(value) ? { ...created, ...value } : value;
+    return ValueCheck.Check(schema, references, mapped) ? mapped : ValueCreate.Create(schema, references);
+}
+function TIterator(schema, references, value) {
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references);
+}
+function TLiteral(schema, references, value) {
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references);
+}
+function TNever(schema, references, value) {
+    throw new ValueCastNeverTypeError(schema);
+}
+function TNot(schema, references, value) {
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references);
+}
+function TNull(schema, references, value) {
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references);
+}
+function TNumber(schema, references, value) {
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references);
+}
+function TObject(schema, references, value) {
+    if (ValueCheck.Check(schema, references, value))
+        return value;
+    if (value === null || typeof value !== 'object')
+        return ValueCreate.Create(schema, references);
+    const required = new Set(schema.required || []);
+    const result = {};
+    for (const [key, property] of Object.entries(schema.properties)) {
+        if (!required.has(key) && value[key] === undefined)
+            continue;
+        result[key] = Visit(property, references, value[key]);
+    }
+    // additional schema properties
+    if (typeof schema.additionalProperties === 'object') {
+        const propertyNames = Object.getOwnPropertyNames(schema.properties);
+        for (const propertyName of Object.getOwnPropertyNames(value)) {
+            if (propertyNames.includes(propertyName))
                 continue;
-            result[key] = Visit(property, references, value[key]);
-        }
-        // additional schema properties
-        if (typeof schema.additionalProperties === 'object') {
-            const propertyNames = globalThis.Object.getOwnPropertyNames(schema.properties);
-            for (const propertyName of globalThis.Object.getOwnPropertyNames(value)) {
-                if (propertyNames.includes(propertyName))
-                    continue;
-                result[propertyName] = Visit(schema.additionalProperties, references, value[propertyName]);
-            }
-        }
-        return result;
-    }
-    function Promise(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
-    }
-    function Record(schema, references, value) {
-        if (check_1.ValueCheck.Check(schema, references, value))
-            return clone_1.ValueClone.Clone(value);
-        if (value === null || typeof value !== 'object' || globalThis.Array.isArray(value) || value instanceof globalThis.Date)
-            return create_1.ValueCreate.Create(schema, references);
-        const subschemaPropertyName = globalThis.Object.getOwnPropertyNames(schema.patternProperties)[0];
-        const subschema = schema.patternProperties[subschemaPropertyName];
-        const result = {};
-        for (const [propKey, propValue] of globalThis.Object.entries(value)) {
-            result[propKey] = Visit(subschema, references, propValue);
-        }
-        return result;
-    }
-    function Ref(schema, references, value) {
-        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
-        if (index === -1)
-            throw new ValueCastDereferenceError(schema);
-        const target = references[index];
-        return Visit(target, references, value);
-    }
-    function String(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
-    }
-    function Symbol(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
-    }
-    function TemplateLiteral(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
-    }
-    function This(schema, references, value) {
-        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
-        if (index === -1)
-            throw new ValueCastDereferenceError(schema);
-        const target = references[index];
-        return Visit(target, references, value);
-    }
-    function Tuple(schema, references, value) {
-        if (check_1.ValueCheck.Check(schema, references, value))
-            return clone_1.ValueClone.Clone(value);
-        if (!globalThis.Array.isArray(value))
-            return create_1.ValueCreate.Create(schema, references);
-        if (schema.items === undefined)
-            return [];
-        return schema.items.map((schema, index) => Visit(schema, references, value[index]));
-    }
-    function Undefined(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
-    }
-    function Union(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : UnionCastCreate.Create(schema, references, value);
-    }
-    function Uint8Array(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
-    }
-    function Unknown(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
-    }
-    function Void(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
-    }
-    function UserDefined(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
-    }
-    function Visit(schema, references, value) {
-        const references_ = IsString(schema.$id) ? [...references, schema] : references;
-        const schema_ = schema;
-        switch (schema[Types.Kind]) {
-            case 'Any':
-                return Any(schema_, references_, value);
-            case 'Array':
-                return Array(schema_, references_, value);
-            case 'BigInt':
-                return BigInt(schema_, references_, value);
-            case 'Boolean':
-                return Boolean(schema_, references_, value);
-            case 'Constructor':
-                return Constructor(schema_, references_, value);
-            case 'Date':
-                return Date(schema_, references_, value);
-            case 'Function':
-                return Function(schema_, references_, value);
-            case 'Integer':
-                return Integer(schema_, references_, value);
-            case 'Intersect':
-                return Intersect(schema_, references_, value);
-            case 'Literal':
-                return Literal(schema_, references_, value);
-            case 'Never':
-                return Never(schema_, references_, value);
-            case 'Not':
-                return Not(schema_, references_, value);
-            case 'Null':
-                return Null(schema_, references_, value);
-            case 'Number':
-                return Number(schema_, references_, value);
-            case 'Object':
-                return Object(schema_, references_, value);
-            case 'Promise':
-                return Promise(schema_, references_, value);
-            case 'Record':
-                return Record(schema_, references_, value);
-            case 'Ref':
-                return Ref(schema_, references_, value);
-            case 'String':
-                return String(schema_, references_, value);
-            case 'Symbol':
-                return Symbol(schema_, references_, value);
-            case 'TemplateLiteral':
-                return TemplateLiteral(schema_, references_, value);
-            case 'This':
-                return This(schema_, references_, value);
-            case 'Tuple':
-                return Tuple(schema_, references_, value);
-            case 'Undefined':
-                return Undefined(schema_, references_, value);
-            case 'Union':
-                return Union(schema_, references_, value);
-            case 'Uint8Array':
-                return Uint8Array(schema_, references_, value);
-            case 'Unknown':
-                return Unknown(schema_, references_, value);
-            case 'Void':
-                return Void(schema_, references_, value);
-            default:
-                if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
-                    throw new ValueCastUnknownTypeError(schema_);
-                return UserDefined(schema_, references_, value);
+            result[propertyName] = Visit(schema.additionalProperties, references, value[propertyName]);
         }
     }
-    ValueCast.Visit = Visit;
-    function Cast(schema, references, value) {
-        return Visit(schema, references, clone_1.ValueClone.Clone(value));
+    return result;
+}
+function TPromise(schema, references, value) {
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references);
+}
+function TRecord(schema, references, value) {
+    if (ValueCheck.Check(schema, references, value))
+        return ValueClone.Clone(value);
+    if (value === null || typeof value !== 'object' || Array.isArray(value) || value instanceof Date)
+        return ValueCreate.Create(schema, references);
+    const subschemaPropertyName = Object.getOwnPropertyNames(schema.patternProperties)[0];
+    const subschema = schema.patternProperties[subschemaPropertyName];
+    const result = {};
+    for (const [propKey, propValue] of Object.entries(value)) {
+        result[propKey] = Visit(subschema, references, propValue);
+    }
+    return result;
+}
+function TRef(schema, references, value) {
+    const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
+    if (index === -1)
+        throw new ValueCastDereferenceError(schema);
+    const target = references[index];
+    return Visit(target, references, value);
+}
+function TString(schema, references, value) {
+    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references);
+}
+function TSymbol(schema, references, value) {
+    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references);
+}
+function TTemplateLiteral(schema, references, value) {
+    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references);
+}
+function TThis(schema, references, value) {
+    const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
+    if (index === -1)
+        throw new ValueCastDereferenceError(schema);
+    const target = references[index];
+    return Visit(target, references, value);
+}
+function TTuple(schema, references, value) {
+    if (ValueCheck.Check(schema, references, value))
+        return ValueClone.Clone(value);
+    if (!ValueGuard.IsArray(value))
+        return ValueCreate.Create(schema, references);
+    if (schema.items === undefined)
+        return [];
+    return schema.items.map((schema, index) => Visit(schema, references, value[index]));
+}
+function TUndefined(schema, references, value) {
+    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references);
+}
+function TUnion(schema, references, value) {
+    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : UnionCastCreate.Create(schema, references, value);
+}
+function TUint8Array(schema, references, value) {
+    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references);
+}
+function TUnknown(schema, references, value) {
+    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references);
+}
+function TVoid(schema, references, value) {
+    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references);
+}
+function TKind(schema, references, value) {
+    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references);
+}
+function Visit(schema, references, value) {
+    const references_ = ValueGuard.IsString(schema.$id) ? [...references, schema] : references;
+    const schema_ = schema;
+    switch (schema[Types.Kind]) {
+        case 'Any':
+            return TAny(schema_, references_, value);
+        case 'Array':
+            return TArray(schema_, references_, value);
+        case 'AsyncIterator':
+            return TAsyncIterator(schema_, references_, value);
+        case 'BigInt':
+            return TBigInt(schema_, references_, value);
+        case 'Boolean':
+            return TBoolean(schema_, references_, value);
+        case 'Constructor':
+            return TConstructor(schema_, references_, value);
+        case 'Date':
+            return TDate(schema_, references_, value);
+        case 'Function':
+            return TFunction(schema_, references_, value);
+        case 'Integer':
+            return TInteger(schema_, references_, value);
+        case 'Intersect':
+            return TIntersect(schema_, references_, value);
+        case 'Iterator':
+            return TIterator(schema_, references_, value);
+        case 'Literal':
+            return TLiteral(schema_, references_, value);
+        case 'Never':
+            return TNever(schema_, references_, value);
+        case 'Not':
+            return TNot(schema_, references_, value);
+        case 'Null':
+            return TNull(schema_, references_, value);
+        case 'Number':
+            return TNumber(schema_, references_, value);
+        case 'Object':
+            return TObject(schema_, references_, value);
+        case 'Promise':
+            return TPromise(schema_, references_, value);
+        case 'Record':
+            return TRecord(schema_, references_, value);
+        case 'Ref':
+            return TRef(schema_, references_, value);
+        case 'String':
+            return TString(schema_, references_, value);
+        case 'Symbol':
+            return TSymbol(schema_, references_, value);
+        case 'TemplateLiteral':
+            return TTemplateLiteral(schema_, references_, value);
+        case 'This':
+            return TThis(schema_, references_, value);
+        case 'Tuple':
+            return TTuple(schema_, references_, value);
+        case 'Undefined':
+            return TUndefined(schema_, references_, value);
+        case 'Union':
+            return TUnion(schema_, references_, value);
+        case 'Uint8Array':
+            return TUint8Array(schema_, references_, value);
+        case 'Unknown':
+            return TUnknown(schema_, references_, value);
+        case 'Void':
+            return TVoid(schema_, references_, value);
+        default:
+            if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
+                throw new ValueCastUnknownTypeError(schema_);
+            return TKind(schema_, references_, value);
     }
-    ValueCast.Cast = Cast;
-})(ValueCast || (exports.ValueCast = ValueCast = {}));
+}
+exports.Visit = Visit;
+/** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
+function Cast(...args) {
+    return args.length === 3 ? Visit(args[0], args[1], args[2]) : Visit(args[0], [], args[1]);
+}
+exports.Cast = Cast;

package/value/check.d.ts

@@ -7,6 +7,7 @@ export declare class ValueCheckDereferenceError extends Error {
     readonly schema: Types.TRef | Types.TThis;
     constructor(schema: Types.TRef | Types.TThis);
 }
-export declare namespace ValueCheck {
-    function Check<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): boolean;
-}
+/** Returns true if the value matches the given type. */
+export declare function Check<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): value is Types.Static<T>;
+/** Returns true if the value matches the given type. */
+export declare function Check<T extends Types.TSchema>(schema: T, value: unknown): value is Types.Static<T>;