@sinclair/typebox 0.32.24 → 0.32.26

package/build/require/type/guard/kind.d.ts

@@ -0,0 +1,136 @@
+import { Kind, Hint, TransformKind } from '../symbols/index';
+import { TransformOptions } from '../transform/index';
+import { TTemplateLiteral } from '../template-literal/index';
+import { TArray } from '../array/index';
+import { TBoolean } from '../boolean/index';
+import type { TRecord } from '../record/index';
+import type { TString } from '../string/index';
+import type { TUnion } from '../union/index';
+import type { TAny } from '../any/index';
+import type { TAsyncIterator } from '../async-iterator/index';
+import type { TBigInt } from '../bigint/index';
+import type { TConstructor } from '../constructor/index';
+import type { TFunction } from '../function/index';
+import type { TInteger } from '../integer/index';
+import type { TIntersect } from '../intersect/index';
+import type { TIterator } from '../iterator/index';
+import type { TLiteral } from '../literal/index';
+import type { TMappedKey, TMappedResult } from '../mapped/index';
+import type { TNever } from '../never/index';
+import type { TNot } from '../not/index';
+import type { TNull } from '../null/index';
+import type { TNumber } from '../number/index';
+import type { TObject, TProperties } from '../object/index';
+import type { TOptional } from '../optional/index';
+import type { TPromise } from '../promise/index';
+import type { TReadonly } from '../readonly/index';
+import type { TRef } from '../ref/index';
+import type { TRegExp } from '../regexp/index';
+import type { TSchema } from '../schema/index';
+import type { TSymbol } from '../symbol/index';
+import type { TTuple } from '../tuple/index';
+import type { TUint8Array } from '../uint8array/index';
+import type { TUndefined } from '../undefined/index';
+import type { TUnknown } from '../unknown/index';
+import type { TUnsafe } from '../unsafe/index';
+import type { TVoid } from '../void/index';
+import type { TDate } from '../date/index';
+import type { TThis } from '../recursive/index';
+/** `[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/require/type/guard/kind.js

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

package/build/require/type/guard/type.d.ts

@@ -1,7 +1,7 @@
 import { Kind, Hint, TransformKind } from '../symbols/index';
 import { TypeBoxError } from '../error/index';
 import { TransformOptions } from '../transform/index';
-import { TTemplateLiteral, TTemplateLiteralKind } from '../template-literal/index';
+import { TTemplateLiteral } from '../template-literal/index';
 import { TArray } from '../array/index';
 import { TBoolean } from '../boolean/index';
 import type { TRecord } from '../record/index';
@@ -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/require/type/indexed/indexed-from-mapped-result.js

@@ -7,9 +7,11 @@ const indexed_property_keys_1 = require("./indexed-property-keys");
 const index_2 = require("./index");
 // prettier-ignore
 function FromProperties(T, P, options) {
-    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: (0, index_2.Index)(T, (0, indexed_property_keys_1.IndexPropertyKeys)(P[K2]), options) };
-    }, {});
+    const Acc = {};
+    for (const K2 of Object.getOwnPropertyNames(P)) {
+        Acc[K2] = (0, index_2.Index)(T, (0, indexed_property_keys_1.IndexPropertyKeys)(P[K2]), options);
+    }
+    return Acc;
 }
 // prettier-ignore
 function FromMappedResult(T, R, options) {

package/build/require/type/indexed/indexed-property-keys.js

@@ -6,7 +6,7 @@ const index_1 = require("../template-literal/index");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-const type_1 = require("../guard/type");
+const kind_1 = require("../guard/kind");
 // prettier-ignore
 function FromTemplateLiteral(T) {
     const R = (0, index_1.TemplateLiteralGenerate)(T);
@@ -14,9 +14,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) {
@@ -26,11 +27,11 @@ function FromLiteral(T) {
 /** Returns a tuple of PropertyKeys derived from the given TSchema */
 // prettier-ignore
 function IndexPropertyKeys(T) {
-    return [...new Set(((0, type_1.IsTemplateLiteral)(T) ? FromTemplateLiteral(T) :
-            (0, type_1.IsUnion)(T) ? FromUnion(T.anyOf) :
-                (0, type_1.IsLiteral)(T) ? FromLiteral(T.const) :
-                    (0, type_1.IsNumber)(T) ? ['[number]'] :
-                        (0, type_1.IsInteger)(T) ? ['[number]'] :
+    return [...new Set(((0, kind_1.IsTemplateLiteral)(T) ? FromTemplateLiteral(T) :
+            (0, kind_1.IsUnion)(T) ? FromUnion(T.anyOf) :
+                (0, kind_1.IsLiteral)(T) ? FromLiteral(T.const) :
+                    (0, kind_1.IsNumber)(T) ? ['[number]'] :
+                        (0, kind_1.IsInteger)(T) ? ['[number]'] :
                             []))];
 }
 exports.IndexPropertyKeys = IndexPropertyKeys;

package/build/require/type/indexed/indexed.js

@@ -12,14 +12,14 @@ const indexed_from_mapped_result_1 = require("./indexed-from-mapped-result");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-const type_2 = require("../guard/type");
+const kind_1 = require("../guard/kind");
 // prettier-ignore
 function FromRest(T, K) {
     return T.map(L => IndexFromPropertyKey(L, K));
 }
 // prettier-ignore
 function FromIntersectRest(T) {
-    return T.filter(L => !(0, type_2.IsNever)(L));
+    return T.filter(L => !(0, kind_1.IsNever)(L));
 }
 // prettier-ignore
 function FromIntersect(T, K) {
@@ -27,7 +27,7 @@ function FromIntersect(T, K) {
 }
 // prettier-ignore
 function FromUnionRest(T) {
-    return (T.some(L => (0, type_2.IsNever)(L))
+    return (T.some(L => (0, kind_1.IsNever)(L))
         ? []
         : T);
 }
@@ -53,11 +53,11 @@ function FromProperty(T, K) {
 }
 // prettier-ignore
 function IndexFromPropertyKey(T, K) {
-    return ((0, type_2.IsIntersect)(T) ? FromIntersect(T.allOf, K) :
-        (0, type_2.IsUnion)(T) ? FromUnion(T.anyOf, K) :
-            (0, type_2.IsTuple)(T) ? FromTuple(T.items ?? [], K) :
-                (0, type_2.IsArray)(T) ? FromArray(T.items, K) :
-                    (0, type_2.IsObject)(T) ? FromProperty(T.properties, K) :
+    return ((0, kind_1.IsIntersect)(T) ? FromIntersect(T.allOf, K) :
+        (0, kind_1.IsUnion)(T) ? FromUnion(T.anyOf, K) :
+            (0, kind_1.IsTuple)(T) ? FromTuple(T.items ?? [], K) :
+                (0, kind_1.IsArray)(T) ? FromArray(T.items, K) :
+                    (0, kind_1.IsObject)(T) ? FromProperty(T.properties, K) :
                         (0, index_1.Never)());
 }
 exports.IndexFromPropertyKey = IndexFromPropertyKey;
@@ -73,9 +73,9 @@ function FromSchema(T, K) {
 /** `[Json]` Returns an Indexed property type for the given keys */
 function Index(T, K, options = {}) {
     // prettier-ignore
-    return ((0, type_2.IsMappedResult)(K) ? (0, type_1.CloneType)((0, indexed_from_mapped_result_1.IndexFromMappedResult)(T, K, options)) :
-        (0, type_2.IsMappedKey)(K) ? (0, type_1.CloneType)((0, indexed_from_mapped_key_1.IndexFromMappedKey)(T, K, options)) :
-            (0, type_2.IsSchema)(K) ? (0, type_1.CloneType)(FromSchema(T, (0, indexed_property_keys_1.IndexPropertyKeys)(K)), options) :
+    return ((0, kind_1.IsMappedResult)(K) ? (0, type_1.CloneType)((0, indexed_from_mapped_result_1.IndexFromMappedResult)(T, K, options)) :
+        (0, kind_1.IsMappedKey)(K) ? (0, type_1.CloneType)((0, indexed_from_mapped_key_1.IndexFromMappedKey)(T, K, options)) :
+            (0, kind_1.IsSchema)(K) ? (0, type_1.CloneType)(FromSchema(T, (0, indexed_property_keys_1.IndexPropertyKeys)(K)), options) :
                 (0, type_1.CloneType)(FromSchema(T, K), options));
 }
 exports.Index = Index;

package/build/require/type/intersect/intersect-create.js

@@ -7,17 +7,17 @@ const type_1 = require("../clone/type");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-const type_2 = require("../guard/type");
+const kind_1 = require("../guard/kind");
 // ------------------------------------------------------------------
 // IntersectCreate
 // ------------------------------------------------------------------
 // prettier-ignore
 function IntersectCreate(T, options) {
-    const allObjects = T.every((schema) => (0, type_2.IsObject)(schema));
-    const clonedUnevaluatedProperties = (0, type_2.IsSchema)(options.unevaluatedProperties)
+    const allObjects = T.every((schema) => (0, kind_1.IsObject)(schema));
+    const clonedUnevaluatedProperties = (0, kind_1.IsSchema)(options.unevaluatedProperties)
         ? { unevaluatedProperties: (0, type_1.CloneType)(options.unevaluatedProperties) }
         : {};
-    return ((options.unevaluatedProperties === false || (0, type_2.IsSchema)(options.unevaluatedProperties) || allObjects
+    return ((options.unevaluatedProperties === false || (0, kind_1.IsSchema)(options.unevaluatedProperties) || allObjects
         ? { ...options, ...clonedUnevaluatedProperties, [index_1.Kind]: 'Intersect', type: 'object', allOf: (0, type_1.CloneRest)(T) }
         : { ...options, ...clonedUnevaluatedProperties, [index_1.Kind]: 'Intersect', allOf: (0, type_1.CloneRest)(T) }));
 }

package/build/require/type/intersect/intersect-evaluated.js

@@ -11,11 +11,10 @@ const intersect_create_1 = require("./intersect-create");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
-const type_2 = require("../guard/type");
+const kind_1 = require("../guard/kind");
 // prettier-ignore
 function IsIntersectOptional(T) {
-    return T.every(L => (0, type_2.IsOptional)(L));
+    return T.every(L => (0, kind_1.IsOptional)(L));
 }
 // prettier-ignore
 function RemoveOptionalFromType(T) {
@@ -23,7 +22,7 @@ function RemoveOptionalFromType(T) {
 }
 // prettier-ignore
 function RemoveOptionalFromRest(T) {
-    return T.map(L => (0, type_2.IsOptional)(L) ? RemoveOptionalFromType(L) : L);
+    return T.map(L => (0, kind_1.IsOptional)(L) ? RemoveOptionalFromType(L) : L);
 }
 // prettier-ignore
 function ResolveIntersect(T, options) {
@@ -37,7 +36,7 @@ function IntersectEvaluated(T, options = {}) {
         return (0, index_3.Never)(options);
     if (T.length === 1)
         return (0, type_1.CloneType)(T[0], options);
-    if (T.some((schema) => (0, type_2.IsTransform)(schema)))
+    if (T.some((schema) => (0, kind_1.IsTransform)(schema)))
         throw new Error('Cannot intersect transform types');
     return ResolveIntersect(T, options);
 }

package/build/require/type/intersect/intersect.js

@@ -8,14 +8,14 @@ const intersect_create_1 = require("./intersect-create");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-const type_2 = require("../guard/type");
+const kind_1 = require("../guard/kind");
 /** `[Json]` Creates an evaluated Intersect type */
 function Intersect(T, options = {}) {
     if (T.length === 0)
         return (0, index_1.Never)(options);
     if (T.length === 1)
         return (0, type_1.CloneType)(T[0], options);
-    if (T.some((schema) => (0, type_2.IsTransform)(schema)))
+    if (T.some((schema) => (0, kind_1.IsTransform)(schema)))
         throw new Error('Cannot intersect transform types');
     return (0, intersect_create_1.IntersectCreate)(T, options);
 }

package/build/require/type/intrinsic/intrinsic.js

@@ -9,7 +9,7 @@ const index_3 = require("../union/index");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-const type_1 = require("../guard/type");
+const kind_1 = require("../guard/kind");
 // ------------------------------------------------------------------
 // Apply
 // ------------------------------------------------------------------
@@ -57,11 +57,11 @@ function Intrinsic(schema, mode, options = {}) {
     // prettier-ignore
     return (
     // Intrinsic-Mapped-Inference
-    (0, type_1.IsMappedKey)(schema) ? (0, intrinsic_from_mapped_key_1.IntrinsicFromMappedKey)(schema, mode, options) :
+    (0, kind_1.IsMappedKey)(schema) ? (0, intrinsic_from_mapped_key_1.IntrinsicFromMappedKey)(schema, mode, options) :
         // Standard-Inference
-        (0, type_1.IsTemplateLiteral)(schema) ? FromTemplateLiteral(schema, mode, schema) :
-            (0, type_1.IsUnion)(schema) ? (0, index_3.Union)(FromRest(schema.anyOf, mode), options) :
-                (0, type_1.IsLiteral)(schema) ? (0, index_2.Literal)(FromLiteralValue(schema.const, mode), options) :
+        (0, kind_1.IsTemplateLiteral)(schema) ? FromTemplateLiteral(schema, mode, schema) :
+            (0, kind_1.IsUnion)(schema) ? (0, index_3.Union)(FromRest(schema.anyOf, mode), options) :
+                (0, kind_1.IsLiteral)(schema) ? (0, index_2.Literal)(FromLiteralValue(schema.const, mode), options) :
                     schema);
 }
 exports.Intrinsic = Intrinsic;

package/build/require/type/keyof/keyof-from-mapped-result.js

@@ -6,9 +6,10 @@ const index_1 = require("../mapped/index");
 const keyof_1 = require("./keyof");
 // prettier-ignore
 function FromProperties(K, options) {
-    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: (0, keyof_1.KeyOf)(K[K2], options) };
-    }, {});
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(K))
+        Acc[K2] = (0, keyof_1.KeyOf)(K[K2], options);
+    return Acc;
 }
 // prettier-ignore
 function FromMappedResult(R, options) {