@sinclair/typebox 0.32.24 → 0.32.25

package/build/import/value/transform/decode.mjs

@@ -65,21 +65,21 @@ function FromIntersect(schema, references, path, value) {
     if (!IsStandardObject(value) || IsValueType(value))
         return Default(schema, path, value);
     const knownKeys = KeyOfPropertyKeys(schema);
-    const knownProperties = knownKeys.reduce((value, key) => {
-        return (key in value)
-            ? { ...value, [key]: Visit(Index(schema, [key]), references, `${path}/${key}`, value[key]) }
-            : value;
-    }, value);
+    const knownProperties = { ...value };
+    for (const key of knownKeys)
+        if (key in knownProperties) {
+            knownProperties[key] = Visit(Index(schema, [key]), references, `${path}/${key}`, knownProperties[key]);
+        }
     if (!IsTransform(schema.unevaluatedProperties)) {
         return Default(schema, path, knownProperties);
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const unevaluatedProperties = schema.unevaluatedProperties;
-    const unknownProperties = unknownKeys.reduce((value, key) => {
-        return !knownKeys.includes(key)
-            ? { ...value, [key]: Default(unevaluatedProperties, `${path}/${key}`, value[key]) }
-            : value;
-    }, knownProperties);
+    const unknownProperties = { ...knownProperties };
+    for (const key of unknownKeys)
+        if (!knownKeys.includes(key)) {
+            unknownProperties[key] = Default(unevaluatedProperties, `${path}/${key}`, unknownProperties[key]);
+        }
     return Default(schema, path, unknownProperties);
 }
 function FromNot(schema, references, path, value) {
@@ -90,21 +90,21 @@ function FromObject(schema, references, path, value) {
     if (!IsStandardObject(value))
         return Default(schema, path, value);
     const knownKeys = KeyOfPropertyKeys(schema);
-    const knownProperties = knownKeys.reduce((value, key) => {
-        return (key in value)
-            ? { ...value, [key]: Visit(schema.properties[key], references, `${path}/${key}`, value[key]) }
-            : value;
-    }, value);
+    const knownProperties = { ...value };
+    for (const key of knownKeys)
+        if (key in knownProperties) {
+            knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
+        }
     if (!IsSchema(schema.additionalProperties)) {
         return Default(schema, path, knownProperties);
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const additionalProperties = schema.additionalProperties;
-    const unknownProperties = unknownKeys.reduce((value, key) => {
-        return !knownKeys.includes(key)
-            ? { ...value, [key]: Default(additionalProperties, `${path}/${key}`, value[key]) }
-            : value;
-    }, knownProperties);
+    const unknownProperties = { ...knownProperties };
+    for (const key of unknownKeys)
+        if (!knownKeys.includes(key)) {
+            unknownProperties[key] = Default(additionalProperties, `${path}/${key}`, unknownProperties[key]);
+        }
     return Default(schema, path, unknownProperties);
 }
 // prettier-ignore
@@ -113,21 +113,21 @@ function FromRecord(schema, references, path, value) {
         return Default(schema, path, value);
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const knownKeys = new RegExp(pattern);
-    const knownProperties = Object.getOwnPropertyNames(value).reduce((value, key) => {
-        return knownKeys.test(key)
-            ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, `${path}/${key}`, value[key]) }
-            : value;
-    }, value);
+    const knownProperties = { ...value };
+    for (const key of Object.getOwnPropertyNames(value))
+        if (knownKeys.test(key)) {
+            knownProperties[key] = Visit(schema.patternProperties[pattern], references, `${path}/${key}`, knownProperties[key]);
+        }
     if (!IsSchema(schema.additionalProperties)) {
         return Default(schema, path, knownProperties);
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const additionalProperties = schema.additionalProperties;
-    const unknownProperties = unknownKeys.reduce((value, key) => {
-        return !knownKeys.test(key)
-            ? { ...value, [key]: Default(additionalProperties, `${path}/${key}`, value[key]) }
-            : value;
-    }, knownProperties);
+    const unknownProperties = { ...knownProperties };
+    for (const key of unknownKeys)
+        if (!knownKeys.test(key)) {
+            unknownProperties[key] = Default(additionalProperties, `${path}/${key}`, unknownProperties[key]);
+        }
     return Default(schema, path, unknownProperties);
 }
 // prettier-ignore

package/build/import/value/transform/encode.mjs

@@ -66,21 +66,22 @@ function FromIntersect(schema, references, path, value) {
     if (!IsStandardObject(value) || IsValueType(value))
         return defaulted;
     const knownKeys = KeyOfPropertyKeys(schema);
-    const knownProperties = knownKeys.reduce((value, key) => {
-        return key in defaulted
-            ? { ...value, [key]: Visit(Index(schema, [key]), references, `${path}/${key}`, value[key]) }
-            : value;
-    }, defaulted);
+    const knownProperties = { ...defaulted };
+    for (const key of knownKeys)
+        if (key in knownProperties) {
+            knownProperties[key] = Visit(Index(schema, [key]), references, `${path}/${key}`, knownProperties[key]);
+        }
     if (!IsTransform(schema.unevaluatedProperties)) {
         return Default(schema, path, knownProperties);
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const unevaluatedProperties = schema.unevaluatedProperties;
-    return unknownKeys.reduce((value, key) => {
-        return !knownKeys.includes(key)
-            ? { ...value, [key]: Default(unevaluatedProperties, `${path}/${key}`, value[key]) }
-            : value;
-    }, knownProperties);
+    const properties = { ...knownProperties };
+    for (const key of unknownKeys)
+        if (!knownKeys.includes(key)) {
+            properties[key] = Default(unevaluatedProperties, `${path}/${key}`, properties[key]);
+        }
+    return properties;
 }
 // prettier-ignore
 function FromNot(schema, references, path, value) {
@@ -92,21 +93,22 @@ function FromObject(schema, references, path, value) {
     if (!IsStandardObject(value))
         return defaulted;
     const knownKeys = KeyOfPropertyKeys(schema);
-    const knownProperties = knownKeys.reduce((value, key) => {
-        return key in value
-            ? { ...value, [key]: Visit(schema.properties[key], references, `${path}/${key}`, value[key]) }
-            : value;
-    }, defaulted);
+    const knownProperties = { ...defaulted };
+    for (const key of knownKeys)
+        if (key in value) {
+            knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
+        }
     if (!IsSchema(schema.additionalProperties)) {
         return knownProperties;
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const additionalProperties = schema.additionalProperties;
-    return unknownKeys.reduce((value, key) => {
-        return !knownKeys.includes(key)
-            ? { ...value, [key]: Default(additionalProperties, `${path}/${key}`, value[key]) }
-            : value;
-    }, knownProperties);
+    const properties = { ...knownProperties };
+    for (const key of unknownKeys)
+        if (!knownKeys.includes(key)) {
+            properties[key] = Default(additionalProperties, `${path}/${key}`, properties[key]);
+        }
+    return properties;
 }
 // prettier-ignore
 function FromRecord(schema, references, path, value) {
@@ -115,21 +117,22 @@ function FromRecord(schema, references, path, value) {
         return defaulted;
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const knownKeys = new RegExp(pattern);
-    const knownProperties = Object.getOwnPropertyNames(value).reduce((value, key) => {
-        return knownKeys.test(key)
-            ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, `${path}/${key}`, value[key]) }
-            : value;
-    }, defaulted);
+    const knownProperties = { ...defaulted };
+    for (const key of Object.getOwnPropertyNames(value))
+        if (knownKeys.test(key)) {
+            knownProperties[key] = Visit(schema.patternProperties[pattern], references, `${path}/${key}`, knownProperties[key]);
+        }
     if (!IsSchema(schema.additionalProperties)) {
         return Default(schema, path, knownProperties);
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const additionalProperties = schema.additionalProperties;
-    return unknownKeys.reduce((value, key) => {
-        return !knownKeys.test(key)
-            ? { ...value, [key]: Default(additionalProperties, `${path}/${key}`, value[key]) }
-            : value;
-    }, knownProperties);
+    const properties = { ...knownProperties };
+    for (const key of unknownKeys)
+        if (!knownKeys.test(key)) {
+            properties[key] = Default(additionalProperties, `${path}/${key}`, properties[key]);
+        }
+    return properties;
 }
 // prettier-ignore
 function FromRef(schema, references, path, value) {

package/build/require/type/awaited/awaited.js

@@ -8,7 +8,7 @@ const type_1 = require("../clone/type");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-const type_2 = require("../guard/type");
+const kind_1 = require("../guard/kind");
 // prettier-ignore
 function FromRest(T) {
     return T.map(L => AwaitedResolve(L));
@@ -30,9 +30,9 @@ function FromPromise(T) {
 // ----------------------------------------------------------------
 // prettier-ignore
 function AwaitedResolve(T) {
-    return ((0, type_2.IsIntersect)(T) ? FromIntersect(T.allOf) :
-        (0, type_2.IsUnion)(T) ? FromUnion(T.anyOf) :
-            (0, type_2.IsPromise)(T) ? FromPromise(T.item) :
+    return ((0, kind_1.IsIntersect)(T) ? FromIntersect(T.allOf) :
+        (0, kind_1.IsUnion)(T) ? FromUnion(T.anyOf) :
+            (0, kind_1.IsPromise)(T) ? FromPromise(T.item) :
                 T);
 }
 /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */

package/build/require/type/clone/value.js

@@ -16,9 +16,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/require/type/composite/composite.js

@@ -10,28 +10,32 @@ const index_5 = require("../sets/index");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-const type_1 = require("../guard/type");
+const kind_1 = require("../guard/kind");
 // prettier-ignore
 function CompositeKeys(T) {
-    return (0, index_5.SetDistinct)(T.reduce((Acc, L) => {
-        return ([...Acc, ...(0, index_3.KeyOfPropertyKeys)(L)]);
-    }, []));
+    const Acc = [];
+    for (const L of T)
+        Acc.push(...(0, index_3.KeyOfPropertyKeys)(L));
+    return (0, index_5.SetDistinct)(Acc);
 }
 // prettier-ignore
 function FilterNever(T) {
-    return T.filter(L => !(0, type_1.IsNever)(L));
+    return T.filter(L => !(0, kind_1.IsNever)(L));
 }
 // prettier-ignore
 function CompositeProperty(T, K) {
-    return FilterNever(T.reduce((Acc, L) => {
-        return [...Acc, ...(0, index_2.IndexFromPropertyKeys)(L, [K])];
-    }, []));
+    const Acc = [];
+    for (const L of T)
+        Acc.push(...(0, index_2.IndexFromPropertyKeys)(L, [K]));
+    return FilterNever(Acc);
 }
 // prettier-ignore
 function CompositeProperties(T, K) {
-    return K.reduce((Acc, L) => {
-        return { ...Acc, [L]: (0, index_1.IntersectEvaluated)(CompositeProperty(T, L)) };
-    }, {});
+    const Acc = {};
+    for (const L of K) {
+        Acc[L] = (0, index_1.IntersectEvaluated)(CompositeProperty(T, L));
+    }
+    return Acc;
 }
 // prettier-ignore
 function Composite(T, options = {}) {

package/build/require/type/const/const.js

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

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

@@ -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/require/type/deref/deref.js

@@ -8,15 +8,17 @@ const value_1 = require("../guard/value");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-const type_2 = require("../guard/type");
+const kind_1 = require("../guard/kind");
 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) {
@@ -82,17 +84,17 @@ function FromRef(schema, references) {
 }
 // prettier-ignore
 function DerefResolve(schema, references) {
-    return ((0, type_2.IsConstructor)(schema) ? FromConstructor(schema, references) :
-        (0, type_2.IsFunction)(schema) ? FromFunction(schema, references) :
-            (0, type_2.IsIntersect)(schema) ? FromIntersect(schema, references) :
-                (0, type_2.IsUnion)(schema) ? FromUnion(schema, references) :
-                    (0, type_2.IsTuple)(schema) ? FromTuple(schema, references) :
-                        (0, type_2.IsArray)(schema) ? FromArray(schema, references) :
-                            (0, type_2.IsObject)(schema) ? FromObject(schema, references) :
-                                (0, type_2.IsPromise)(schema) ? FromPromise(schema, references) :
-                                    (0, type_2.IsAsyncIterator)(schema) ? FromAsyncIterator(schema, references) :
-                                        (0, type_2.IsIterator)(schema) ? FromIterator(schema, references) :
-                                            (0, type_2.IsRef)(schema) ? FromRef(schema, references) :
+    return ((0, kind_1.IsConstructor)(schema) ? FromConstructor(schema, references) :
+        (0, kind_1.IsFunction)(schema) ? FromFunction(schema, references) :
+            (0, kind_1.IsIntersect)(schema) ? FromIntersect(schema, references) :
+                (0, kind_1.IsUnion)(schema) ? FromUnion(schema, references) :
+                    (0, kind_1.IsTuple)(schema) ? FromTuple(schema, references) :
+                        (0, kind_1.IsArray)(schema) ? FromArray(schema, references) :
+                            (0, kind_1.IsObject)(schema) ? FromObject(schema, references) :
+                                (0, kind_1.IsPromise)(schema) ? FromPromise(schema, references) :
+                                    (0, kind_1.IsAsyncIterator)(schema) ? FromAsyncIterator(schema, references) :
+                                        (0, kind_1.IsIterator)(schema) ? FromIterator(schema, references) :
+                                            (0, kind_1.IsRef)(schema) ? FromRef(schema, references) :
                                                 schema);
 }
 // ------------------------------------------------------------------

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

@@ -6,9 +6,10 @@ const index_1 = require("../mapped/index");
 const exclude_1 = require("./exclude");
 // prettier-ignore
 function FromProperties(P, U) {
-    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: (0, exclude_1.Exclude)(P[K2], U) };
-    }, {});
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = (0, exclude_1.Exclude)(P[K2], U);
+    return Acc;
 }
 // prettier-ignore
 function FromMappedResult(R, T) {

package/build/require/type/exclude/exclude.js

@@ -11,7 +11,7 @@ const exclude_from_template_literal_1 = require("./exclude-from-template-literal
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-const type_2 = require("../guard/type");
+const kind_1 = require("../guard/kind");
 function ExcludeRest(L, R) {
     const excluded = L.filter((inner) => (0, index_3.ExtendsCheck)(inner, R) === index_3.ExtendsResult.False);
     return excluded.length === 1 ? excluded[0] : (0, index_1.Union)(excluded);
@@ -19,12 +19,12 @@ function ExcludeRest(L, R) {
 /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
 function Exclude(L, R, options = {}) {
     // overloads
-    if ((0, type_2.IsTemplateLiteral)(L))
+    if ((0, kind_1.IsTemplateLiteral)(L))
         return (0, type_1.CloneType)((0, exclude_from_template_literal_1.ExcludeFromTemplateLiteral)(L, R), options);
-    if ((0, type_2.IsMappedResult)(L))
+    if ((0, kind_1.IsMappedResult)(L))
         return (0, type_1.CloneType)((0, exclude_from_mapped_result_1.ExcludeFromMappedResult)(L, R), options);
     // prettier-ignore
-    return (0, type_1.CloneType)((0, type_2.IsUnion)(L) ? ExcludeRest(L.anyOf, R) :
+    return (0, type_1.CloneType)((0, kind_1.IsUnion)(L) ? ExcludeRest(L.anyOf, R) :
         (0, index_3.ExtendsCheck)(L, R) !== index_3.ExtendsResult.False ? (0, index_2.Never)() : L, options);
 }
 exports.Exclude = Exclude;

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

@@ -6,9 +6,10 @@ const index_1 = require("../mapped/index");
 const extends_1 = require("./extends");
 // prettier-ignore
 function FromProperties(P, Right, True, False, options) {
-    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: (0, extends_1.Extends)(P[K2], Right, True, False, options) };
-    }, {});
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = (0, extends_1.Extends)(P[K2], Right, True, False, options);
+    return Acc;
 }
 // prettier-ignore
 function FromMappedResult(Left, Right, True, False, options) {

package/build/require/type/extends/extends.js

@@ -10,7 +10,7 @@ const extends_from_mapped_result_1 = require("./extends-from-mapped-result");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-const type_2 = require("../guard/type");
+const kind_1 = require("../guard/kind");
 // prettier-ignore
 function ExtendsResolve(left, right, trueType, falseType) {
     const R = (0, extends_check_1.ExtendsCheck)(left, right);
@@ -21,8 +21,8 @@ function ExtendsResolve(left, right, trueType, falseType) {
 /** `[Json]` Creates a Conditional type */
 function Extends(L, R, T, F, options = {}) {
     // prettier-ignore
-    return ((0, type_2.IsMappedResult)(L) ? (0, extends_from_mapped_result_1.ExtendsFromMappedResult)(L, R, T, F, options) :
-        (0, type_2.IsMappedKey)(L) ? (0, type_1.CloneType)((0, extends_from_mapped_key_1.ExtendsFromMappedKey)(L, R, T, F, options)) :
+    return ((0, kind_1.IsMappedResult)(L) ? (0, extends_from_mapped_result_1.ExtendsFromMappedResult)(L, R, T, F, options) :
+        (0, kind_1.IsMappedKey)(L) ? (0, type_1.CloneType)((0, extends_from_mapped_key_1.ExtendsFromMappedKey)(L, R, T, F, options)) :
             (0, type_1.CloneType)(ExtendsResolve(L, R, T, F), options));
 }
 exports.Extends = Extends;

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

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

package/build/require/type/extract/extract.js

@@ -11,7 +11,7 @@ const extract_from_template_literal_1 = require("./extract-from-template-literal
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-const type_2 = require("../guard/type");
+const kind_1 = require("../guard/kind");
 function ExtractRest(L, R) {
     const extracted = L.filter((inner) => (0, index_3.ExtendsCheck)(inner, R) !== index_3.ExtendsResult.False);
     return extracted.length === 1 ? extracted[0] : (0, index_1.Union)(extracted);
@@ -19,12 +19,12 @@ function ExtractRest(L, R) {
 /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
 function Extract(L, R, options = {}) {
     // overloads
-    if ((0, type_2.IsTemplateLiteral)(L))
+    if ((0, kind_1.IsTemplateLiteral)(L))
         return (0, type_1.CloneType)((0, extract_from_template_literal_1.ExtractFromTemplateLiteral)(L, R), options);
-    if ((0, type_2.IsMappedResult)(L))
+    if ((0, kind_1.IsMappedResult)(L))
         return (0, type_1.CloneType)((0, extract_from_mapped_result_1.ExtractFromMappedResult)(L, R), options);
     // prettier-ignore
-    return (0, type_1.CloneType)((0, type_2.IsUnion)(L) ? ExtractRest(L.anyOf, R) :
+    return (0, type_1.CloneType)((0, kind_1.IsUnion)(L) ? ExtractRest(L.anyOf, R) :
         (0, index_3.ExtendsCheck)(L, R) !== index_3.ExtendsResult.False ? L : (0, index_2.Never)(), options);
 }
 exports.Extract = Extract;

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

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

package/build/require/type/guard/index.js

@@ -1,6 +1,7 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueGuard = exports.TypeGuard = void 0;
+exports.ValueGuard = exports.TypeGuard = exports.KindGuard = void 0;
+exports.KindGuard = require("./kind");
 exports.TypeGuard = require("./type");
 exports.ValueGuard = require("./value");