@sinclair/typebox 0.32.0-dev-18 → 0.32.0-dev-19

package/build/import/type/intrinsic/intrinsic.mjs

@@ -6,7 +6,7 @@ import { Union } from '../union/index.mjs';
 // TypeGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-import { TMappedKey as IsMappedKeyType, TTemplateLiteral as IsTemplateLiteralType, TUnion as IsUnionType, TLiteral as IsLiteralType } from '../guard/type.mjs';
+import { IsMappedKey, IsTemplateLiteral, IsUnion, IsLiteral } from '../guard/type.mjs';
 // ------------------------------------------------------------------
 // Apply
 // ------------------------------------------------------------------
@@ -54,10 +54,10 @@ export function Intrinsic(schema, mode, options = {}) {
     // prettier-ignore
     return (
     // Intrinsic-Mapped-Inference
-    IsMappedKeyType(schema) ? IntrinsicFromMappedKey(schema, mode, options) :
+    IsMappedKey(schema) ? IntrinsicFromMappedKey(schema, mode, options) :
         // Standard-Inference
-        IsTemplateLiteralType(schema) ? FromTemplateLiteral(schema, mode, schema) :
-            IsUnionType(schema) ? Union(FromRest(schema.anyOf, mode), options) :
-                IsLiteralType(schema) ? Literal(FromLiteralValue(schema.const, mode), options) :
+        IsTemplateLiteral(schema) ? FromTemplateLiteral(schema, mode, schema) :
+            IsUnion(schema) ? Union(FromRest(schema.anyOf, mode), options) :
+                IsLiteral(schema) ? Literal(FromLiteralValue(schema.const, mode), options) :
                     schema);
 }

package/build/import/type/keyof/keyof-property-keys.mjs

@@ -4,7 +4,7 @@ import { OperatorUnionMany, OperatorIntersectMany } from '../operators/index.mjs
 // TypeGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-import { TIntersect as IsIntersectType, TUnion as IsUnionType, TTuple as IsTupleType, TArray as IsArrayType, TObject as IsObjectType, TRecord as IsRecordType } from '../guard/type.mjs';
+import { IsIntersect, IsUnion, IsTuple, IsArray, IsObject, IsRecord } from '../guard/type.mjs';
 // prettier-ignore
 function FromRest(T) {
     const [L, ...R] = T;
@@ -53,12 +53,12 @@ function FromPatternProperties(patternProperties) {
 /** Returns a tuple of PropertyKeys derived from the given TSchema. */
 // prettier-ignore
 export function KeyOfPropertyKeys(T) {
-    return (IsIntersectType(T) ? FromIntersect(T.allOf) :
-        IsUnionType(T) ? FromUnion(T.anyOf) :
-            IsTupleType(T) ? FromTuple(T.items ?? []) :
-                IsArrayType(T) ? FromArray(T.items) :
-                    IsObjectType(T) ? FromProperties(T.properties) :
-                        IsRecordType(T) ? FromPatternProperties(T.patternProperties) :
+    return (IsIntersect(T) ? FromIntersect(T.allOf) :
+        IsUnion(T) ? FromUnion(T.anyOf) :
+            IsTuple(T) ? FromTuple(T.items ?? []) :
+                IsArray(T) ? FromArray(T.items) :
+                    IsObject(T) ? FromProperties(T.properties) :
+                        IsRecord(T) ? FromPatternProperties(T.patternProperties) :
                             []);
 }
 // ----------------------------------------------------------------

package/build/import/type/keyof/keyof.mjs

@@ -8,7 +8,7 @@ import { KeyOfFromMappedResult } from './keyof-from-mapped-result.mjs';
 // TypeGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-import { TMappedResult as IsMappedResultType } from '../guard/type.mjs';
+import { IsMappedResult } from '../guard/type.mjs';
 // prettier-ignore
 function FromLiterals(T) {
     const [L, ...R] = T;
@@ -20,7 +20,7 @@ function FromLiterals(T) {
 }
 /** `[Json]` Creates a KeyOf type */
 export function KeyOf(T, options = {}) {
-    if (IsMappedResultType(T)) {
+    if (IsMappedResult(T)) {
         return KeyOfFromMappedResult(T, options);
     }
     else {

package/build/import/type/mapped/mapped.mjs

@@ -22,7 +22,7 @@ import { MappedResult } from './mapped-result.mjs';
 // TypeGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-import { TArray as IsArrayType, TAsyncIterator as IsAsyncIteratorType, TConstructor as IsConstructorType, TFunction as IsFunctionType, TIntersect as IsIntersectType, TIterator as IsIteratorType, TReadonly as IsReadonlyType, TMappedResult as IsMappedResultType, TMappedKey as IsMappedKeyType, TObject as IsObjectType, TOptional as IsOptionalType, TPromise as IsPromiseType, TSchema as IsSchemaType, TTuple as IsTupleType, TUnion as IsUnionType, } from '../guard/type.mjs';
+import { IsArray, IsAsyncIterator, IsConstructor, IsFunction, IsIntersect, IsIterator, IsReadonly, IsMappedResult, IsMappedKey, IsObject, IsOptional, IsPromise, IsSchema, IsTuple, IsUnion, } from '../guard/type.mjs';
 // prettier-ignore
 function FromMappedResult(K, P) {
     return (K in P
@@ -58,22 +58,22 @@ function FromProperties(K, T) {
 function FromSchemaType(K, T) {
     return (
     // unevaluated modifier types
-    IsOptionalType(T) ? Optional(FromSchemaType(K, Discard(T, [OptionalKind]))) :
-        IsReadonlyType(T) ? Readonly(FromSchemaType(K, Discard(T, [ReadonlyKind]))) :
+    IsOptional(T) ? Optional(FromSchemaType(K, Discard(T, [OptionalKind]))) :
+        IsReadonly(T) ? Readonly(FromSchemaType(K, Discard(T, [ReadonlyKind]))) :
             // unevaluated mapped types
-            IsMappedResultType(T) ? FromMappedResult(K, T.properties) :
-                IsMappedKeyType(T) ? FromMappedKey(K, T.keys) :
+            IsMappedResult(T) ? FromMappedResult(K, T.properties) :
+                IsMappedKey(T) ? FromMappedKey(K, T.keys) :
                     // unevaluated types
-                    IsConstructorType(T) ? Constructor(FromRest(K, T.parameters), FromSchemaType(K, T.returns)) :
-                        IsFunctionType(T) ? FunctionType(FromRest(K, T.parameters), FromSchemaType(K, T.returns)) :
-                            IsAsyncIteratorType(T) ? AsyncIterator(FromSchemaType(K, T.items)) :
-                                IsIteratorType(T) ? Iterator(FromSchemaType(K, T.items)) :
-                                    IsIntersectType(T) ? Intersect(FromRest(K, T.allOf)) :
-                                        IsUnionType(T) ? Union(FromRest(K, T.anyOf)) :
-                                            IsTupleType(T) ? Tuple(FromRest(K, T.items ?? [])) :
-                                                IsObjectType(T) ? Object(FromProperties(K, T.properties)) :
-                                                    IsArrayType(T) ? Array(FromSchemaType(K, T.items)) :
-                                                        IsPromiseType(T) ? Promise(FromSchemaType(K, T.item)) :
+                    IsConstructor(T) ? Constructor(FromRest(K, T.parameters), FromSchemaType(K, T.returns)) :
+                        IsFunction(T) ? FunctionType(FromRest(K, T.parameters), FromSchemaType(K, T.returns)) :
+                            IsAsyncIterator(T) ? AsyncIterator(FromSchemaType(K, T.items)) :
+                                IsIterator(T) ? Iterator(FromSchemaType(K, T.items)) :
+                                    IsIntersect(T) ? Intersect(FromRest(K, T.allOf)) :
+                                        IsUnion(T) ? Union(FromRest(K, T.anyOf)) :
+                                            IsTuple(T) ? Tuple(FromRest(K, T.items ?? [])) :
+                                                IsObject(T) ? Object(FromProperties(K, T.properties)) :
+                                                    IsArray(T) ? Array(FromSchemaType(K, T.items)) :
+                                                        IsPromise(T) ? Promise(FromSchemaType(K, T.item)) :
                                                             T);
 }
 // prettier-ignore
@@ -85,7 +85,7 @@ function FromMappedFunctionReturnType(K, T) {
 }
 /** `[Json]` Creates a Mapped object type */
 export function Mapped(key, map, options = {}) {
-    const K = IsSchemaType(key) ? IndexPropertyKeys(key) : key;
+    const K = IsSchema(key) ? IndexPropertyKeys(key) : key;
     const RT = map({ [Kind]: 'MappedKey', keys: K });
     const R = FromMappedFunctionReturnType(K, RT);
     return CloneType(Object(R), options);

package/build/import/type/modifiers/modifiers.mjs

@@ -7,12 +7,12 @@ import { OptionalKind } from '../symbols/index.mjs';
 // TypeGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-import { TOptional as IsOptionalType } from '../guard/type.mjs';
+import { IsOptional } from '../guard/type.mjs';
 // prettier-ignore
 function IsOptionalFromIntersect(T) {
     const [L, ...R] = T;
     return (T.length > 0
-        ? IsOptionalType(L)
+        ? IsOptional(L)
             ? IsOptionalFromIntersect(R)
             : false
         : true);
@@ -21,7 +21,7 @@ function IsOptionalFromIntersect(T) {
 function IsOptionalFromUnion(T) {
     const [L, ...R] = T;
     return (T.length > 0
-        ? IsOptionalType(L)
+        ? IsOptional(L)
             ? true
             : IsOptionalFromUnion(R)
         : false);

package/build/import/type/object/object.mjs

@@ -4,13 +4,13 @@ import { Kind } from '../symbols/index.mjs';
 // TypeGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-import { TOptional as IsOptionalType, TSchema as IsSchemaType } from '../guard/type.mjs';
+import { IsOptional, IsSchema } from '../guard/type.mjs';
 /** `[Json]` Creates an Object type */
 export function _Object(properties, options = {}) {
     const propertyKeys = globalThis.Object.getOwnPropertyNames(properties);
-    const optionalKeys = propertyKeys.filter((key) => IsOptionalType(properties[key]));
+    const optionalKeys = propertyKeys.filter((key) => IsOptional(properties[key]));
     const requiredKeys = propertyKeys.filter((name) => !optionalKeys.includes(name));
-    const clonedAdditionalProperties = IsSchemaType(options.additionalProperties) ? { additionalProperties: CloneType(options.additionalProperties) } : {};
+    const clonedAdditionalProperties = IsSchema(options.additionalProperties) ? { additionalProperties: CloneType(options.additionalProperties) } : {};
     const clonedProperties = propertyKeys.reduce((acc, key) => ({ ...acc, [key]: CloneType(properties[key]) }), {});
     return (requiredKeys.length > 0
         ? { ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties, required: requiredKeys }

package/build/import/type/omit/omit.mjs

@@ -10,7 +10,7 @@ import { OmitFromMappedKey } from './omit-from-mapped-key.mjs';
 // TypeGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-import { TMappedKey as IsMappedKeyType, TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType, TSchema as IsSchemaType } from '../guard/type.mjs';
+import { IsMappedKey, IsIntersect, IsUnion, IsObject, IsSchema } from '../guard/type.mjs';
 // prettier-ignore
 function FromIntersect(T, K) {
     return T.map((T) => OmitResolve(T, K));
@@ -35,17 +35,17 @@ function FromProperties(T, K) {
 }
 // prettier-ignore
 export function OmitResolve(T, K) {
-    return (IsIntersectType(T) ? Intersect(FromIntersect(T.allOf, K)) :
-        IsUnionType(T) ? Union(FromUnion(T.anyOf, K)) :
-            IsObjectType(T) ? Object(FromProperties(T.properties, K)) :
+    return (IsIntersect(T) ? Intersect(FromIntersect(T.allOf, K)) :
+        IsUnion(T) ? Union(FromUnion(T.anyOf, K)) :
+            IsObject(T) ? Object(FromProperties(T.properties, K)) :
                 Object({}));
 }
 export function Omit(T, K, options = {}) {
-    if (IsMappedKeyType(K)) {
+    if (IsMappedKey(K)) {
         return OmitFromMappedKey(T, K, options);
     }
     else {
-        const I = IsSchemaType(K) ? IndexPropertyKeys(K) : K;
+        const I = IsSchema(K) ? IndexPropertyKeys(K) : K;
         const D = Discard(T, [TransformKind, '$id', 'required']);
         const R = CloneType(OmitResolve(T, I), options);
         return { ...D, ...R };

package/build/import/type/partial/partial.mjs

@@ -10,7 +10,7 @@ import { PartialFromMappedResult } from './partial-from-mapped-result.mjs';
 // TypeGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-import { TMappedResult as IsMappedResultType, TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType } from '../guard/type.mjs';
+import { IsMappedResult, IsIntersect, IsUnion, IsObject } from '../guard/type.mjs';
 // prettier-ignore
 function FromIntersect(T) {
     const [L, ...R] = T;
@@ -33,14 +33,14 @@ function FromProperties(T) {
 }
 // prettier-ignore
 function PartialResolve(T) {
-    return (IsIntersectType(T) ? Intersect(FromIntersect(T.allOf)) :
-        IsUnionType(T) ? Union(FromUnion(T.anyOf)) :
-            IsObjectType(T) ? Object(FromProperties(T.properties)) :
+    return (IsIntersect(T) ? Intersect(FromIntersect(T.allOf)) :
+        IsUnion(T) ? Union(FromUnion(T.anyOf)) :
+            IsObject(T) ? Object(FromProperties(T.properties)) :
                 Object({}));
 }
 /** `[Json]` Constructs a type where all properties are optional */
 export function Partial(T, options = {}) {
-    if (IsMappedResultType(T)) {
+    if (IsMappedResult(T)) {
         return PartialFromMappedResult(T, options);
     }
     else {

package/build/import/type/pick/pick.mjs

@@ -10,7 +10,7 @@ import { PickFromMappedKey } from './pick-from-mapped-key.mjs';
 // TypeGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-import { TMappedKey as IsMappedKeyType, TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType, TSchema as IsSchemaType, } from '../guard/type.mjs';
+import { IsMappedKey, IsIntersect, IsUnion, IsObject, IsSchema, } from '../guard/type.mjs';
 function FromIntersect(T, K) {
     return T.map((T) => PickResolve(T, K));
 }
@@ -26,17 +26,17 @@ function FromProperties(T, K) {
 }
 // prettier-ignore
 export function PickResolve(T, K) {
-    return (IsIntersectType(T) ? Intersect(FromIntersect(T.allOf, K)) :
-        IsUnionType(T) ? Union(FromUnion(T.anyOf, K)) :
-            IsObjectType(T) ? Object(FromProperties(T.properties, K)) :
+    return (IsIntersect(T) ? Intersect(FromIntersect(T.allOf, K)) :
+        IsUnion(T) ? Union(FromUnion(T.anyOf, K)) :
+            IsObject(T) ? Object(FromProperties(T.properties, K)) :
                 Object({}));
 }
 export function Pick(T, K, options = {}) {
-    if (IsMappedKeyType(K)) {
+    if (IsMappedKey(K)) {
         return PickFromMappedKey(T, K, options);
     }
     else {
-        const I = IsSchemaType(K) ? IndexPropertyKeys(K) : K;
+        const I = IsSchema(K) ? IndexPropertyKeys(K) : K;
         const D = Discard(T, [TransformKind, '$id', 'required']);
         const R = CloneType(PickResolve(T, I), options);
         return { ...D, ...R };

package/build/import/type/record/record.mjs

@@ -11,7 +11,7 @@ import { IsUndefined } from '../guard/value.mjs';
 // TypeGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-import { TInteger as IsIntegerType, TLiteral as IsLiteralType, TNumber as IsNumberType, TString as IsStringType, TTemplateLiteral as IsTemplateLiteralType, TUnion as IsUnionType, } from '../guard/type.mjs';
+import { IsInteger, IsLiteral, IsNumber, IsString, IsTemplateLiteral, IsUnion } from '../guard/type.mjs';
 // ------------------------------------------------------------------
 // RecordCreateFromPattern
 // ------------------------------------------------------------------
@@ -66,11 +66,11 @@ function FromNumberKey(_, T, options) {
 /** `[Json]` Creates a Record type */
 export function Record(K, T, options = {}) {
     // prettier-ignore
-    return (IsUnionType(K) ? FromUnionKey(K.anyOf, T, options) :
-        IsTemplateLiteralType(K) ? FromTemplateLiteralKey(K, T, options) :
-            IsLiteralType(K) ? FromLiteralKey(K.const, T, options) :
-                IsStringType(K) ? FromStringKey(K, T, options) :
-                    IsIntegerType(K) ? FromIntegerKey(K, T, options) :
-                        IsNumberType(K) ? FromNumberKey(K, T, options) :
+    return (IsUnion(K) ? FromUnionKey(K.anyOf, T, options) :
+        IsTemplateLiteral(K) ? FromTemplateLiteralKey(K, T, options) :
+            IsLiteral(K) ? FromLiteralKey(K.const, T, options) :
+                IsString(K) ? FromStringKey(K, T, options) :
+                    IsInteger(K) ? FromIntegerKey(K, T, options) :
+                        IsNumber(K) ? FromNumberKey(K, T, options) :
                             Never(options));
 }

package/build/import/type/required/required.mjs

@@ -9,7 +9,7 @@ import { RequiredFromMappedResult } from './required-from-mapped-result.mjs';
 // TypeGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-import { TMappedResult as IsMappedResultType, TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType } from '../guard/type.mjs';
+import { IsMappedResult, IsIntersect, IsUnion, IsObject } from '../guard/type.mjs';
 // prettier-ignore
 function FromIntersect(T) {
     const [L, ...R] = T;
@@ -32,14 +32,14 @@ function FromProperties(T) {
 }
 // prettier-ignore
 function RequiredResolve(T) {
-    return (IsIntersectType(T) ? Intersect(FromIntersect(T.allOf)) :
-        IsUnionType(T) ? Union(FromUnion(T.anyOf)) :
-            IsObjectType(T) ? Object(FromProperties(T.properties)) :
+    return (IsIntersect(T) ? Intersect(FromIntersect(T.allOf)) :
+        IsUnion(T) ? Union(FromUnion(T.anyOf)) :
+            IsObject(T) ? Object(FromProperties(T.properties)) :
                 Object({}));
 }
 /** `[Json]` Constructs a type where all properties are required */
 export function Required(T, options = {}) {
-    if (IsMappedResultType(T)) {
+    if (IsMappedResult(T)) {
         return RequiredFromMappedResult(T, options);
     }
     else {

package/build/import/type/rest/rest.mjs

@@ -3,9 +3,13 @@ import { CloneRest } from '../clone/type.mjs';
 // TypeGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-import { TIntersect as IsIntersectType, TUnion as IsUnionType, TTuple as IsTupleType } from '../guard/type.mjs';
+import { IsIntersect, IsUnion, IsTuple } from '../guard/type.mjs';
+// prettier-ignore
 export function RestResolve(T) {
-    return (IsIntersectType(T) ? [...T.allOf] : IsUnionType(T) ? [...T.anyOf] : IsTupleType(T) ? [...(T.items ?? [])] : []);
+    return (IsIntersect(T) ? [...T.allOf] :
+        IsUnion(T) ? [...T.anyOf] :
+            IsTuple(T) ? [...(T.items ?? [])] :
+                []);
 }
 /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
 export function Rest(T) {

package/build/import/type/template-literal/pattern.mjs

@@ -4,7 +4,7 @@ import { Kind } from '../symbols/index.mjs';
 // TypeGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-import { TTemplateLiteral as IsTemplateLiteralType, TUnion as IsUnionType, TNumber as IsNumberType, TInteger as IsIntegerType, TBigInt as IsBigIntType, TString as IsStringType, TLiteral as IsLiteralType, TBoolean as IsBooleanType, } from '../guard/type.mjs';
+import { IsTemplateLiteral, IsUnion, IsNumber, IsInteger, IsBigInt, IsString, IsLiteral, IsBoolean } from '../guard/type.mjs';
 // ------------------------------------------------------------------
 // TemplateLiteralPatternError
 // ------------------------------------------------------------------
@@ -18,14 +18,14 @@ function Escape(value) {
 }
 // prettier-ignore
 function Visit(schema, acc) {
-    return (IsTemplateLiteralType(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) :
-        IsUnionType(schema) ? `(${schema.anyOf.map((schema) => Visit(schema, acc)).join('|')})` :
-            IsNumberType(schema) ? `${acc}${PatternNumber}` :
-                IsIntegerType(schema) ? `${acc}${PatternNumber}` :
-                    IsBigIntType(schema) ? `${acc}${PatternNumber}` :
-                        IsStringType(schema) ? `${acc}${PatternString}` :
-                            IsLiteralType(schema) ? `${acc}${Escape(schema.const.toString())}` :
-                                IsBooleanType(schema) ? `${acc}${PatternBoolean}` :
+    return (IsTemplateLiteral(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) :
+        IsUnion(schema) ? `(${schema.anyOf.map((schema) => Visit(schema, acc)).join('|')})` :
+            IsNumber(schema) ? `${acc}${PatternNumber}` :
+                IsInteger(schema) ? `${acc}${PatternNumber}` :
+                    IsBigInt(schema) ? `${acc}${PatternNumber}` :
+                        IsString(schema) ? `${acc}${PatternString}` :
+                            IsLiteral(schema) ? `${acc}${Escape(schema.const.toString())}` :
+                                IsBoolean(schema) ? `${acc}${PatternBoolean}` :
                                     (() => { throw new TemplateLiteralPatternError(`Unexpected Kind '${schema[Kind]}'`); })());
 }
 export function TemplateLiteralPattern(kinds) {

package/build/import/type/transform/transform.mjs

@@ -4,7 +4,7 @@ import { TransformKind } from '../symbols/index.mjs';
 // TypeGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-import { TTransform as IsTransform } from '../guard/type.mjs';
+import { IsTransform } from '../guard/type.mjs';
 // ------------------------------------------------------------------
 // TransformBuilders
 // ------------------------------------------------------------------

package/build/import/type/union/union-evaluated.mjs

@@ -8,12 +8,12 @@ import { UnionCreate } from './union-create.mjs';
 // TypeGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-import { TOptional as IsOptionalType } from '../guard/type.mjs';
+import { IsOptional } from '../guard/type.mjs';
 // prettier-ignore
 function IsUnionOptional(T) {
     const [L, ...R] = T;
     return (T.length > 0
-        ? IsOptionalType(L)
+        ? IsOptional(L)
             ? true
             : IsUnionOptional(R)
         : false);

package/build/import/value/check/check.mjs

@@ -1,16 +1,23 @@
-import { IsArray, IsUint8Array, IsDate, IsPromise, IsFunction, IsAsyncIterator, IsIterator, IsBoolean, IsNumber, IsBigInt, IsString, IsSymbol, IsInteger, IsNull, IsUndefined } from '../guard/index.mjs';
 import { TypeSystemPolicy } from '../../system/index.mjs';
 import { Deref } from '../deref/index.mjs';
 import { Hash } from '../hash/index.mjs';
 import { Kind } from '../../type/symbols/index.mjs';
 import { KeyOfPattern } from '../../type/keyof/index.mjs';
 import { ExtendsUndefinedCheck } from '../../type/extends/index.mjs';
-import { TSchema as IsSchemaType } from '../../type/guard/type.mjs';
 import { TypeRegistry, FormatRegistry } from '../../type/registry/index.mjs';
 import { Never } from '../../type/never/index.mjs';
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+// prettier-ignore
+import { IsArray, IsUint8Array, IsDate, IsPromise, IsFunction, IsAsyncIterator, IsIterator, IsBoolean, IsNumber, IsBigInt, IsString, IsSymbol, IsInteger, IsNull, IsUndefined } from '../guard/index.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsSchema } from '../../type/guard/type.mjs';
+// ------------------------------------------------------------------
 // Errors
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 export class ValueCheckUnknownTypeError extends Error {
     schema;
     constructor(schema) {
@@ -18,21 +25,21 @@ export class ValueCheckUnknownTypeError extends Error {
         this.schema = schema;
     }
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // TypeGuards
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function IsAnyOrUnknown(schema) {
     return schema[Kind] === 'Any' || schema[Kind] === 'Unknown';
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Guards
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function IsDefined(value) {
     return value !== undefined;
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Types
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function TAny(schema, references, value) {
     return true;
 }
@@ -157,7 +164,7 @@ function TIntersect(schema, references, value) {
         const check2 = Object.getOwnPropertyNames(value).every((key) => keyPattern.test(key));
         return check1 && check2;
     }
-    else if (IsSchemaType(schema.unevaluatedProperties)) {
+    else if (IsSchema(schema.unevaluatedProperties)) {
         const keyCheck = new RegExp(KeyOfPattern(schema));
         const check2 = Object.getOwnPropertyNames(value).every((key) => keyCheck.test(key) || Visit(schema.unevaluatedProperties, references, value[key]));
         return check1 && check2;

package/build/import/value/clean/clean.mjs

@@ -1,21 +1,23 @@
-import { IsString, IsObject, IsArray, IsUndefined } from '../guard/index.mjs';
-import { TSchema as IsSchemaType } from '../../type/guard/type.mjs';
 import { KeyOfPropertyKeys } from '../../type/keyof/index.mjs';
 import { Check } from '../check/index.mjs';
 import { Clone } from '../clone/index.mjs';
 import { Deref } from '../deref/index.mjs';
 import { Kind } from '../../type/symbols/index.mjs';
 // ------------------------------------------------------------------
-// IsSchema
+// ValueGuard
 // ------------------------------------------------------------------
-function IsSchema(schema) {
-    return IsSchemaType(schema);
-}
+// prettier-ignore
+import { IsString, IsObject, IsArray, IsUndefined } from '../guard/index.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
+import { IsSchema } from '../../type/guard/type.mjs';
 // ------------------------------------------------------------------
 // IsCheckable
 // ------------------------------------------------------------------
 function IsCheckable(schema) {
-    return IsSchemaType(schema) && schema[Kind] !== 'Unsafe';
+    return IsSchema(schema) && schema[Kind] !== 'Unsafe';
 }
 // ------------------------------------------------------------------
 // Types

package/build/import/value/clone/clone.mjs

@@ -1,7 +1,10 @@
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
 import { IsArray, IsDate, IsPlainObject, IsTypedArray, IsValueType } from '../guard/index.mjs';
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Clonable
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function ObjectType(value) {
     const keys = [...Object.getOwnPropertyNames(value), ...Object.getOwnPropertySymbols(value)];
     return keys.reduce((acc, key) => ({ ...acc, [key]: Clone(value[key]) }), {});
@@ -18,9 +21,9 @@ function DateType(value) {
 function ValueType(value) {
     return value;
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Clone
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 /** Returns a clone of the given value */
 export function Clone(value) {
     if (IsArray(value))

package/build/import/value/convert/convert.mjs

@@ -1,11 +1,15 @@
-import { IsArray, IsObject, IsDate, IsUndefined, IsString, IsNumber, IsBoolean, IsBigInt, IsSymbol } from '../guard/index.mjs';
 import { Clone } from '../clone/index.mjs';
 import { Check } from '../check/index.mjs';
 import { Deref } from '../deref/index.mjs';
-import { TObject as IsObjectType } from '../../type/guard/type.mjs';
+import { IsObject as IsObjectType } from '../../type/guard/type.mjs';
 import { Kind } from '../../type/symbols/index.mjs';
 import { Composite } from '../../type/composite/index.mjs';
 // ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+// prettier-ignore
+import { IsArray, IsObject, IsDate, IsUndefined, IsString, IsNumber, IsBoolean, IsBigInt, IsSymbol } from '../guard/index.mjs';
+// ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
 export class ValueConvertUnknownTypeError extends Error {

package/build/import/value/default/default.mjs

@@ -1,9 +1,17 @@
-import { IsString, IsObject, IsArray, IsUndefined } from '../guard/index.mjs';
-import { TSchema as IsSchemaType } from '../../type/guard/type.mjs';
 import { Check } from '../check/index.mjs';
 import { Deref } from '../deref/index.mjs';
 import { Kind } from '../../type/symbols/index.mjs';
 // ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+// prettier-ignore
+import { IsString, IsObject, IsArray, IsUndefined } from '../guard/index.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
+import { IsSchema } from '../../type/guard/type.mjs';
+// ------------------------------------------------------------------
 // ValueOrDefault
 // ------------------------------------------------------------------
 function ValueOrDefault(schema, value) {
@@ -13,13 +21,13 @@ function ValueOrDefault(schema, value) {
 // IsCheckable
 // ------------------------------------------------------------------
 function IsCheckable(schema) {
-    return IsSchemaType(schema) && schema[Kind] !== 'Unsafe';
+    return IsSchema(schema) && schema[Kind] !== 'Unsafe';
 }
 // ------------------------------------------------------------------
 // IsDefaultSchema
 // ------------------------------------------------------------------
 function IsDefaultSchema(value) {
-    return IsSchemaType(value) && 'default' in value;
+    return IsSchema(value) && 'default' in value;
 }
 // ------------------------------------------------------------------
 // Types