@sinclair/typebox 0.31.28 → 0.32.0-dev-1

package/value/{cast.js → cast/cast.js}

@@ -27,17 +27,17 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Cast = exports.Default = exports.DefaultClone = exports.ValueCastUnknownTypeError = exports.ValueCastRecursiveTypeError = exports.ValueCastNeverTypeError = exports.ValueCastArrayUniqueItemsTypeError = void 0;
-const guard_1 = require("./guard");
-const create_1 = require("./create");
-const check_1 = require("./check");
-const clone_1 = require("./clone");
-const deref_1 = require("./deref");
-const Types = require("../typebox");
-// --------------------------------------------------------------------------
+exports.Cast = exports.ValueCastUnknownTypeError = exports.ValueCastRecursiveTypeError = exports.ValueCastNeverTypeError = exports.ValueCastArrayUniqueItemsTypeError = void 0;
+const index_1 = require("../guard/index");
+const index_2 = require("../../type/symbols/index");
+const index_3 = require("../create/index");
+const index_4 = require("../check/index");
+const index_5 = require("../clone/index");
+const index_6 = require("../deref/index");
+// ------------------------------------------------------------------
 // Errors
-// --------------------------------------------------------------------------
-class ValueCastArrayUniqueItemsTypeError extends Types.TypeBoxError {
+// ------------------------------------------------------------------
+class ValueCastArrayUniqueItemsTypeError extends Error {
     constructor(schema, value) {
         super('Array cast produced invalid data due to uniqueItems constraint');
         this.schema = schema;
@@ -45,51 +45,52 @@ class ValueCastArrayUniqueItemsTypeError extends Types.TypeBoxError {
     }
 }
 exports.ValueCastArrayUniqueItemsTypeError = ValueCastArrayUniqueItemsTypeError;
-class ValueCastNeverTypeError extends Types.TypeBoxError {
+class ValueCastNeverTypeError extends Error {
     constructor(schema) {
         super('Never types cannot be cast');
         this.schema = schema;
     }
 }
 exports.ValueCastNeverTypeError = ValueCastNeverTypeError;
-class ValueCastRecursiveTypeError extends Types.TypeBoxError {
+class ValueCastRecursiveTypeError extends Error {
     constructor(schema) {
         super('Cannot cast recursive schemas');
         this.schema = schema;
     }
 }
 exports.ValueCastRecursiveTypeError = ValueCastRecursiveTypeError;
-class ValueCastUnknownTypeError extends Types.TypeBoxError {
+class ValueCastUnknownTypeError extends Error {
     constructor(schema) {
         super('Unknown type');
         this.schema = schema;
     }
 }
 exports.ValueCastUnknownTypeError = ValueCastUnknownTypeError;
-// --------------------------------------------------------------------------
-// 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' && !(0, guard_1.IsNull)(value)) {
+        if (schema[index_2.Kind] === 'Object' && typeof value === 'object' && !(0, index_1.IsNull)(value)) {
             const object = schema;
             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 = (0, check_1.Check)(schema, references, value[key]) ? point : 0;
+                const literal = schema[index_2.Kind] === 'Literal' && schema.const === value[key] ? max : 0;
+                const checks = (0, index_4.Check)(schema, references, value[key]) ? point : 0;
                 const exists = keys.includes(key) ? point : 0;
                 return acc + (literal + checks + exists);
             }, 0);
         }
         else {
-            return (0, check_1.Check)(schema, references, value) ? 1 : 0;
+            return (0, index_4.Check)(schema, references, value) ? 1 : 0;
         }
     }
     function Select(union, references, value) {
@@ -114,37 +115,35 @@ var UnionCastCreate;
     }
     UnionCastCreate.Create = Create;
 })(UnionCastCreate || (UnionCastCreate = {}));
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Default
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function DefaultClone(schema, references, value) {
-    return (0, check_1.Check)(schema, references, value) ? (0, clone_1.Clone)(value) : (0, create_1.Create)(schema, references);
+    return (0, index_4.Check)(schema, references, value) ? (0, index_5.Clone)(value) : (0, index_3.Create)(schema, references);
 }
-exports.DefaultClone = DefaultClone;
 function Default(schema, references, value) {
-    return (0, check_1.Check)(schema, references, value) ? value : (0, create_1.Create)(schema, references);
+    return (0, index_4.Check)(schema, references, value) ? value : (0, index_3.Create)(schema, references);
 }
-exports.Default = Default;
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Cast
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function TArray(schema, references, value) {
-    if ((0, check_1.Check)(schema, references, value))
-        return (0, clone_1.Clone)(value);
-    const created = (0, guard_1.IsArray)(value) ? (0, clone_1.Clone)(value) : (0, create_1.Create)(schema, references);
-    const minimum = (0, guard_1.IsNumber)(schema.minItems) && created.length < schema.minItems ? [...created, ...Array.from({ length: schema.minItems - created.length }, () => null)] : created;
-    const maximum = (0, guard_1.IsNumber)(schema.maxItems) && minimum.length > schema.maxItems ? minimum.slice(0, schema.maxItems) : minimum;
+    if ((0, index_4.Check)(schema, references, value))
+        return (0, index_5.Clone)(value);
+    const created = (0, index_1.IsArray)(value) ? (0, index_5.Clone)(value) : (0, index_3.Create)(schema, references);
+    const minimum = (0, index_1.IsNumber)(schema.minItems) && created.length < schema.minItems ? [...created, ...Array.from({ length: schema.minItems - created.length }, () => null)] : created;
+    const maximum = (0, index_1.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 (!(0, check_1.Check)(schema, references, unique))
+    if (!(0, index_4.Check)(schema, references, unique))
         throw new ValueCastArrayUniqueItemsTypeError(schema, unique);
     return unique;
 }
 function TConstructor(schema, references, value) {
-    if ((0, check_1.Check)(schema, references, value))
-        return (0, create_1.Create)(schema, references);
+    if ((0, index_4.Check)(schema, references, value))
+        return (0, index_3.Create)(schema, references);
     const required = new Set(schema.returns.required || []);
     const result = function () { };
     for (const [key, property] of Object.entries(schema.returns.properties)) {
@@ -155,18 +154,18 @@ function TConstructor(schema, references, value) {
     return result;
 }
 function TIntersect(schema, references, value) {
-    const created = (0, create_1.Create)(schema, references);
-    const mapped = (0, guard_1.IsPlainObject)(created) && (0, guard_1.IsPlainObject)(value) ? { ...created, ...value } : value;
-    return (0, check_1.Check)(schema, references, mapped) ? mapped : (0, create_1.Create)(schema, references);
+    const created = (0, index_3.Create)(schema, references);
+    const mapped = (0, index_1.IsPlainObject)(created) && (0, index_1.IsPlainObject)(value) ? { ...created, ...value } : value;
+    return (0, index_4.Check)(schema, references, mapped) ? mapped : (0, index_3.Create)(schema, references);
 }
 function TNever(schema, references, value) {
     throw new ValueCastNeverTypeError(schema);
 }
 function TObject(schema, references, value) {
-    if ((0, check_1.Check)(schema, references, value))
+    if ((0, index_4.Check)(schema, references, value))
         return value;
     if (value === null || typeof value !== 'object')
-        return (0, create_1.Create)(schema, references);
+        return (0, index_3.Create)(schema, references);
     const required = new Set(schema.required || []);
     const result = {};
     for (const [key, property] of Object.entries(schema.properties)) {
@@ -186,10 +185,10 @@ function TObject(schema, references, value) {
     return result;
 }
 function TRecord(schema, references, value) {
-    if ((0, check_1.Check)(schema, references, value))
-        return (0, clone_1.Clone)(value);
+    if ((0, index_4.Check)(schema, references, value))
+        return (0, index_5.Clone)(value);
     if (value === null || typeof value !== 'object' || Array.isArray(value) || value instanceof Date)
-        return (0, create_1.Create)(schema, references);
+        return (0, index_3.Create)(schema, references);
     const subschemaPropertyName = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const subschema = schema.patternProperties[subschemaPropertyName];
     const result = {};
@@ -199,30 +198,30 @@ function TRecord(schema, references, value) {
     return result;
 }
 function TRef(schema, references, value) {
-    return Visit((0, deref_1.Deref)(schema, references), references, value);
+    return Visit((0, index_6.Deref)(schema, references), references, value);
 }
 function TThis(schema, references, value) {
-    return Visit((0, deref_1.Deref)(schema, references), references, value);
+    return Visit((0, index_6.Deref)(schema, references), references, value);
 }
 function TTuple(schema, references, value) {
-    if ((0, check_1.Check)(schema, references, value))
-        return (0, clone_1.Clone)(value);
-    if (!(0, guard_1.IsArray)(value))
-        return (0, create_1.Create)(schema, references);
+    if ((0, index_4.Check)(schema, references, value))
+        return (0, index_5.Clone)(value);
+    if (!(0, index_1.IsArray)(value))
+        return (0, index_3.Create)(schema, references);
     if (schema.items === undefined)
         return [];
     return schema.items.map((schema, index) => Visit(schema, references, value[index]));
 }
 function TUnion(schema, references, value) {
-    return (0, check_1.Check)(schema, references, value) ? (0, clone_1.Clone)(value) : UnionCastCreate.Create(schema, references, value);
+    return (0, index_4.Check)(schema, references, value) ? (0, index_5.Clone)(value) : UnionCastCreate.Create(schema, references, value);
 }
 function Visit(schema, references, value) {
-    const references_ = (0, guard_1.IsString)(schema.$id) ? [...references, schema] : references;
+    const references_ = (0, index_1.IsString)(schema.$id) ? [...references, schema] : references;
     const schema_ = schema;
-    switch (schema[Types.Kind]) {
-        // ------------------------------------------------------
+    switch (schema[index_2.Kind]) {
+        // --------------------------------------------------------------
         // Structural
-        // ------------------------------------------------------
+        // --------------------------------------------------------------
         case 'Array':
             return TArray(schema_, references_, value);
         case 'Constructor':
@@ -243,37 +242,17 @@ function Visit(schema, references, value) {
             return TTuple(schema_, references_, value);
         case 'Union':
             return TUnion(schema_, references_, value);
-        // ------------------------------------------------------
+        // --------------------------------------------------------------
         // DefaultClone
-        // ------------------------------------------------------
+        // --------------------------------------------------------------
         case 'Date':
         case 'Symbol':
         case 'Uint8Array':
             return DefaultClone(schema, references, value);
-        // ------------------------------------------------------
+        // --------------------------------------------------------------
         // Default
-        // ------------------------------------------------------
-        case 'Any':
-        case 'AsyncIterator':
-        case 'BigInt':
-        case 'Boolean':
-        case 'Function':
-        case 'Integer':
-        case 'Iterator':
-        case 'Literal':
-        case 'Not':
-        case 'Null':
-        case 'Number':
-        case 'Promise':
-        case 'String':
-        case 'TemplateLiteral':
-        case 'Undefined':
-        case 'Unknown':
-        case 'Void':
-            return Default(schema_, references_, value);
+        // --------------------------------------------------------------
         default:
-            if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
-                throw new ValueCastUnknownTypeError(schema_);
             return Default(schema_, references_, value);
     }
 }

package/value/cast/index.d.ts

@@ -0,0 +1 @@
+export * from './cast';

package/value/cast/index.js

@@ -0,0 +1,44 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cast"), exports);

package/value/check/check.d.ts

@@ -0,0 +1,10 @@
+import type { TSchema } from '../../type/schema/index';
+import type { Static } from '../../type/static/index';
+export declare class ValueCheckUnknownTypeError extends Error {
+    readonly schema: TSchema;
+    constructor(schema: TSchema);
+}
+/** Returns true if the value matches the given type. */
+export declare function Check<T extends TSchema>(schema: T, references: TSchema[], value: unknown): value is Static<T>;
+/** Returns true if the value matches the given type. */
+export declare function Check<T extends TSchema>(schema: T, value: unknown): value is Static<T>;

package/value/{check.js → check/check.js}

@@ -28,15 +28,20 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Check = exports.ValueCheckUnknownTypeError = void 0;
-const guard_1 = require("./guard");
-const index_1 = require("../system/index");
-const deref_1 = require("./deref");
-const hash_1 = require("./hash");
-const Types = require("../typebox");
+const index_1 = require("../guard/index");
+const index_2 = require("../../system/index");
+const index_3 = require("../deref/index");
+const index_4 = require("../hash/index");
+const index_5 = require("../../type/symbols/index");
+const index_6 = require("../../type/keyof/index");
+const index_7 = require("../../type/extends/index");
+const type_1 = require("../../type/guard/type");
+const index_8 = require("../../type/registry/index");
+const index_9 = require("../../type/never/index");
 // --------------------------------------------------------------------------
 // Errors
 // --------------------------------------------------------------------------
-class ValueCheckUnknownTypeError extends Types.TypeBoxError {
+class ValueCheckUnknownTypeError extends Error {
     constructor(schema) {
         super(`Unknown type`);
         this.schema = schema;
@@ -47,7 +52,7 @@ exports.ValueCheckUnknownTypeError = ValueCheckUnknownTypeError;
 // TypeGuards
 // --------------------------------------------------------------------------
 function IsAnyOrUnknown(schema) {
-    return schema[Types.Kind] === 'Any' || schema[Types.Kind] === 'Unknown';
+    return schema[index_5.Kind] === 'Any' || schema[index_5.Kind] === 'Unknown';
 }
 // --------------------------------------------------------------------------
 // Guards
@@ -62,7 +67,7 @@ function TAny(schema, references, value) {
     return true;
 }
 function TArray(schema, references, value) {
-    if (!(0, guard_1.IsArray)(value))
+    if (!(0, index_1.IsArray)(value))
         return false;
     if (IsDefined(schema.minItems) && !(value.length >= schema.minItems)) {
         return false;
@@ -75,7 +80,7 @@ function TArray(schema, references, value) {
     }
     // prettier-ignore
     if (schema.uniqueItems === true && !((function () { const set = new Set(); for (const element of value) {
-        const hashed = (0, hash_1.Hash)(element);
+        const hashed = (0, index_4.Hash)(element);
         if (set.has(hashed)) {
             return false;
         }
@@ -86,27 +91,27 @@ function TArray(schema, references, value) {
         return false;
     }
     // contains
-    if (!(IsDefined(schema.contains) || (0, guard_1.IsNumber)(schema.minContains) || (0, guard_1.IsNumber)(schema.maxContains))) {
+    if (!(IsDefined(schema.contains) || (0, index_1.IsNumber)(schema.minContains) || (0, index_1.IsNumber)(schema.maxContains))) {
         return true; // exit
     }
-    const containsSchema = IsDefined(schema.contains) ? schema.contains : Types.Type.Never();
+    const containsSchema = IsDefined(schema.contains) ? schema.contains : (0, index_9.Never)();
     const containsCount = value.reduce((acc, value) => (Visit(containsSchema, references, value) ? acc + 1 : acc), 0);
     if (containsCount === 0) {
         return false;
     }
-    if ((0, guard_1.IsNumber)(schema.minContains) && containsCount < schema.minContains) {
+    if ((0, index_1.IsNumber)(schema.minContains) && containsCount < schema.minContains) {
         return false;
     }
-    if ((0, guard_1.IsNumber)(schema.maxContains) && containsCount > schema.maxContains) {
+    if ((0, index_1.IsNumber)(schema.maxContains) && containsCount > schema.maxContains) {
         return false;
     }
     return true;
 }
 function TAsyncIterator(schema, references, value) {
-    return (0, guard_1.IsAsyncIterator)(value);
+    return (0, index_1.IsAsyncIterator)(value);
 }
 function TBigInt(schema, references, value) {
-    if (!(0, guard_1.IsBigInt)(value))
+    if (!(0, index_1.IsBigInt)(value))
         return false;
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
         return false;
@@ -126,13 +131,13 @@ function TBigInt(schema, references, value) {
     return true;
 }
 function TBoolean(schema, references, value) {
-    return (0, guard_1.IsBoolean)(value);
+    return (0, index_1.IsBoolean)(value);
 }
 function TConstructor(schema, references, value) {
     return Visit(schema.returns, references, value.prototype);
 }
 function TDate(schema, references, value) {
-    if (!(0, guard_1.IsDate)(value))
+    if (!(0, index_1.IsDate)(value))
         return false;
     if (IsDefined(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
         return false;
@@ -152,10 +157,10 @@ function TDate(schema, references, value) {
     return true;
 }
 function TFunction(schema, references, value) {
-    return (0, guard_1.IsFunction)(value);
+    return (0, index_1.IsFunction)(value);
 }
 function TInteger(schema, references, value) {
-    if (!(0, guard_1.IsInteger)(value)) {
+    if (!(0, index_1.IsInteger)(value)) {
         return false;
     }
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
@@ -178,12 +183,12 @@ function TInteger(schema, references, value) {
 function TIntersect(schema, references, value) {
     const check1 = schema.allOf.every((schema) => Visit(schema, references, value));
     if (schema.unevaluatedProperties === false) {
-        const keyPattern = new RegExp(Types.KeyResolver.ResolvePattern(schema));
+        const keyPattern = new RegExp((0, index_6.KeyOfStringResolvePattern)(schema));
         const check2 = Object.getOwnPropertyNames(value).every((key) => keyPattern.test(key));
         return check1 && check2;
     }
-    else if (Types.TypeGuard.TSchema(schema.unevaluatedProperties)) {
-        const keyCheck = new RegExp(Types.KeyResolver.ResolvePattern(schema));
+    else if ((0, type_1.TSchema)(schema.unevaluatedProperties)) {
+        const keyCheck = new RegExp((0, index_6.KeyOfStringResolvePattern)(schema));
         const check2 = Object.getOwnPropertyNames(value).every((key) => keyCheck.test(key) || Visit(schema.unevaluatedProperties, references, value[key]));
         return check1 && check2;
     }
@@ -192,7 +197,7 @@ function TIntersect(schema, references, value) {
     }
 }
 function TIterator(schema, references, value) {
-    return (0, guard_1.IsIterator)(value);
+    return (0, index_1.IsIterator)(value);
 }
 function TLiteral(schema, references, value) {
     return value === schema.const;
@@ -204,10 +209,10 @@ function TNot(schema, references, value) {
     return !Visit(schema.not, references, value);
 }
 function TNull(schema, references, value) {
-    return (0, guard_1.IsNull)(value);
+    return (0, index_1.IsNull)(value);
 }
 function TNumber(schema, references, value) {
-    if (!index_1.TypeSystemPolicy.IsNumberLike(value))
+    if (!index_2.TypeSystemPolicy.IsNumberLike(value))
         return false;
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
         return false;
@@ -227,7 +232,7 @@ function TNumber(schema, references, value) {
     return true;
 }
 function TObject(schema, references, value) {
-    if (!index_1.TypeSystemPolicy.IsObjectLike(value))
+    if (!index_2.TypeSystemPolicy.IsObjectLike(value))
         return false;
     if (IsDefined(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
         return false;
@@ -242,12 +247,12 @@ function TObject(schema, references, value) {
             if (!Visit(property, references, value[knownKey])) {
                 return false;
             }
-            if ((Types.ExtendsUndefined.Check(property) || IsAnyOrUnknown(property)) && !(knownKey in value)) {
+            if (((0, index_7.ExtendsUndefinedCheck)(property) || IsAnyOrUnknown(property)) && !(knownKey in value)) {
                 return false;
             }
         }
         else {
-            if (index_1.TypeSystemPolicy.IsExactOptionalProperty(value, knownKey) && !Visit(property, references, value[knownKey])) {
+            if (index_2.TypeSystemPolicy.IsExactOptionalProperty(value, knownKey) && !Visit(property, references, value[knownKey])) {
                 return false;
             }
         }
@@ -271,10 +276,10 @@ function TObject(schema, references, value) {
     }
 }
 function TPromise(schema, references, value) {
-    return (0, guard_1.IsPromise)(value);
+    return (0, index_1.IsPromise)(value);
 }
 function TRecord(schema, references, value) {
-    if (!index_1.TypeSystemPolicy.IsRecordLike(value)) {
+    if (!index_2.TypeSystemPolicy.IsRecordLike(value)) {
         return false;
     }
     if (IsDefined(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
@@ -301,10 +306,10 @@ function TRecord(schema, references, value) {
     return check1 && check2 && check3;
 }
 function TRef(schema, references, value) {
-    return Visit((0, deref_1.Deref)(schema, references), references, value);
+    return Visit((0, index_3.Deref)(schema, references), references, value);
 }
 function TString(schema, references, value) {
-    if (!(0, guard_1.IsString)(value)) {
+    if (!(0, index_1.IsString)(value)) {
         return false;
     }
     if (IsDefined(schema.minLength)) {
@@ -321,24 +326,24 @@ function TString(schema, references, value) {
             return false;
     }
     if (IsDefined(schema.format)) {
-        if (!Types.FormatRegistry.Has(schema.format))
+        if (!index_8.FormatRegistry.Has(schema.format))
             return false;
-        const func = Types.FormatRegistry.Get(schema.format);
+        const func = index_8.FormatRegistry.Get(schema.format);
         return func(value);
     }
     return true;
 }
 function TSymbol(schema, references, value) {
-    return (0, guard_1.IsSymbol)(value);
+    return (0, index_1.IsSymbol)(value);
 }
 function TTemplateLiteral(schema, references, value) {
-    return (0, guard_1.IsString)(value) && new RegExp(schema.pattern).test(value);
+    return (0, index_1.IsString)(value) && new RegExp(schema.pattern).test(value);
 }
 function TThis(schema, references, value) {
-    return Visit((0, deref_1.Deref)(schema, references), references, value);
+    return Visit((0, index_3.Deref)(schema, references), references, value);
 }
 function TTuple(schema, references, value) {
-    if (!(0, guard_1.IsArray)(value)) {
+    if (!(0, index_1.IsArray)(value)) {
         return false;
     }
     if (schema.items === undefined && !(value.length === 0)) {
@@ -357,13 +362,13 @@ function TTuple(schema, references, value) {
     return true;
 }
 function TUndefined(schema, references, value) {
-    return (0, guard_1.IsUndefined)(value);
+    return (0, index_1.IsUndefined)(value);
 }
 function TUnion(schema, references, value) {
     return schema.anyOf.some((inner) => Visit(inner, references, value));
 }
 function TUint8Array(schema, references, value) {
-    if (!(0, guard_1.IsUint8Array)(value)) {
+    if (!(0, index_1.IsUint8Array)(value)) {
         return false;
     }
     if (IsDefined(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
@@ -378,18 +383,18 @@ function TUnknown(schema, references, value) {
     return true;
 }
 function TVoid(schema, references, value) {
-    return index_1.TypeSystemPolicy.IsVoidLike(value);
+    return index_2.TypeSystemPolicy.IsVoidLike(value);
 }
 function TKind(schema, references, value) {
-    if (!Types.TypeRegistry.Has(schema[Types.Kind]))
+    if (!index_8.TypeRegistry.Has(schema[index_5.Kind]))
         return false;
-    const func = Types.TypeRegistry.Get(schema[Types.Kind]);
+    const func = index_8.TypeRegistry.Get(schema[index_5.Kind]);
     return func(schema, value);
 }
 function Visit(schema, references, value) {
     const references_ = IsDefined(schema.$id) ? [...references, schema] : references;
     const schema_ = schema;
-    switch (schema_[Types.Kind]) {
+    switch (schema_[index_5.Kind]) {
         case 'Any':
             return TAny(schema_, references_, value);
         case 'Array':
@@ -451,7 +456,7 @@ function Visit(schema, references, value) {
         case 'Void':
             return TVoid(schema_, references_, value);
         default:
-            if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
+            if (!index_8.TypeRegistry.Has(schema_[index_5.Kind]))
                 throw new ValueCheckUnknownTypeError(schema_);
             return TKind(schema_, references_, value);
     }

package/value/check/index.d.ts

@@ -0,0 +1 @@
+export * from './check';

package/value/check/index.js

@@ -0,0 +1,44 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./check"), exports);