@sinclair/typebox 0.32.24 → 0.32.25

package/build/import/type/awaited/awaited.mjs

@@ -4,7 +4,7 @@ import { CloneType } from '../clone/type.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsIntersect, IsUnion, IsPromise } from '../guard/type.mjs';
+import { IsIntersect, IsUnion, IsPromise } from '../guard/kind.mjs';
 // prettier-ignore
 function FromRest(T) {
     return T.map(L => AwaitedResolve(L));

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

@@ -12,9 +12,14 @@ function RegExpType(value) {
     return new RegExp(value.source, value.flags);
 }
 function ObjectType(value) {
-    const clonedProperties = Object.getOwnPropertyNames(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), {});
-    const clonedSymbols = Object.getOwnPropertySymbols(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), {});
-    return { ...clonedProperties, ...clonedSymbols };
+    const result = {};
+    for (const key of Object.getOwnPropertyNames(value)) {
+        result[key] = Visit(value[key]);
+    }
+    for (const key of Object.getOwnPropertySymbols(value)) {
+        result[key] = Visit(value[key]);
+    }
+    return result;
 }
 // prettier-ignore
 function Visit(value) {

package/build/import/type/composite/composite.mjs

@@ -6,12 +6,13 @@ import { SetDistinct } from '../sets/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsNever } from '../guard/type.mjs';
+import { IsNever } from '../guard/kind.mjs';
 // prettier-ignore
 function CompositeKeys(T) {
-    return SetDistinct(T.reduce((Acc, L) => {
-        return ([...Acc, ...KeyOfPropertyKeys(L)]);
-    }, []));
+    const Acc = [];
+    for (const L of T)
+        Acc.push(...KeyOfPropertyKeys(L));
+    return SetDistinct(Acc);
 }
 // prettier-ignore
 function FilterNever(T) {
@@ -19,15 +20,18 @@ function FilterNever(T) {
 }
 // prettier-ignore
 function CompositeProperty(T, K) {
-    return FilterNever(T.reduce((Acc, L) => {
-        return [...Acc, ...IndexFromPropertyKeys(L, [K])];
-    }, []));
+    const Acc = [];
+    for (const L of T)
+        Acc.push(...IndexFromPropertyKeys(L, [K]));
+    return FilterNever(Acc);
 }
 // prettier-ignore
 function CompositeProperties(T, K) {
-    return K.reduce((Acc, L) => {
-        return { ...Acc, [L]: IntersectEvaluated(CompositeProperty(T, L)) };
-    }, {});
+    const Acc = {};
+    for (const L of K) {
+        Acc[L] = IntersectEvaluated(CompositeProperty(T, L));
+    }
+    return Acc;
 }
 // prettier-ignore
 export function Composite(T, options = {}) {

package/build/import/type/const/const.mjs

@@ -22,9 +22,10 @@ function FromArray(T) {
 }
 // prettier-ignore
 function FromProperties(value) {
-    return globalThis.Object.getOwnPropertyNames(value).reduce((acc, key) => {
-        return { ...acc, [key]: Readonly(FromValue(value[key], false)) };
-    }, {});
+    const Acc = {};
+    for (const K of globalThis.Object.getOwnPropertyNames(value))
+        Acc[K] = Readonly(FromValue(value[K], false));
+    return Acc;
 }
 function ConditionalReadonly(T, root) {
     return (root === true ? T : Readonly(T));

package/build/import/type/deref/deref.d.mts

@@ -15,7 +15,7 @@ export type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T exte
 type FromProperties<T extends TProperties> = Evaluate<{
     [K in keyof T]: TDeref<T[K]>;
 }>;
-declare function FromProperties(properties: TProperties, references: TSchema[]): TProperties;
+declare function FromProperties(properties: TProperties, references: TSchema[]): never;
 export type TDeref<T extends TSchema> = T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<TFromRest<S>, TDeref<R>> : T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<TFromRest<S>, TDeref<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromRest<S>> : T extends TTuple<infer S extends TSchema[]> ? TTuple<TFromRest<S>> : T extends TObject<infer S extends TProperties> ? TObject<FromProperties<S>> : T extends TArray<infer S extends TSchema> ? TArray<TDeref<S>> : T extends TPromise<infer S extends TSchema> ? TPromise<TDeref<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<TDeref<S>> : T extends TIterator<infer S extends TSchema> ? TIterator<TDeref<S>> : T extends TRef<infer S extends TSchema> ? TDeref<S> : T;
 /** `[Json]` Creates a dereferenced type */
 export declare function Deref<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>;

package/build/import/type/deref/deref.mjs

@@ -4,15 +4,17 @@ import { IsUndefined } from '../guard/value.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsConstructor, IsFunction, IsIntersect, IsUnion, IsTuple, IsArray, IsObject, IsPromise, IsAsyncIterator, IsIterator, IsRef } from '../guard/type.mjs';
+import { IsConstructor, IsFunction, IsIntersect, IsUnion, IsTuple, IsArray, IsObject, IsPromise, IsAsyncIterator, IsIterator, IsRef } from '../guard/kind.mjs';
 function FromRest(schema, references) {
     return schema.map((schema) => Deref(schema, references));
 }
 // prettier-ignore
 function FromProperties(properties, references) {
-    return globalThis.Object.getOwnPropertyNames(properties).reduce((acc, key) => {
-        return { ...acc, [key]: Deref(properties[key], references) };
-    }, {});
+    const Acc = {};
+    for (const K of globalThis.Object.getOwnPropertyNames(properties)) {
+        Acc[K] = Deref(properties[K], references);
+    }
+    return Acc;
 }
 // prettier-ignore
 function FromConstructor(schema, references) {

package/build/import/type/exclude/exclude-from-mapped-result.mjs

@@ -2,9 +2,10 @@ import { MappedResult } from '../mapped/index.mjs';
 import { Exclude } from './exclude.mjs';
 // prettier-ignore
 function FromProperties(P, U) {
-    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: Exclude(P[K2], U) };
-    }, {});
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = Exclude(P[K2], U);
+    return Acc;
 }
 // prettier-ignore
 function FromMappedResult(R, T) {

package/build/import/type/exclude/exclude.mjs

@@ -7,7 +7,7 @@ import { ExcludeFromTemplateLiteral } from './exclude-from-template-literal.mjs'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsMappedResult, IsTemplateLiteral, IsUnion } from '../guard/type.mjs';
+import { IsMappedResult, IsTemplateLiteral, IsUnion } from '../guard/kind.mjs';
 function ExcludeRest(L, R) {
     const excluded = L.filter((inner) => ExtendsCheck(inner, R) === ExtendsResult.False);
     return excluded.length === 1 ? excluded[0] : Union(excluded);

package/build/import/type/extends/extends-from-mapped-result.mjs

@@ -2,9 +2,10 @@ import { MappedResult } from '../mapped/index.mjs';
 import { Extends } from './extends.mjs';
 // prettier-ignore
 function FromProperties(P, Right, True, False, options) {
-    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: Extends(P[K2], Right, True, False, options) };
-    }, {});
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = Extends(P[K2], Right, True, False, options);
+    return Acc;
 }
 // prettier-ignore
 function FromMappedResult(Left, Right, True, False, options) {

package/build/import/type/extends/extends.mjs

@@ -6,7 +6,7 @@ import { ExtendsFromMappedResult } from './extends-from-mapped-result.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsMappedKey, IsMappedResult } from '../guard/type.mjs';
+import { IsMappedKey, IsMappedResult } from '../guard/kind.mjs';
 // prettier-ignore
 function ExtendsResolve(left, right, trueType, falseType) {
     const R = ExtendsCheck(left, right);

package/build/import/type/extract/extract-from-mapped-result.mjs

@@ -2,9 +2,10 @@ import { MappedResult } from '../mapped/index.mjs';
 import { Extract } from './extract.mjs';
 // prettier-ignore
 function FromProperties(P, T) {
-    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: Extract(P[K2], T) };
-    }, {});
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = Extract(P[K2], T);
+    return Acc;
 }
 // prettier-ignore
 function FromMappedResult(R, T) {

package/build/import/type/extract/extract.mjs

@@ -7,7 +7,7 @@ import { ExtractFromTemplateLiteral } from './extract-from-template-literal.mjs'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsMappedResult, IsTemplateLiteral, IsUnion } from '../guard/type.mjs';
+import { IsMappedResult, IsTemplateLiteral, IsUnion } from '../guard/kind.mjs';
 function ExtractRest(L, R) {
     const extracted = L.filter((inner) => ExtendsCheck(inner, R) !== ExtendsResult.False);
     return extracted.length === 1 ? extracted[0] : Union(extracted);

package/build/import/type/guard/index.d.mts

@@ -1,2 +1,3 @@
+export * as KindGuard from './kind.mjs';
 export * as TypeGuard from './type.mjs';
 export * as ValueGuard from './value.mjs';

package/build/import/type/guard/index.mjs

@@ -1,2 +1,3 @@
+export * as KindGuard from './kind.mjs';
 export * as TypeGuard from './type.mjs';
 export * as ValueGuard from './value.mjs';

package/build/import/type/guard/kind.d.mts

@@ -0,0 +1,136 @@
+import { Kind, Hint, TransformKind } from '../symbols/index.mjs';
+import { TransformOptions } from '../transform/index.mjs';
+import { TTemplateLiteral } from '../template-literal/index.mjs';
+import { TArray } from '../array/index.mjs';
+import { TBoolean } from '../boolean/index.mjs';
+import type { TRecord } from '../record/index.mjs';
+import type { TString } from '../string/index.mjs';
+import type { TUnion } from '../union/index.mjs';
+import type { TAny } from '../any/index.mjs';
+import type { TAsyncIterator } from '../async-iterator/index.mjs';
+import type { TBigInt } from '../bigint/index.mjs';
+import type { TConstructor } from '../constructor/index.mjs';
+import type { TFunction } from '../function/index.mjs';
+import type { TInteger } from '../integer/index.mjs';
+import type { TIntersect } from '../intersect/index.mjs';
+import type { TIterator } from '../iterator/index.mjs';
+import type { TLiteral } from '../literal/index.mjs';
+import type { TMappedKey, TMappedResult } from '../mapped/index.mjs';
+import type { TNever } from '../never/index.mjs';
+import type { TNot } from '../not/index.mjs';
+import type { TNull } from '../null/index.mjs';
+import type { TNumber } from '../number/index.mjs';
+import type { TObject, TProperties } from '../object/index.mjs';
+import type { TOptional } from '../optional/index.mjs';
+import type { TPromise } from '../promise/index.mjs';
+import type { TReadonly } from '../readonly/index.mjs';
+import type { TRef } from '../ref/index.mjs';
+import type { TRegExp } from '../regexp/index.mjs';
+import type { TSchema } from '../schema/index.mjs';
+import type { TSymbol } from '../symbol/index.mjs';
+import type { TTuple } from '../tuple/index.mjs';
+import type { TUint8Array } from '../uint8array/index.mjs';
+import type { TUndefined } from '../undefined/index.mjs';
+import type { TUnknown } from '../unknown/index.mjs';
+import type { TUnsafe } from '../unsafe/index.mjs';
+import type { TVoid } from '../void/index.mjs';
+import type { TDate } from '../date/index.mjs';
+import type { TThis } from '../recursive/index.mjs';
+/** `[Kind-Only]` Returns true if this value has a Readonly symbol */
+export declare function IsReadonly<T extends TSchema>(value: T): value is TReadonly<T>;
+/** `[Kind-Only]` Returns true if this value has a Optional symbol */
+export declare function IsOptional<T extends TSchema>(value: T): value is TOptional<T>;
+/** `[Kind-Only]` Returns true if the given value is TAny */
+export declare function IsAny(value: unknown): value is TAny;
+/** `[Kind-Only]` Returns true if the given value is TArray */
+export declare function IsArray(value: unknown): value is TArray;
+/** `[Kind-Only]` Returns true if the given value is TAsyncIterator */
+export declare function IsAsyncIterator(value: unknown): value is TAsyncIterator;
+/** `[Kind-Only]` Returns true if the given value is TBigInt */
+export declare function IsBigInt(value: unknown): value is TBigInt;
+/** `[Kind-Only]` Returns true if the given value is TBoolean */
+export declare function IsBoolean(value: unknown): value is TBoolean;
+/** `[Kind-Only]` Returns true if the given value is TConstructor */
+export declare function IsConstructor(value: unknown): value is TConstructor;
+/** `[Kind-Only]` Returns true if the given value is TDate */
+export declare function IsDate(value: unknown): value is TDate;
+/** `[Kind-Only]` Returns true if the given value is TFunction */
+export declare function IsFunction(value: unknown): value is TFunction;
+/** `[Kind-Only]` Returns true if the given value is TInteger */
+export declare function IsInteger(value: unknown): value is TInteger;
+/** `[Kind-Only]` Returns true if the given schema is TProperties */
+export declare function IsProperties(value: unknown): value is TProperties;
+/** `[Kind-Only]` Returns true if the given value is TIntersect */
+export declare function IsIntersect(value: unknown): value is TIntersect;
+/** `[Kind-Only]` Returns true if the given value is TIterator */
+export declare function IsIterator(value: unknown): value is TIterator;
+/** `[Kind-Only]` Returns true if the given value is a TKind with the given name. */
+export declare function IsKindOf<T extends string>(value: unknown, kind: T): value is Record<PropertyKey, unknown> & {
+    [Kind]: T;
+};
+/** `[Kind-Only]` Returns true if the given value is TLiteral<string> */
+export declare function IsLiteralString(value: unknown): value is TLiteral<string>;
+/** `[Kind-Only]` Returns true if the given value is TLiteral<number> */
+export declare function IsLiteralNumber(value: unknown): value is TLiteral<number>;
+/** `[Kind-Only]` Returns true if the given value is TLiteral<boolean> */
+export declare function IsLiteralBoolean(value: unknown): value is TLiteral<boolean>;
+/** `[Kind-Only]` Returns true if the given value is TLiteral */
+export declare function IsLiteral(value: unknown): value is TLiteral;
+/** `[Kind-Only]` Returns true if the given value is a TMappedKey */
+export declare function IsMappedKey(value: unknown): value is TMappedKey;
+/** `[Kind-Only]` Returns true if the given value is TMappedResult */
+export declare function IsMappedResult(value: unknown): value is TMappedResult;
+/** `[Kind-Only]` Returns true if the given value is TNever */
+export declare function IsNever(value: unknown): value is TNever;
+/** `[Kind-Only]` Returns true if the given value is TNot */
+export declare function IsNot(value: unknown): value is TNot;
+/** `[Kind-Only]` Returns true if the given value is TNull */
+export declare function IsNull(value: unknown): value is TNull;
+/** `[Kind-Only]` Returns true if the given value is TNumber */
+export declare function IsNumber(value: unknown): value is TNumber;
+/** `[Kind-Only]` Returns true if the given value is TObject */
+export declare function IsObject(value: unknown): value is TObject;
+/** `[Kind-Only]` Returns true if the given value is TPromise */
+export declare function IsPromise(value: unknown): value is TPromise;
+/** `[Kind-Only]` Returns true if the given value is TRecord */
+export declare function IsRecord(value: unknown): value is TRecord;
+/** `[Kind-Only]` Returns true if this value is TRecursive */
+export declare function IsRecursive(value: unknown): value is {
+    [Hint]: 'Recursive';
+};
+/** `[Kind-Only]` Returns true if the given value is TRef */
+export declare function IsRef(value: unknown): value is TRef;
+/** `[Kind-Only]` Returns true if the given value is TRegExp */
+export declare function IsRegExp(value: unknown): value is TRegExp;
+/** `[Kind-Only]` Returns true if the given value is TString */
+export declare function IsString(value: unknown): value is TString;
+/** `[Kind-Only]` Returns true if the given value is TSymbol */
+export declare function IsSymbol(value: unknown): value is TSymbol;
+/** `[Kind-Only]` Returns true if the given value is TTemplateLiteral */
+export declare function IsTemplateLiteral(value: unknown): value is TTemplateLiteral;
+/** `[Kind-Only]` Returns true if the given value is TThis */
+export declare function IsThis(value: unknown): value is TThis;
+/** `[Kind-Only]` Returns true of this value is TTransform */
+export declare function IsTransform(value: unknown): value is {
+    [TransformKind]: TransformOptions;
+};
+/** `[Kind-Only]` Returns true if the given value is TTuple */
+export declare function IsTuple(value: unknown): value is TTuple;
+/** `[Kind-Only]` Returns true if the given value is TUndefined */
+export declare function IsUndefined(value: unknown): value is TUndefined;
+/** `[Kind-Only]` Returns true if the given value is TUnion */
+export declare function IsUnion(value: unknown): value is TUnion;
+/** `[Kind-Only]` Returns true if the given value is TUint8Array */
+export declare function IsUint8Array(value: unknown): value is TUint8Array;
+/** `[Kind-Only]` Returns true if the given value is TUnknown */
+export declare function IsUnknown(value: unknown): value is TUnknown;
+/** `[Kind-Only]` Returns true if the given value is a raw TUnsafe */
+export declare function IsUnsafe(value: unknown): value is TUnsafe<unknown>;
+/** `[Kind-Only]` Returns true if the given value is TVoid */
+export declare function IsVoid(value: unknown): value is TVoid;
+/** `[Kind-Only]` Returns true if the given value is TKind */
+export declare function IsKind(value: unknown): value is Record<PropertyKey, unknown> & {
+    [Kind]: string;
+};
+/** `[Kind-Only]` Returns true if the given value is TSchema */
+export declare function IsSchema(value: unknown): value is TSchema;

package/build/import/type/guard/kind.mjs

@@ -0,0 +1,217 @@
+import * as ValueGuard from './value.mjs';
+import { Kind, Hint, TransformKind, ReadonlyKind, OptionalKind } from '../symbols/index.mjs';
+/** `[Kind-Only]` Returns true if this value has a Readonly symbol */
+export function IsReadonly(value) {
+    return ValueGuard.IsObject(value) && value[ReadonlyKind] === 'Readonly';
+}
+/** `[Kind-Only]` Returns true if this value has a Optional symbol */
+export function IsOptional(value) {
+    return ValueGuard.IsObject(value) && value[OptionalKind] === 'Optional';
+}
+/** `[Kind-Only]` Returns true if the given value is TAny */
+export function IsAny(value) {
+    return IsKindOf(value, 'Any');
+}
+/** `[Kind-Only]` Returns true if the given value is TArray */
+export function IsArray(value) {
+    return IsKindOf(value, 'Array');
+}
+/** `[Kind-Only]` Returns true if the given value is TAsyncIterator */
+export function IsAsyncIterator(value) {
+    return IsKindOf(value, 'AsyncIterator');
+}
+/** `[Kind-Only]` Returns true if the given value is TBigInt */
+export function IsBigInt(value) {
+    return IsKindOf(value, 'BigInt');
+}
+/** `[Kind-Only]` Returns true if the given value is TBoolean */
+export function IsBoolean(value) {
+    return IsKindOf(value, 'Boolean');
+}
+/** `[Kind-Only]` Returns true if the given value is TConstructor */
+export function IsConstructor(value) {
+    return IsKindOf(value, 'Constructor');
+}
+/** `[Kind-Only]` Returns true if the given value is TDate */
+export function IsDate(value) {
+    return IsKindOf(value, 'Date');
+}
+/** `[Kind-Only]` Returns true if the given value is TFunction */
+export function IsFunction(value) {
+    return IsKindOf(value, 'Function');
+}
+/** `[Kind-Only]` Returns true if the given value is TInteger */
+export function IsInteger(value) {
+    return IsKindOf(value, 'Integer');
+}
+/** `[Kind-Only]` Returns true if the given schema is TProperties */
+export function IsProperties(value) {
+    return ValueGuard.IsObject(value);
+}
+/** `[Kind-Only]` Returns true if the given value is TIntersect */
+export function IsIntersect(value) {
+    return IsKindOf(value, 'Intersect');
+}
+/** `[Kind-Only]` Returns true if the given value is TIterator */
+export function IsIterator(value) {
+    return IsKindOf(value, 'Iterator');
+}
+/** `[Kind-Only]` Returns true if the given value is a TKind with the given name. */
+export function IsKindOf(value, kind) {
+    return ValueGuard.IsObject(value) && Kind in value && value[Kind] === kind;
+}
+/** `[Kind-Only]` Returns true if the given value is TLiteral<string> */
+export function IsLiteralString(value) {
+    return IsLiteral(value) && ValueGuard.IsString(value.const);
+}
+/** `[Kind-Only]` Returns true if the given value is TLiteral<number> */
+export function IsLiteralNumber(value) {
+    return IsLiteral(value) && ValueGuard.IsNumber(value.const);
+}
+/** `[Kind-Only]` Returns true if the given value is TLiteral<boolean> */
+export function IsLiteralBoolean(value) {
+    return IsLiteral(value) && ValueGuard.IsBoolean(value.const);
+}
+/** `[Kind-Only]` Returns true if the given value is TLiteral */
+export function IsLiteral(value) {
+    return IsKindOf(value, 'Literal');
+}
+/** `[Kind-Only]` Returns true if the given value is a TMappedKey */
+export function IsMappedKey(value) {
+    return IsKindOf(value, 'MappedKey');
+}
+/** `[Kind-Only]` Returns true if the given value is TMappedResult */
+export function IsMappedResult(value) {
+    return IsKindOf(value, 'MappedResult');
+}
+/** `[Kind-Only]` Returns true if the given value is TNever */
+export function IsNever(value) {
+    return IsKindOf(value, 'Never');
+}
+/** `[Kind-Only]` Returns true if the given value is TNot */
+export function IsNot(value) {
+    return IsKindOf(value, 'Not');
+}
+/** `[Kind-Only]` Returns true if the given value is TNull */
+export function IsNull(value) {
+    return IsKindOf(value, 'Null');
+}
+/** `[Kind-Only]` Returns true if the given value is TNumber */
+export function IsNumber(value) {
+    return IsKindOf(value, 'Number');
+}
+/** `[Kind-Only]` Returns true if the given value is TObject */
+export function IsObject(value) {
+    return IsKindOf(value, 'Object');
+}
+/** `[Kind-Only]` Returns true if the given value is TPromise */
+export function IsPromise(value) {
+    return IsKindOf(value, 'Promise');
+}
+/** `[Kind-Only]` Returns true if the given value is TRecord */
+export function IsRecord(value) {
+    return IsKindOf(value, 'Record');
+}
+/** `[Kind-Only]` Returns true if this value is TRecursive */
+export function IsRecursive(value) {
+    return ValueGuard.IsObject(value) && Hint in value && value[Hint] === 'Recursive';
+}
+/** `[Kind-Only]` Returns true if the given value is TRef */
+export function IsRef(value) {
+    return IsKindOf(value, 'Ref');
+}
+/** `[Kind-Only]` Returns true if the given value is TRegExp */
+export function IsRegExp(value) {
+    return IsKindOf(value, 'RegExp');
+}
+/** `[Kind-Only]` Returns true if the given value is TString */
+export function IsString(value) {
+    return IsKindOf(value, 'String');
+}
+/** `[Kind-Only]` Returns true if the given value is TSymbol */
+export function IsSymbol(value) {
+    return IsKindOf(value, 'Symbol');
+}
+/** `[Kind-Only]` Returns true if the given value is TTemplateLiteral */
+export function IsTemplateLiteral(value) {
+    return IsKindOf(value, 'TemplateLiteral');
+}
+/** `[Kind-Only]` Returns true if the given value is TThis */
+export function IsThis(value) {
+    return IsKindOf(value, 'This');
+}
+/** `[Kind-Only]` Returns true of this value is TTransform */
+export function IsTransform(value) {
+    return ValueGuard.IsObject(value) && TransformKind in value;
+}
+/** `[Kind-Only]` Returns true if the given value is TTuple */
+export function IsTuple(value) {
+    return IsKindOf(value, 'Tuple');
+}
+/** `[Kind-Only]` Returns true if the given value is TUndefined */
+export function IsUndefined(value) {
+    return IsKindOf(value, 'Undefined');
+}
+/** `[Kind-Only]` Returns true if the given value is TUnion */
+export function IsUnion(value) {
+    return IsKindOf(value, 'Union');
+}
+/** `[Kind-Only]` Returns true if the given value is TUint8Array */
+export function IsUint8Array(value) {
+    return IsKindOf(value, 'Uint8Array');
+}
+/** `[Kind-Only]` Returns true if the given value is TUnknown */
+export function IsUnknown(value) {
+    return IsKindOf(value, 'Unknown');
+}
+/** `[Kind-Only]` Returns true if the given value is a raw TUnsafe */
+export function IsUnsafe(value) {
+    return IsKindOf(value, 'Unsafe');
+}
+/** `[Kind-Only]` Returns true if the given value is TVoid */
+export function IsVoid(value) {
+    return IsKindOf(value, 'Void');
+}
+/** `[Kind-Only]` Returns true if the given value is TKind */
+export function IsKind(value) {
+    return ValueGuard.IsObject(value) && Kind in value && ValueGuard.IsString(value[Kind]);
+}
+/** `[Kind-Only]` Returns true if the given value is TSchema */
+export function IsSchema(value) {
+    // prettier-ignore
+    return (IsAny(value) ||
+        IsArray(value) ||
+        IsBoolean(value) ||
+        IsBigInt(value) ||
+        IsAsyncIterator(value) ||
+        IsConstructor(value) ||
+        IsDate(value) ||
+        IsFunction(value) ||
+        IsInteger(value) ||
+        IsIntersect(value) ||
+        IsIterator(value) ||
+        IsLiteral(value) ||
+        IsMappedKey(value) ||
+        IsMappedResult(value) ||
+        IsNever(value) ||
+        IsNot(value) ||
+        IsNull(value) ||
+        IsNumber(value) ||
+        IsObject(value) ||
+        IsPromise(value) ||
+        IsRecord(value) ||
+        IsRef(value) ||
+        IsRegExp(value) ||
+        IsString(value) ||
+        IsSymbol(value) ||
+        IsTemplateLiteral(value) ||
+        IsThis(value) ||
+        IsTuple(value) ||
+        IsUndefined(value) ||
+        IsUnion(value) ||
+        IsUint8Array(value) ||
+        IsUnknown(value) ||
+        IsUnsafe(value) ||
+        IsVoid(value) ||
+        IsKind(value));
+}

package/build/import/type/guard/type.d.mts

@@ -1,7 +1,7 @@
 import { Kind, Hint, TransformKind } from '../symbols/index.mjs';
 import { TypeBoxError } from '../error/index.mjs';
 import { TransformOptions } from '../transform/index.mjs';
-import { TTemplateLiteral, TTemplateLiteralKind } from '../template-literal/index.mjs';
+import { TTemplateLiteral } from '../template-literal/index.mjs';
 import { TArray } from '../array/index.mjs';
 import { TBoolean } from '../boolean/index.mjs';
 import type { TRecord } from '../record/index.mjs';
@@ -112,7 +112,7 @@ export declare function IsString(value: unknown): value is TString;
 /** Returns true if the given value is TSymbol */
 export declare function IsSymbol(value: unknown): value is TSymbol;
 /** Returns true if the given value is TTemplateLiteral */
-export declare function IsTemplateLiteral(value: unknown): value is TTemplateLiteral<TTemplateLiteralKind[]>;
+export declare function IsTemplateLiteral(value: unknown): value is TTemplateLiteral;
 /** Returns true if the given value is TThis */
 export declare function IsThis(value: unknown): value is TThis;
 /** Returns true of this value is TTransform */

package/build/import/type/indexed/indexed-from-mapped-result.mjs

@@ -3,9 +3,11 @@ import { IndexPropertyKeys } from './indexed-property-keys.mjs';
 import { Index } from './index.mjs';
 // prettier-ignore
 function FromProperties(T, P, options) {
-    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: Index(T, IndexPropertyKeys(P[K2]), options) };
-    }, {});
+    const Acc = {};
+    for (const K2 of Object.getOwnPropertyNames(P)) {
+        Acc[K2] = Index(T, IndexPropertyKeys(P[K2]), options);
+    }
+    return Acc;
 }
 // prettier-ignore
 function FromMappedResult(T, R, options) {

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

@@ -2,7 +2,7 @@ import { TemplateLiteralGenerate } from '../template-literal/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsTemplateLiteral, IsUnion, IsLiteral, IsNumber, IsInteger } from '../guard/type.mjs';
+import { IsTemplateLiteral, IsUnion, IsLiteral, IsNumber, IsInteger } from '../guard/kind.mjs';
 // prettier-ignore
 function FromTemplateLiteral(T) {
     const R = TemplateLiteralGenerate(T);
@@ -10,9 +10,10 @@ function FromTemplateLiteral(T) {
 }
 // prettier-ignore
 function FromUnion(T) {
-    return T.reduce((Acc, L) => {
-        return [...Acc, ...IndexPropertyKeys(L)];
-    }, []);
+    const Acc = [];
+    for (const L of T)
+        Acc.push(...IndexPropertyKeys(L));
+    return Acc;
 }
 // prettier-ignore
 function FromLiteral(T) {

package/build/import/type/indexed/indexed.mjs

@@ -8,7 +8,7 @@ import { IndexFromMappedResult } from './indexed-from-mapped-result.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsArray, IsIntersect, IsObject, IsMappedKey, IsMappedResult, IsNever, IsSchema, IsTuple, IsUnion } from '../guard/type.mjs';
+import { IsArray, IsIntersect, IsObject, IsMappedKey, IsMappedResult, IsNever, IsSchema, IsTuple, IsUnion } from '../guard/kind.mjs';
 // prettier-ignore
 function FromRest(T, K) {
     return T.map(L => IndexFromPropertyKey(L, K));

package/build/import/type/intersect/intersect-create.mjs

@@ -3,7 +3,7 @@ import { CloneType, CloneRest } from '../clone/type.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsObject, IsSchema } from '../guard/type.mjs';
+import { IsObject, IsSchema } from '../guard/kind.mjs';
 // ------------------------------------------------------------------
 // IntersectCreate
 // ------------------------------------------------------------------