@sinclair/typebox 0.32.0-dev-2 → 0.32.0-dev-4

package/index.d.ts

@@ -0,0 +1,71 @@
+export { Kind, Hint, ReadonlyKind, OptionalKind, TransformKind } from './type/symbols/index';
+export { PatternBoolean, PatternBooleanExact, PatternNumber, PatternNumberExact, PatternString, PatternStringExact } from './type/patterns/index';
+export { TypeRegistry, FormatRegistry } from './type/registry/index';
+export { TypeGuard, ValueGuard } from './type/guard/index';
+export { CloneType, CloneRest } from './type/clone/type';
+export { Clone } from './type/clone/value';
+export { Any, type TAny } from './type/any/index';
+export { Array, type TArray, type ArrayOptions } from './type/array/index';
+export { AsyncIterator, type TAsyncIterator } from './type/async-iterator/index';
+export { Awaited, type TAwaited } from './type/awaited/index';
+export { BigInt, type TBigInt, BigIntOptions } from './type/bigint/index';
+export { Boolean, type TBoolean } from './type/boolean/index';
+export { Composite, type TComposite } from './type/composite/index';
+export { Const, type TConst } from './type/const/index';
+export { Constructor, type TConstructor } from './type/constructor/index';
+export { ConstructorParameters, type TConstructorParameters } from './type/constructor-parameters/index';
+export { Date, type TDate, type DateOptions } from './type/date/index';
+export { Deref, type TDeref } from './type/deref/index';
+export { Enum, type TEnum } from './type/enum/index';
+export { Exclude, type TExclude } from './type/exclude/index';
+export { Extends, type TExtends, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck } from './type/extends/index';
+export { Extract, type TExtract } from './type/extract/index';
+export { Function, type TFunction } from './type/function/index';
+export { Increment, type Assert, type AssertType, type AssertRest, type AssertProperties, type Ensure, type Evaluate, type TupleToIntersect, type TupleToUnion, type UnionToTuple } from './type/helpers/index';
+export { Index, type TIndex, IndexedKeyResolve, IndexedTypeResolve } from './type/indexed/index';
+export { InstanceType, type TInstanceType } from './type/instance-type/index';
+export { Integer, type TInteger, type IntegerOptions } from './type/integer/index';
+export { Intersect, type TIntersect, type IntersectOptions } from './type/intersect/index';
+export { Iterator, type TIterator } from './type/iterator/index';
+export { Capitalize, type TCapitalize, Lowercase, type TLowercase, Uncapitalize, type TUncapitalize, Uppercase, type TUppercase, IntrinsicResolve } from './type/intrinsic/index';
+export { KeyOf, type TKeyOf, KeyOfStringResolve, KeyOfStringResolvePattern, KeyOfTypeResolve } from './type/keyof/index';
+export { Literal, type TLiteral } from './type/literal/index';
+export { Mapped, type TMappedKey, type MappedFunction, type TMappedResult } from './type/mapped/index';
+export { Never, type TNever } from './type/never/index';
+export { Not, type TNot } from './type/not/index';
+export { Null, type TNull } from './type/null/index';
+export { Number, type TNumber, type NumberOptions } from './type/number/index';
+export { Object, type TObject, type TProperties, type ObjectOptions } from './type/object/index';
+export { Omit, type TOmit } from './type/omit/index';
+export { Optional, type TOptional } from './type/optional/index';
+export { Parameters, type TParameters } from './type/parameters/index';
+export { Partial, type TPartial } from './type/partial/index';
+export { Pick, type TPick } from './type/pick/index';
+export { Promise, type TPromise } from './type/promise/index';
+export { Readonly, type TReadonly } from './type/readonly/index';
+export { ReadonlyOptional, type TReadonlyOptional } from './type/readonly-optional/index';
+export { Record, type TRecord } from './type/record/index';
+export { Recursive, type TRecursive, type TThis } from './type/recursive/index';
+export { Ref, type TRef } from './type/ref/index';
+export { RegExp, type TRegExp } from './type/regexp/index';
+export { Required, type TRequired } from './type/required/index';
+export { Rest, type TRest } from './type/rest/index';
+export { ReturnType, type TReturnType } from './type/return-type/index';
+export { type TSchema, type TKind, type SchemaOptions, type TAnySchema } from './type/schema/index';
+export { type Static, type StaticDecode, type StaticEncode } from './type/static/index';
+export { Strict } from './type/strict/index';
+export { String, type TString, type StringOptions, type StringFormatOption, type StringContentEncodingOption } from './type/string/index';
+export { Symbol, type TSymbol, type SymbolValue } from './type/symbol/index';
+export { TemplateLiteral, IsTemplateLiteralFinite, TemplateLiteralParse, TemplateLiteralParseExact, TemplateLiteralGenerate, type TTemplateLiteral, type TTemplateLiteralKind } from './type/template-literal/index';
+export { Transform, type TTransform, type TransformOptions, type TransformFunction, TransformDecodeBuilder, TransformEncodeBuilder } from './type/transform/index';
+export { Tuple, type TTuple } from './type/tuple/index';
+export { Uint8Array, type TUint8Array, type Uint8ArrayOptions } from './type/uint8array/index';
+export { Undefined, type TUndefined } from './type/undefined/index';
+export { Union, type TUnion } from './type/union/index';
+export { Unknown, type TUnknown } from './type/unknown/index';
+export { Unsafe, type TUnsafe } from './type/unsafe/index';
+export { Void, type TVoid } from './type/void/index';
+export { JsonTypeBuilder, JavaScriptTypeBuilder } from './type/type/index';
+import { Type } from './type/type/index';
+export { Type };
+export default Type;

package/index.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Uppercase = exports.Uncapitalize = exports.Lowercase = exports.Capitalize = exports.Iterator = exports.Intersect = exports.Integer = exports.InstanceType = exports.IndexedTypeResolve = exports.IndexedKeyResolve = exports.Index = exports.Increment = exports.Function = exports.Extract = exports.ExtendsUndefinedCheck = exports.ExtendsResult = exports.ExtendsCheck = exports.Extends = exports.Exclude = exports.Enum = exports.Deref = exports.Date = exports.ConstructorParameters = exports.Constructor = exports.Const = exports.Composite = exports.Boolean = exports.BigInt = exports.Awaited = exports.AsyncIterator = exports.Array = exports.Any = exports.Clone = exports.CloneRest = exports.CloneType = exports.ValueGuard = exports.TypeGuard = exports.FormatRegistry = exports.TypeRegistry = exports.PatternStringExact = exports.PatternString = exports.PatternNumberExact = exports.PatternNumber = exports.PatternBooleanExact = exports.PatternBoolean = exports.TransformKind = exports.OptionalKind = exports.ReadonlyKind = exports.Hint = exports.Kind = void 0;
+exports.Type = exports.JavaScriptTypeBuilder = exports.JsonTypeBuilder = exports.Void = exports.Unsafe = exports.Unknown = exports.Union = exports.Undefined = exports.Uint8Array = exports.Tuple = exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = exports.Transform = exports.TemplateLiteralGenerate = exports.TemplateLiteralParseExact = exports.TemplateLiteralParse = exports.IsTemplateLiteralFinite = exports.TemplateLiteral = exports.Symbol = exports.String = exports.Strict = exports.ReturnType = exports.Rest = exports.Required = exports.RegExp = exports.Ref = exports.Recursive = exports.Record = exports.ReadonlyOptional = exports.Readonly = exports.Promise = exports.Pick = exports.Partial = exports.Parameters = exports.Optional = exports.Omit = exports.Object = exports.Number = exports.Null = exports.Not = exports.Never = exports.Mapped = exports.Literal = exports.KeyOfTypeResolve = exports.KeyOfStringResolvePattern = exports.KeyOfStringResolve = exports.KeyOf = exports.IntrinsicResolve = void 0;
+var index_1 = require("./type/symbols/index");
+Object.defineProperty(exports, "Kind", { enumerable: true, get: function () { return index_1.Kind; } });
+Object.defineProperty(exports, "Hint", { enumerable: true, get: function () { return index_1.Hint; } });
+Object.defineProperty(exports, "ReadonlyKind", { enumerable: true, get: function () { return index_1.ReadonlyKind; } });
+Object.defineProperty(exports, "OptionalKind", { enumerable: true, get: function () { return index_1.OptionalKind; } });
+Object.defineProperty(exports, "TransformKind", { enumerable: true, get: function () { return index_1.TransformKind; } });
+var index_2 = require("./type/patterns/index");
+Object.defineProperty(exports, "PatternBoolean", { enumerable: true, get: function () { return index_2.PatternBoolean; } });
+Object.defineProperty(exports, "PatternBooleanExact", { enumerable: true, get: function () { return index_2.PatternBooleanExact; } });
+Object.defineProperty(exports, "PatternNumber", { enumerable: true, get: function () { return index_2.PatternNumber; } });
+Object.defineProperty(exports, "PatternNumberExact", { enumerable: true, get: function () { return index_2.PatternNumberExact; } });
+Object.defineProperty(exports, "PatternString", { enumerable: true, get: function () { return index_2.PatternString; } });
+Object.defineProperty(exports, "PatternStringExact", { enumerable: true, get: function () { return index_2.PatternStringExact; } });
+var index_3 = require("./type/registry/index");
+Object.defineProperty(exports, "TypeRegistry", { enumerable: true, get: function () { return index_3.TypeRegistry; } });
+Object.defineProperty(exports, "FormatRegistry", { enumerable: true, get: function () { return index_3.FormatRegistry; } });
+var index_4 = require("./type/guard/index");
+Object.defineProperty(exports, "TypeGuard", { enumerable: true, get: function () { return index_4.TypeGuard; } });
+Object.defineProperty(exports, "ValueGuard", { enumerable: true, get: function () { return index_4.ValueGuard; } });
+var type_1 = require("./type/clone/type");
+Object.defineProperty(exports, "CloneType", { enumerable: true, get: function () { return type_1.CloneType; } });
+Object.defineProperty(exports, "CloneRest", { enumerable: true, get: function () { return type_1.CloneRest; } });
+var value_1 = require("./type/clone/value");
+Object.defineProperty(exports, "Clone", { enumerable: true, get: function () { return value_1.Clone; } });
+var index_5 = require("./type/any/index");
+Object.defineProperty(exports, "Any", { enumerable: true, get: function () { return index_5.Any; } });
+var index_6 = require("./type/array/index");
+Object.defineProperty(exports, "Array", { enumerable: true, get: function () { return index_6.Array; } });
+var index_7 = require("./type/async-iterator/index");
+Object.defineProperty(exports, "AsyncIterator", { enumerable: true, get: function () { return index_7.AsyncIterator; } });
+var index_8 = require("./type/awaited/index");
+Object.defineProperty(exports, "Awaited", { enumerable: true, get: function () { return index_8.Awaited; } });
+var index_9 = require("./type/bigint/index");
+Object.defineProperty(exports, "BigInt", { enumerable: true, get: function () { return index_9.BigInt; } });
+var index_10 = require("./type/boolean/index");
+Object.defineProperty(exports, "Boolean", { enumerable: true, get: function () { return index_10.Boolean; } });
+var index_11 = require("./type/composite/index");
+Object.defineProperty(exports, "Composite", { enumerable: true, get: function () { return index_11.Composite; } });
+var index_12 = require("./type/const/index");
+Object.defineProperty(exports, "Const", { enumerable: true, get: function () { return index_12.Const; } });
+var index_13 = require("./type/constructor/index");
+Object.defineProperty(exports, "Constructor", { enumerable: true, get: function () { return index_13.Constructor; } });
+var index_14 = require("./type/constructor-parameters/index");
+Object.defineProperty(exports, "ConstructorParameters", { enumerable: true, get: function () { return index_14.ConstructorParameters; } });
+var index_15 = require("./type/date/index");
+Object.defineProperty(exports, "Date", { enumerable: true, get: function () { return index_15.Date; } });
+var index_16 = require("./type/deref/index");
+Object.defineProperty(exports, "Deref", { enumerable: true, get: function () { return index_16.Deref; } });
+var index_17 = require("./type/enum/index");
+Object.defineProperty(exports, "Enum", { enumerable: true, get: function () { return index_17.Enum; } });
+var index_18 = require("./type/exclude/index");
+Object.defineProperty(exports, "Exclude", { enumerable: true, get: function () { return index_18.Exclude; } });
+var index_19 = require("./type/extends/index");
+Object.defineProperty(exports, "Extends", { enumerable: true, get: function () { return index_19.Extends; } });
+Object.defineProperty(exports, "ExtendsCheck", { enumerable: true, get: function () { return index_19.ExtendsCheck; } });
+Object.defineProperty(exports, "ExtendsResult", { enumerable: true, get: function () { return index_19.ExtendsResult; } });
+Object.defineProperty(exports, "ExtendsUndefinedCheck", { enumerable: true, get: function () { return index_19.ExtendsUndefinedCheck; } });
+var index_20 = require("./type/extract/index");
+Object.defineProperty(exports, "Extract", { enumerable: true, get: function () { return index_20.Extract; } });
+var index_21 = require("./type/function/index");
+Object.defineProperty(exports, "Function", { enumerable: true, get: function () { return index_21.Function; } });
+var index_22 = require("./type/helpers/index");
+Object.defineProperty(exports, "Increment", { enumerable: true, get: function () { return index_22.Increment; } });
+var index_23 = require("./type/indexed/index");
+Object.defineProperty(exports, "Index", { enumerable: true, get: function () { return index_23.Index; } });
+Object.defineProperty(exports, "IndexedKeyResolve", { enumerable: true, get: function () { return index_23.IndexedKeyResolve; } });
+Object.defineProperty(exports, "IndexedTypeResolve", { enumerable: true, get: function () { return index_23.IndexedTypeResolve; } });
+var index_24 = require("./type/instance-type/index");
+Object.defineProperty(exports, "InstanceType", { enumerable: true, get: function () { return index_24.InstanceType; } });
+var index_25 = require("./type/integer/index");
+Object.defineProperty(exports, "Integer", { enumerable: true, get: function () { return index_25.Integer; } });
+var index_26 = require("./type/intersect/index");
+Object.defineProperty(exports, "Intersect", { enumerable: true, get: function () { return index_26.Intersect; } });
+var index_27 = require("./type/iterator/index");
+Object.defineProperty(exports, "Iterator", { enumerable: true, get: function () { return index_27.Iterator; } });
+var index_28 = require("./type/intrinsic/index");
+Object.defineProperty(exports, "Capitalize", { enumerable: true, get: function () { return index_28.Capitalize; } });
+Object.defineProperty(exports, "Lowercase", { enumerable: true, get: function () { return index_28.Lowercase; } });
+Object.defineProperty(exports, "Uncapitalize", { enumerable: true, get: function () { return index_28.Uncapitalize; } });
+Object.defineProperty(exports, "Uppercase", { enumerable: true, get: function () { return index_28.Uppercase; } });
+Object.defineProperty(exports, "IntrinsicResolve", { enumerable: true, get: function () { return index_28.IntrinsicResolve; } });
+var index_29 = require("./type/keyof/index");
+Object.defineProperty(exports, "KeyOf", { enumerable: true, get: function () { return index_29.KeyOf; } });
+Object.defineProperty(exports, "KeyOfStringResolve", { enumerable: true, get: function () { return index_29.KeyOfStringResolve; } });
+Object.defineProperty(exports, "KeyOfStringResolvePattern", { enumerable: true, get: function () { return index_29.KeyOfStringResolvePattern; } });
+Object.defineProperty(exports, "KeyOfTypeResolve", { enumerable: true, get: function () { return index_29.KeyOfTypeResolve; } });
+var index_30 = require("./type/literal/index");
+Object.defineProperty(exports, "Literal", { enumerable: true, get: function () { return index_30.Literal; } });
+var index_31 = require("./type/mapped/index");
+Object.defineProperty(exports, "Mapped", { enumerable: true, get: function () { return index_31.Mapped; } });
+var index_32 = require("./type/never/index");
+Object.defineProperty(exports, "Never", { enumerable: true, get: function () { return index_32.Never; } });
+var index_33 = require("./type/not/index");
+Object.defineProperty(exports, "Not", { enumerable: true, get: function () { return index_33.Not; } });
+var index_34 = require("./type/null/index");
+Object.defineProperty(exports, "Null", { enumerable: true, get: function () { return index_34.Null; } });
+var index_35 = require("./type/number/index");
+Object.defineProperty(exports, "Number", { enumerable: true, get: function () { return index_35.Number; } });
+var index_36 = require("./type/object/index");
+Object.defineProperty(exports, "Object", { enumerable: true, get: function () { return index_36.Object; } });
+var index_37 = require("./type/omit/index");
+Object.defineProperty(exports, "Omit", { enumerable: true, get: function () { return index_37.Omit; } });
+var index_38 = require("./type/optional/index");
+Object.defineProperty(exports, "Optional", { enumerable: true, get: function () { return index_38.Optional; } });
+var index_39 = require("./type/parameters/index");
+Object.defineProperty(exports, "Parameters", { enumerable: true, get: function () { return index_39.Parameters; } });
+var index_40 = require("./type/partial/index");
+Object.defineProperty(exports, "Partial", { enumerable: true, get: function () { return index_40.Partial; } });
+var index_41 = require("./type/pick/index");
+Object.defineProperty(exports, "Pick", { enumerable: true, get: function () { return index_41.Pick; } });
+var index_42 = require("./type/promise/index");
+Object.defineProperty(exports, "Promise", { enumerable: true, get: function () { return index_42.Promise; } });
+var index_43 = require("./type/readonly/index");
+Object.defineProperty(exports, "Readonly", { enumerable: true, get: function () { return index_43.Readonly; } });
+var index_44 = require("./type/readonly-optional/index");
+Object.defineProperty(exports, "ReadonlyOptional", { enumerable: true, get: function () { return index_44.ReadonlyOptional; } });
+var index_45 = require("./type/record/index");
+Object.defineProperty(exports, "Record", { enumerable: true, get: function () { return index_45.Record; } });
+var index_46 = require("./type/recursive/index");
+Object.defineProperty(exports, "Recursive", { enumerable: true, get: function () { return index_46.Recursive; } });
+var index_47 = require("./type/ref/index");
+Object.defineProperty(exports, "Ref", { enumerable: true, get: function () { return index_47.Ref; } });
+var index_48 = require("./type/regexp/index");
+Object.defineProperty(exports, "RegExp", { enumerable: true, get: function () { return index_48.RegExp; } });
+var index_49 = require("./type/required/index");
+Object.defineProperty(exports, "Required", { enumerable: true, get: function () { return index_49.Required; } });
+var index_50 = require("./type/rest/index");
+Object.defineProperty(exports, "Rest", { enumerable: true, get: function () { return index_50.Rest; } });
+var index_51 = require("./type/return-type/index");
+Object.defineProperty(exports, "ReturnType", { enumerable: true, get: function () { return index_51.ReturnType; } });
+var index_52 = require("./type/strict/index");
+Object.defineProperty(exports, "Strict", { enumerable: true, get: function () { return index_52.Strict; } });
+var index_53 = require("./type/string/index");
+Object.defineProperty(exports, "String", { enumerable: true, get: function () { return index_53.String; } });
+var index_54 = require("./type/symbol/index");
+Object.defineProperty(exports, "Symbol", { enumerable: true, get: function () { return index_54.Symbol; } });
+var index_55 = require("./type/template-literal/index");
+Object.defineProperty(exports, "TemplateLiteral", { enumerable: true, get: function () { return index_55.TemplateLiteral; } });
+Object.defineProperty(exports, "IsTemplateLiteralFinite", { enumerable: true, get: function () { return index_55.IsTemplateLiteralFinite; } });
+Object.defineProperty(exports, "TemplateLiteralParse", { enumerable: true, get: function () { return index_55.TemplateLiteralParse; } });
+Object.defineProperty(exports, "TemplateLiteralParseExact", { enumerable: true, get: function () { return index_55.TemplateLiteralParseExact; } });
+Object.defineProperty(exports, "TemplateLiteralGenerate", { enumerable: true, get: function () { return index_55.TemplateLiteralGenerate; } });
+var index_56 = require("./type/transform/index");
+Object.defineProperty(exports, "Transform", { enumerable: true, get: function () { return index_56.Transform; } });
+Object.defineProperty(exports, "TransformDecodeBuilder", { enumerable: true, get: function () { return index_56.TransformDecodeBuilder; } });
+Object.defineProperty(exports, "TransformEncodeBuilder", { enumerable: true, get: function () { return index_56.TransformEncodeBuilder; } });
+var index_57 = require("./type/tuple/index");
+Object.defineProperty(exports, "Tuple", { enumerable: true, get: function () { return index_57.Tuple; } });
+var index_58 = require("./type/uint8array/index");
+Object.defineProperty(exports, "Uint8Array", { enumerable: true, get: function () { return index_58.Uint8Array; } });
+var index_59 = require("./type/undefined/index");
+Object.defineProperty(exports, "Undefined", { enumerable: true, get: function () { return index_59.Undefined; } });
+var index_60 = require("./type/union/index");
+Object.defineProperty(exports, "Union", { enumerable: true, get: function () { return index_60.Union; } });
+var index_61 = require("./type/unknown/index");
+Object.defineProperty(exports, "Unknown", { enumerable: true, get: function () { return index_61.Unknown; } });
+var index_62 = require("./type/unsafe/index");
+Object.defineProperty(exports, "Unsafe", { enumerable: true, get: function () { return index_62.Unsafe; } });
+var index_63 = require("./type/void/index");
+Object.defineProperty(exports, "Void", { enumerable: true, get: function () { return index_63.Void; } });
+var index_64 = require("./type/type/index");
+Object.defineProperty(exports, "JsonTypeBuilder", { enumerable: true, get: function () { return index_64.JsonTypeBuilder; } });
+Object.defineProperty(exports, "JavaScriptTypeBuilder", { enumerable: true, get: function () { return index_64.JavaScriptTypeBuilder; } });
+const index_65 = require("./type/type/index");
+Object.defineProperty(exports, "Type", { enumerable: true, get: function () { return index_65.Type; } });
+exports.default = index_65.Type;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.0-dev-2",
+  "version": "0.32.0-dev-4",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -10,34 +10,15 @@
   ],
   "author": "sinclairzx81",
   "license": "MIT",
-  "main": "./cjs/index.js",
-  "module": "./esm/index.mjs",
-  "types": "./esm/index.d.mts",
+  "main": "./index.js",
+  "types": "./index.d.ts",
   "exports": {
-    "./compiler": {
-      "require": "./cjs/compiler/index.js",
-      "import": "./esm/compiler/index.mjs"
-    },
-    "./errors": {
-      "require": "./cjs/errors/index.js",
-      "import": "./esm/errors/index.mjs"
-    },
-    "./system": {
-      "require": "./cjs/system/index.js",
-      "import": "./esm/system/index.mjs"
-    },
-    "./type": {
-      "require": "./cjs/type/index.js",
-      "import": "./esm/type/index.mjs"
-    },
-    "./value": {
-      "require": "./cjs/value/index.js",
-      "import": "./esm/value/index.mjs"
-    },
-    ".": {
-      "require": "./cjs/index.js",
-      "import": "./esm/index.mjs"
-    }
+    "./compiler": "./compiler/index.js",
+    "./errors": "./errors/index.js",
+    "./system": "./system/index.js",
+    "./type": "./type/index.js",
+    "./value": "./value/index.js",
+    ".": "./index.js"
   },
   "repository": {
     "type": "git",
@@ -51,8 +32,6 @@
     "test:typescript": "hammer task test_typescript",
     "test:static": "hammer task test_static",
     "test:runtime": "hammer task test_runtime",
-    "build:esm": "hammer task build_esm",
-    "build:cjs": "hammer task build_cjs",
     "build": "hammer task build",
     "test": "hammer task test",
     "clean": "hammer task clean",

package/readme.md

@@ -1655,7 +1655,7 @@ For additional comparative benchmarks, please refer to [typescript-runtime-type-
 
 ### Compile
 
-This benchmark measures compilation performance for varying types. You can review this benchmark [here](https://github.com/sinclairzx81/typebox/blob/master/benchmark/measurement/module/compile.ts).
+This benchmark measures compilation performance for varying types. You can review this benchmark [here](https://github.com/sinclairzx81/typebox/blob/master/build/benchmark/measurement/module/compile.ts).
 
 ```typescript
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
@@ -1697,7 +1697,7 @@ This benchmark measures compilation performance for varying types. You can revie
 
 ### Validate
 
-This benchmark measures validation performance for varying types. You can review this benchmark [here](https://github.com/sinclairzx81/typebox/blob/master/benchmark/measurement/module/check.ts).
+This benchmark measures validation performance for varying types. You can review this benchmark [here](https://github.com/sinclairzx81/typebox/blob/master/build/benchmark/measurement/module/check.ts).
 
 ```typescript
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
@@ -1747,11 +1747,12 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '163.6 kb' │ ' 71.6 kb' │  '2.28 x'   │
-│ typebox/errors       │ '113.3 kb' │ ' 50.1 kb' │  '2.26 x'   │
-│ typebox/system       │ ' 83.9 kb' │ ' 37.5 kb' │  '2.24 x'   │
-│ typebox/value        │ '191.1 kb' │ ' 82.3 kb' │  '2.32 x'   │
-│ typebox              │ ' 73.8 kb' │ ' 32.3 kb' │  '2.29 x'   │
+│ typebox/compiler     │ '109.3 kb' │ ' 48.5 kb' │  '2.25 x'   │
+│ typebox/errors       │ ' 54.8 kb' │ ' 24.9 kb' │  '2.20 x'   │
+│ typebox/system       │ ' 12.1 kb' │ '  6.1 kb' │  '1.98 x'   │
+│ typebox/type         │ ' 77.8 kb' │ ' 32.8 kb' │  '2.37 x'   │
+│ typebox/value        │ '143.7 kb' │ ' 61.2 kb' │  '2.35 x'   │
+│ typebox              │ ' 77.9 kb' │ ' 32.8 kb' │  '2.37 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 

package/system/errors.d.ts

@@ -0,0 +1,9 @@
+import { ValueErrorType } from '../errors/errors';
+import { TSchema } from '../type/schema/index';
+export type ErrorFunction = (schema: TSchema, type: ValueErrorType) => string;
+export declare namespace TypeSystemErrorFunction {
+    function Reset(): void;
+    function Set(callback: ErrorFunction): void;
+    function Get(): ErrorFunction;
+}
+export declare function DefaultErrorFunction(schema: TSchema, errorType: ValueErrorType): string;

package/system/errors.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultErrorFunction = exports.TypeSystemErrorFunction = void 0;
+const errors_1 = require("../errors/errors");
+const index_1 = require("../type/symbols/index");
+var TypeSystemErrorFunction;
+(function (TypeSystemErrorFunction) {
+    let errorMessageFunction = DefaultErrorFunction;
+    function Reset() {
+        errorMessageFunction = DefaultErrorFunction;
+    }
+    TypeSystemErrorFunction.Reset = Reset;
+    function Set(callback) {
+        errorMessageFunction = callback;
+    }
+    TypeSystemErrorFunction.Set = Set;
+    function Get() {
+        return errorMessageFunction;
+    }
+    TypeSystemErrorFunction.Get = Get;
+})(TypeSystemErrorFunction || (exports.TypeSystemErrorFunction = TypeSystemErrorFunction = {}));
+function DefaultErrorFunction(schema, errorType) {
+    switch (errorType) {
+        case errors_1.ValueErrorType.ArrayContains:
+            return 'Expected array to contain at least one matching value';
+        case errors_1.ValueErrorType.ArrayMaxContains:
+            return `Expected array to contain no more than ${schema.maxContains} matching values`;
+        case errors_1.ValueErrorType.ArrayMinContains:
+            return `Expected array to contain at least ${schema.minContains} matching values`;
+        case errors_1.ValueErrorType.ArrayMaxItems:
+            return `Expected array length to be less or equal to ${schema.maxItems}`;
+        case errors_1.ValueErrorType.ArrayMinItems:
+            return `Expected array length to be greater or equal to ${schema.minItems}`;
+        case errors_1.ValueErrorType.ArrayUniqueItems:
+            return 'Expected array elements to be unique';
+        case errors_1.ValueErrorType.Array:
+            return 'Expected array';
+        case errors_1.ValueErrorType.AsyncIterator:
+            return 'Expected AsyncIterator';
+        case errors_1.ValueErrorType.BigIntExclusiveMaximum:
+            return `Expected bigint to be less than ${schema.exclusiveMaximum}`;
+        case errors_1.ValueErrorType.BigIntExclusiveMinimum:
+            return `Expected bigint to be greater than ${schema.exclusiveMinimum}`;
+        case errors_1.ValueErrorType.BigIntMaximum:
+            return `Expected bigint to be less or equal to ${schema.maximum}`;
+        case errors_1.ValueErrorType.BigIntMinimum:
+            return `Expected bigint to be greater or equal to ${schema.minimum}`;
+        case errors_1.ValueErrorType.BigIntMultipleOf:
+            return `Expected bigint to be a multiple of ${schema.multipleOf}`;
+        case errors_1.ValueErrorType.BigInt:
+            return 'Expected bigint';
+        case errors_1.ValueErrorType.Boolean:
+            return 'Expected boolean';
+        case errors_1.ValueErrorType.DateExclusiveMinimumTimestamp:
+            return `Expected Date timestamp to be greater than ${schema.exclusiveMinimumTimestamp}`;
+        case errors_1.ValueErrorType.DateExclusiveMaximumTimestamp:
+            return `Expected Date timestamp to be less than ${schema.exclusiveMaximumTimestamp}`;
+        case errors_1.ValueErrorType.DateMinimumTimestamp:
+            return `Expected Date timestamp to be greater or equal to ${schema.minimumTimestamp}`;
+        case errors_1.ValueErrorType.DateMaximumTimestamp:
+            return `Expected Date timestamp to be less or equal to ${schema.maximumTimestamp}`;
+        case errors_1.ValueErrorType.DateMultipleOfTimestamp:
+            return `Expected Date timestamp to be a multiple of ${schema.multipleOfTimestamp}`;
+        case errors_1.ValueErrorType.Date:
+            return 'Expected Date';
+        case errors_1.ValueErrorType.Function:
+            return 'Expected function';
+        case errors_1.ValueErrorType.IntegerExclusiveMaximum:
+            return `Expected integer to be less than ${schema.exclusiveMaximum}`;
+        case errors_1.ValueErrorType.IntegerExclusiveMinimum:
+            return `Expected integer to be greater than ${schema.exclusiveMinimum}`;
+        case errors_1.ValueErrorType.IntegerMaximum:
+            return `Expected integer to be less or equal to ${schema.maximum}`;
+        case errors_1.ValueErrorType.IntegerMinimum:
+            return `Expected integer to be greater or equal to ${schema.minimum}`;
+        case errors_1.ValueErrorType.IntegerMultipleOf:
+            return `Expected integer to be a multiple of ${schema.multipleOf}`;
+        case errors_1.ValueErrorType.Integer:
+            return 'Expected integer';
+        case errors_1.ValueErrorType.IntersectUnevaluatedProperties:
+            return 'Unexpected property';
+        case errors_1.ValueErrorType.Intersect:
+            return 'Expected all values to match';
+        case errors_1.ValueErrorType.Iterator:
+            return 'Expected Iterator';
+        case errors_1.ValueErrorType.Literal:
+            return `Expected ${typeof schema.const === 'string' ? `'${schema.const}'` : schema.const}`;
+        case errors_1.ValueErrorType.Never:
+            return 'Never';
+        case errors_1.ValueErrorType.Not:
+            return 'Value should not match';
+        case errors_1.ValueErrorType.Null:
+            return 'Expected null';
+        case errors_1.ValueErrorType.NumberExclusiveMaximum:
+            return `Expected number to be less than ${schema.exclusiveMaximum}`;
+        case errors_1.ValueErrorType.NumberExclusiveMinimum:
+            return `Expected number to be greater than ${schema.exclusiveMinimum}`;
+        case errors_1.ValueErrorType.NumberMaximum:
+            return `Expected number to be less or equal to ${schema.maximum}`;
+        case errors_1.ValueErrorType.NumberMinimum:
+            return `Expected number to be greater or equal to ${schema.minimum}`;
+        case errors_1.ValueErrorType.NumberMultipleOf:
+            return `Expected number to be a multiple of ${schema.multipleOf}`;
+        case errors_1.ValueErrorType.Number:
+            return 'Expected number';
+        case errors_1.ValueErrorType.Object:
+            return 'Expected object';
+        case errors_1.ValueErrorType.ObjectAdditionalProperties:
+            return 'Unexpected property';
+        case errors_1.ValueErrorType.ObjectMaxProperties:
+            return `Expected object to have no more than ${schema.maxProperties} properties`;
+        case errors_1.ValueErrorType.ObjectMinProperties:
+            return `Expected object to have at least ${schema.minProperties} properties`;
+        case errors_1.ValueErrorType.ObjectRequiredProperty:
+            return 'Required property';
+        case errors_1.ValueErrorType.Promise:
+            return 'Expected Promise';
+        case errors_1.ValueErrorType.StringFormatUnknown:
+            return `Unknown format '${schema.format}'`;
+        case errors_1.ValueErrorType.StringFormat:
+            return `Expected string to match '${schema.format}' format`;
+        case errors_1.ValueErrorType.StringMaxLength:
+            return `Expected string length less or equal to ${schema.maxLength}`;
+        case errors_1.ValueErrorType.StringMinLength:
+            return `Expected string length greater or equal to ${schema.minLength}`;
+        case errors_1.ValueErrorType.StringPattern:
+            return `Expected string to match '${schema.pattern}'`;
+        case errors_1.ValueErrorType.String:
+            return 'Expected string';
+        case errors_1.ValueErrorType.Symbol:
+            return 'Expected symbol';
+        case errors_1.ValueErrorType.TupleLength:
+            return `Expected tuple to have ${schema.maxItems || 0} elements`;
+        case errors_1.ValueErrorType.Tuple:
+            return 'Expected tuple';
+        case errors_1.ValueErrorType.Uint8ArrayMaxByteLength:
+            return `Expected byte length less or equal to ${schema.maxByteLength}`;
+        case errors_1.ValueErrorType.Uint8ArrayMinByteLength:
+            return `Expected byte length greater or equal to ${schema.minByteLength}`;
+        case errors_1.ValueErrorType.Uint8Array:
+            return 'Expected Uint8Array';
+        case errors_1.ValueErrorType.Undefined:
+            return 'Expected undefined';
+        case errors_1.ValueErrorType.Union:
+            return 'Expected union value';
+        case errors_1.ValueErrorType.Void:
+            return 'Expected void';
+        case errors_1.ValueErrorType.Kind:
+            return `Expected kind '${schema[index_1.Kind]}'`;
+        default:
+            return 'Unknown error type';
+    }
+}
+exports.DefaultErrorFunction = DefaultErrorFunction;

package/system/index.d.ts

@@ -0,0 +1,4 @@
+export { ValueErrorType } from '../errors/errors';
+export { DefaultErrorFunction, ErrorFunction, TypeSystemErrorFunction } from './errors';
+export { TypeSystemPolicy } from './policy';
+export { TypeSystem, TypeSystemDuplicateFormat, TypeSystemDuplicateTypeKind } from './system';

package/system/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeSystemDuplicateTypeKind = exports.TypeSystemDuplicateFormat = exports.TypeSystem = exports.TypeSystemPolicy = exports.TypeSystemErrorFunction = exports.DefaultErrorFunction = exports.ValueErrorType = void 0;
+var errors_1 = require("../errors/errors");
+Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function () { return errors_1.ValueErrorType; } });
+var errors_2 = require("./errors");
+Object.defineProperty(exports, "DefaultErrorFunction", { enumerable: true, get: function () { return errors_2.DefaultErrorFunction; } });
+Object.defineProperty(exports, "TypeSystemErrorFunction", { enumerable: true, get: function () { return errors_2.TypeSystemErrorFunction; } });
+var policy_1 = require("./policy");
+Object.defineProperty(exports, "TypeSystemPolicy", { enumerable: true, get: function () { return policy_1.TypeSystemPolicy; } });
+var system_1 = require("./system");
+Object.defineProperty(exports, "TypeSystem", { enumerable: true, get: function () { return system_1.TypeSystem; } });
+Object.defineProperty(exports, "TypeSystemDuplicateFormat", { enumerable: true, get: function () { return system_1.TypeSystemDuplicateFormat; } });
+Object.defineProperty(exports, "TypeSystemDuplicateTypeKind", { enumerable: true, get: function () { return system_1.TypeSystemDuplicateTypeKind; } });

package/system/policy.d.ts

@@ -0,0 +1,11 @@
+export declare namespace TypeSystemPolicy {
+    let ExactOptionalPropertyTypes: boolean;
+    let AllowArrayObject: boolean;
+    let AllowNaN: boolean;
+    let AllowNullVoid: boolean;
+    function IsExactOptionalProperty(value: Record<keyof any, unknown>, key: string): boolean;
+    function IsObjectLike(value: unknown): value is Record<keyof any, unknown>;
+    function IsRecordLike(value: unknown): value is Record<keyof any, unknown>;
+    function IsNumberLike(value: unknown): value is number;
+    function IsVoidLike(value: unknown): value is void;
+}

package/system/policy.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeSystemPolicy = void 0;
+const index_1 = require("../value/guard/index");
+var TypeSystemPolicy;
+(function (TypeSystemPolicy) {
+    TypeSystemPolicy.ExactOptionalPropertyTypes = false;
+    TypeSystemPolicy.AllowArrayObject = false;
+    TypeSystemPolicy.AllowNaN = false;
+    TypeSystemPolicy.AllowNullVoid = false;
+    function IsExactOptionalProperty(value, key) {
+        return TypeSystemPolicy.ExactOptionalPropertyTypes ? key in value : value[key] !== undefined;
+    }
+    TypeSystemPolicy.IsExactOptionalProperty = IsExactOptionalProperty;
+    function IsObjectLike(value) {
+        const isObject = (0, index_1.IsObject)(value);
+        return TypeSystemPolicy.AllowArrayObject ? isObject : isObject && !(0, index_1.IsArray)(value);
+    }
+    TypeSystemPolicy.IsObjectLike = IsObjectLike;
+    function IsRecordLike(value) {
+        return IsObjectLike(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
+    }
+    TypeSystemPolicy.IsRecordLike = IsRecordLike;
+    function IsNumberLike(value) {
+        const isNumber = (0, index_1.IsNumber)(value);
+        return TypeSystemPolicy.AllowNaN ? isNumber : isNumber && Number.isFinite(value);
+    }
+    TypeSystemPolicy.IsNumberLike = IsNumberLike;
+    function IsVoidLike(value) {
+        const isUndefined = (0, index_1.IsUndefined)(value);
+        return TypeSystemPolicy.AllowNullVoid ? isUndefined || value === null : isUndefined;
+    }
+    TypeSystemPolicy.IsVoidLike = IsVoidLike;
+})(TypeSystemPolicy || (exports.TypeSystemPolicy = TypeSystemPolicy = {}));

package/system/system.d.ts

@@ -0,0 +1,10 @@
+export declare class TypeSystemDuplicateTypeKind extends Error {
+    constructor(kind: string);
+}
+export declare class TypeSystemDuplicateFormat extends Error {
+    constructor(kind: string);
+}
+export declare namespace TypeSystem {
+    function Type<Type, Options = Record<PropertyKey, unknown>>(kind: string, check: (options: Options, value: unknown) => boolean): (options?: Partial<Options>) => import("../type/unsafe/unsafe").TUnsafe<Type>;
+    function Format<F extends string>(format: F, check: (value: string) => boolean): F;
+}

package/system/system.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeSystem = exports.TypeSystemDuplicateFormat = exports.TypeSystemDuplicateTypeKind = void 0;
+const index_1 = require("../type/registry/index");
+const index_2 = require("../type/unsafe/index");
+const index_3 = require("../type/symbols/index");
+class TypeSystemDuplicateTypeKind extends Error {
+    constructor(kind) {
+        super(`Duplicate type kind '${kind}' detected`);
+    }
+}
+exports.TypeSystemDuplicateTypeKind = TypeSystemDuplicateTypeKind;
+class TypeSystemDuplicateFormat extends Error {
+    constructor(kind) {
+        super(`Duplicate string format '${kind}' detected`);
+    }
+}
+exports.TypeSystemDuplicateFormat = TypeSystemDuplicateFormat;
+var TypeSystem;
+(function (TypeSystem) {
+    function Type(kind, check) {
+        if (index_1.TypeRegistry.Has(kind))
+            throw new TypeSystemDuplicateTypeKind(kind);
+        index_1.TypeRegistry.Set(kind, check);
+        return (options = {}) => (0, index_2.Unsafe)({ ...options, [index_3.Kind]: kind });
+    }
+    TypeSystem.Type = Type;
+    function Format(format, check) {
+        if (index_1.FormatRegistry.Has(format))
+            throw new TypeSystemDuplicateFormat(format);
+        index_1.FormatRegistry.Set(format, check);
+        return format;
+    }
+    TypeSystem.Format = Format;
+})(TypeSystem || (exports.TypeSystem = TypeSystem = {}));