typebox 1.0.31 → 1.0.33

package/build/cjs/type/engine/evaluate/distribute.js

@@ -0,0 +1,56 @@
+"use strict";
+// deno-fmt-ignore-file
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Distribute = Distribute;
+const index_1 = require("../../../guard/index");
+const schema_1 = require("../../types/schema");
+const intersect_1 = require("../../types/intersect");
+const union_1 = require("../../types/union");
+const object_1 = require("../../types/object");
+const tuple_1 = require("../../types/tuple");
+const composite_1 = require("./composite");
+const narrow_1 = require("./narrow");
+const evaluate_1 = require("./evaluate");
+const evaluate_2 = require("./evaluate");
+function CanDistribute(type) {
+    return (0, object_1.IsObject)(type) || (0, tuple_1.IsTuple)(type);
+}
+function DistributeNormalize(type) {
+    return ((0, intersect_1.IsIntersect)(type)
+        ? (0, evaluate_2.EvaluateIntersect)(type.allOf)
+        : type);
+}
+function DistributeOperation(left, right) {
+    const normalLeft = DistributeNormalize(left);
+    const normalRight = DistributeNormalize(right);
+    const isObjectLeft = CanDistribute(normalLeft);
+    const IsObjectRight = CanDistribute(normalRight);
+    const result = (isObjectLeft && IsObjectRight ? (0, composite_1.Composite)((0, evaluate_1.EvaluateType)(normalLeft), normalRight) :
+        isObjectLeft && !IsObjectRight ? (0, evaluate_1.EvaluateType)(normalLeft) :
+            !isObjectLeft && IsObjectRight ? normalRight :
+                (0, narrow_1.Narrow)((0, evaluate_1.EvaluateType)(normalLeft), normalRight));
+    return result;
+}
+function DistributeType(type, types, result = []) {
+    const [left, ...right] = types;
+    return (!index_1.Guard.IsUndefined(left) // TSchema[]
+        ? DistributeType(type, right, [...result, DistributeOperation(type, left)])
+        : result.length === 0
+            ? [type]
+            : result);
+}
+function DistributeUnion(types, distribution, result = []) {
+    const [left, ...right] = types;
+    return ((0, schema_1.IsSchema)(left)
+        ? DistributeUnion(right, distribution, [...result, ...Distribute([left], distribution)])
+        : result);
+}
+function Distribute(types, result = []) {
+    const [left, ...right] = types;
+    return ((0, schema_1.IsSchema)(left)
+        ? (0, union_1.IsUnion)(left)
+            ? Distribute(right, DistributeUnion(left.anyOf, result))
+            : Distribute(right, DistributeType(left, result))
+        : result);
+}

package/build/cjs/type/engine/evaluate/evaluate.d.ts

@@ -0,0 +1,11 @@
+import { type TSchema } from '../../types/schema';
+import { type TIntersect } from '../../types/intersect';
+import { type TUnion } from '../../types/union';
+import { type TDistribute } from './distribute';
+import { type TBroaden } from './broaden';
+export type TEvaluateIntersect<Types extends TSchema[], Distribution extends TSchema[] = TDistribute<Types>, Result extends TSchema = TBroaden<Distribution>> = Result;
+export declare function EvaluateIntersect<Types extends TSchema[]>(types: [...Types]): TEvaluateIntersect<Types>;
+export type TEvaluateUnion<Types extends TSchema[], Result extends TSchema = TBroaden<Types>> = Result;
+export declare function EvaluateUnion<Types extends TSchema[]>(types: [...Types]): TEvaluateUnion<Types>;
+export type TEvaluateType<Type extends TSchema, Result extends TSchema = (Type extends TIntersect<infer Types extends TSchema[]> ? TEvaluateIntersect<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TEvaluateUnion<Types> : Type)> = Result;
+export declare function EvaluateType<Type extends TSchema>(type: Type): TEvaluateType<Type>;

package/build/cjs/type/engine/evaluate/evaluate.js

@@ -0,0 +1,24 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateIntersect = EvaluateIntersect;
+exports.EvaluateUnion = EvaluateUnion;
+exports.EvaluateType = EvaluateType;
+const intersect_1 = require("../../types/intersect");
+const union_1 = require("../../types/union");
+const distribute_1 = require("./distribute");
+const broaden_1 = require("./broaden");
+function EvaluateIntersect(types) {
+    const distribution = (0, distribute_1.Distribute)(types);
+    const result = (0, broaden_1.Broaden)(distribution);
+    return result;
+}
+function EvaluateUnion(types) {
+    const result = (0, broaden_1.Broaden)(types);
+    return result;
+}
+function EvaluateType(type) {
+    return ((0, intersect_1.IsIntersect)(type) ? EvaluateIntersect(type.allOf) :
+        (0, union_1.IsUnion)(type) ? EvaluateUnion(type.anyOf) :
+            type);
+}

package/build/cjs/type/engine/evaluate/flatten.d.ts

@@ -0,0 +1,6 @@
+import { TSchema } from '../../types/schema';
+import { type TUnion } from '../../types/union';
+type TFlattenType<Type extends TSchema, Result extends TSchema[] = Type extends TUnion<infer Types extends TSchema[]> ? TFlatten<Types> : [Type]> = Result;
+export type TFlatten<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFlatten<Right, [...Result, ...TFlattenType<Left>]> : Result);
+export declare function Flatten<Types extends TSchema[]>(types: [...Types]): TFlatten<Types>;
+export {};

package/build/cjs/type/engine/evaluate/flatten.js

@@ -0,0 +1,14 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Flatten = Flatten;
+const union_1 = require("../../types/union");
+function FlattenType(type) {
+    const result = (0, union_1.IsUnion)(type) ? Flatten(type.anyOf) : [type];
+    return result;
+}
+function Flatten(types) {
+    return types.reduce((result, type) => {
+        return [...result, ...FlattenType(type)];
+    }, []);
+}

package/build/cjs/type/engine/evaluate/index.d.ts

@@ -0,0 +1,8 @@
+export * from './broaden';
+export * from './compare';
+export * from './composite';
+export * from './distribute';
+export * from './evaluate';
+export * from './flatten';
+export * from './instantiate';
+export * from './narrow';

package/build/cjs/type/engine/evaluate/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./broaden"), exports);
+__exportStar(require("./compare"), exports);
+__exportStar(require("./composite"), exports);
+__exportStar(require("./distribute"), exports);
+__exportStar(require("./evaluate"), exports);
+__exportStar(require("./flatten"), exports);
+__exportStar(require("./instantiate"), exports);
+__exportStar(require("./narrow"), exports);

package/build/cjs/type/engine/evaluate/instantiate.d.ts

@@ -0,0 +1,8 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema';
+import { type TProperties } from '../../types/properties';
+import { type TState, type TInstantiateType } from '../instantiate';
+import { type TEvaluateType } from './evaluate';
+type TEvaluateImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TEvaluateType<InstantiatedType>;
+export type TEvaluateInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TEvaluateImmediate<Context, State, Type>;
+export declare function EvaluateInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TEvaluateInstantiate<Context, State, Type>;
+export {};

package/build/cjs/type/engine/evaluate/instantiate.js

@@ -0,0 +1,20 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateInstantiate = EvaluateInstantiate;
+const index_1 = require("../../../system/memory/index");
+const instantiate_1 = require("../instantiate");
+const evaluate_1 = require("./evaluate");
+function EvaluateImmediate(context, state, type, options) {
+    const instantiatedType = (0, instantiate_1.InstantiateType)(context, state, type);
+    return index_1.Memory.Update((0, evaluate_1.EvaluateType)(instantiatedType), {}, options);
+}
+function EvaluateInstantiate(context, state, type, options) {
+    return (
+    // [instantiation-rule]
+    //
+    // Evaluate instantiation should never defer on instantiate as the caller is specifically 
+    // requesting that the type be evaluated in whatever context is available. However, actions 
+    // embedded in the Evaluate call may defer local to themselves.
+    EvaluateImmediate(context, state, type, options));
+}

package/build/cjs/type/engine/evaluate/narrow.d.ts

@@ -0,0 +1,5 @@
+import { TSchema } from '../../types/schema';
+import { TNever } from "../../types/never";
+import { TCompare, TCompareResult, ResultLeftInside, ResultRightInside, ResultEqual } from "./compare";
+export type TNarrow<Left extends TSchema, Right extends TSchema, Result extends TCompareResult = TCompare<Left, Right>> = (Result extends typeof ResultLeftInside ? Left : Result extends typeof ResultRightInside ? Right : Result extends typeof ResultEqual ? Right : TNever);
+export declare function Narrow<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TNarrow<Left, Right>;

package/build/cjs/type/engine/evaluate/narrow.js

@@ -0,0 +1,14 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Narrow = Narrow;
+const index_1 = require("../../../guard/index");
+const never_1 = require("../../types/never");
+const compare_1 = require("./compare");
+function Narrow(left, right) {
+    const result = (0, compare_1.Compare)(left, right);
+    return (index_1.Guard.IsEqual(result, compare_1.ResultLeftInside) ? left :
+        index_1.Guard.IsEqual(result, compare_1.ResultRightInside) ? right :
+            index_1.Guard.IsEqual(result, compare_1.ResultEqual) ? right :
+                (0, never_1.Never)());
+}

package/build/cjs/type/engine/exclude/index.d.ts

@@ -0,0 +1 @@
+export * from './instantiate';

package/build/cjs/type/engine/exclude/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./instantiate"), exports);

package/build/cjs/type/engine/exclude/instantiate.d.ts

@@ -0,0 +1,16 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema';
+import { type TProperties } from '../../types/properties';
+import { type TEnum, type TEnumValue } from '../../types/enum';
+import { type TUnion } from '../../types/union';
+import { type TExtends, ExtendsResult } from '../../extends/index';
+import { type TEnumValuesToVariants } from '../enum/index';
+import { type TEvaluateUnion, type TFlatten } from '../evaluate/index';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate';
+import { type TExcludeDeferred } from '../../action/exclude';
+type TExcludeUnion<Types extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Types extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExcludeUnion<Tail, Right, [...Result, ...TExcludeType<Head, Right>]> : Result);
+type TExcludeType<Left extends TSchema, Right extends TSchema, Check extends ExtendsResult.TResult = TExtends<{}, Left, Right>, Result extends TSchema[] = Check extends ExtendsResult.TExtendsTrueLike<infer _> ? [] : [Left]> = Result;
+type TExcludeAction<Left extends TSchema, Right extends TSchema, Remaining extends TSchema[] = (Left extends TEnum<infer Values extends TEnumValue[]> ? TExcludeUnion<TEnumValuesToVariants<Values>, Right> : Left extends TUnion<infer Types extends TSchema[]> ? TExcludeUnion<TFlatten<Types>, Right> : TExcludeType<Left, Right>), Result extends TSchema = TEvaluateUnion<Remaining>> = Result;
+type TExcludeImmediate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, InstantiatedLeft extends TSchema = TInstantiateType<Context, State, Left>, InstantiatedRight extends TSchema = TInstantiateType<Context, State, Right>> = TExcludeAction<InstantiatedLeft, InstantiatedRight>;
+export type TExcludeInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema> = TCanInstantiate<Context, [Left, Right]> extends true ? TExcludeImmediate<Context, State, Left, Right> : TExcludeDeferred<Left, Right>;
+export declare function ExcludeInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema>(context: Context, state: State, left: Left, right: Right, options: TSchemaOptions): TExcludeInstantiate<Context, State, Left, Right>;
+export {};

package/build/cjs/type/engine/exclude/instantiate.js

@@ -0,0 +1,39 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExcludeInstantiate = ExcludeInstantiate;
+const index_1 = require("../../../system/memory/index");
+const enum_1 = require("../../types/enum");
+const union_1 = require("../../types/union");
+const index_2 = require("../../extends/index");
+const index_3 = require("../enum/index");
+const index_4 = require("../evaluate/index");
+const instantiate_1 = require("../instantiate");
+const exclude_1 = require("../../action/exclude");
+function ExcludeUnion(types, right) {
+    return types.reduce((result, head) => {
+        return [...result, ...ExcludeType(head, right)];
+    }, []);
+}
+function ExcludeType(left, right) {
+    const check = (0, index_2.Extends)({}, left, right);
+    const result = index_2.ExtendsResult.IsExtendsTrueLike(check) ? [] : [left];
+    return result;
+}
+function ExcludeAction(left, right) {
+    const remaining = ((0, enum_1.IsEnum)(left) ? ExcludeUnion((0, index_3.EnumValuesToVariants)(left.enum), right) :
+        (0, union_1.IsUnion)(left) ? ExcludeUnion((0, index_4.Flatten)(left.anyOf), right) :
+            ExcludeType(left, right));
+    const result = (0, index_4.EvaluateUnion)(remaining);
+    return result;
+}
+function ExcludeImmediate(context, state, left, right, options) {
+    const instantiatedLeft = (0, instantiate_1.InstantiateType)(context, state, left);
+    const instantiatedRight = (0, instantiate_1.InstantiateType)(context, state, right);
+    return index_1.Memory.Update(ExcludeAction(instantiatedLeft, instantiatedRight), {}, options);
+}
+function ExcludeInstantiate(context, state, left, right, options) {
+    return ((0, instantiate_1.CanInstantiate)(context, [left, right])
+        ? ExcludeImmediate(context, state, left, right, options)
+        : (0, exclude_1.ExcludeDeferred)(left, right, options));
+}

package/build/cjs/type/engine/extract/index.d.ts

@@ -0,0 +1 @@
+export * from './instantiate';

package/build/cjs/type/engine/extract/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./instantiate"), exports);

package/build/cjs/type/engine/extract/instantiate.d.ts

@@ -0,0 +1,16 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema';
+import { type TProperties } from '../../types/properties';
+import { type TEnum, type TEnumValue } from '../../types/enum';
+import { type TUnion } from '../../types/union';
+import { type TExtends, ExtendsResult } from '../../extends/index';
+import { type TEnumValuesToVariants } from '../enum/index';
+import { type TEvaluateUnion, type TFlatten } from '../evaluate/index';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate';
+import { type TExtractDeferred } from '../../action/extract';
+type TExtractUnion<Types extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Types extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtractUnion<Tail, Right, [...Result, ...TExtractType<Head, Right>]> : Result);
+type TExtractType<Left extends TSchema, Right extends TSchema, Check extends ExtendsResult.TResult = TExtends<{}, Left, Right>, Result extends TSchema[] = Check extends ExtendsResult.TExtendsTrueLike<infer _> ? [Left] : []> = Result;
+type TExtractAction<Left extends TSchema, Right extends TSchema, Remaining extends TSchema[] = (Left extends TEnum<infer Values extends TEnumValue[]> ? TExtractUnion<TEnumValuesToVariants<Values>, Right> : Left extends TUnion<infer Types extends TSchema[]> ? TExtractUnion<TFlatten<Types>, Right> : TExtractType<Left, Right>), Result extends TSchema = TEvaluateUnion<Remaining>> = Result;
+type TExtractImmediate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, InstantiatedLeft extends TSchema = TInstantiateType<Context, State, Left>, InstantiatedRight extends TSchema = TInstantiateType<Context, State, Right>> = TExtractAction<InstantiatedLeft, InstantiatedRight>;
+export type TExtractInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema> = TCanInstantiate<Context, [Left, Right]> extends true ? TExtractImmediate<Context, State, Left, Right> : TExtractDeferred<Left, Right>;
+export declare function ExtractInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema>(context: Context, state: State, left: Left, right: Right, options: TSchemaOptions): TExtractInstantiate<Context, State, Left, Right>;
+export {};

package/build/cjs/type/engine/extract/instantiate.js

@@ -0,0 +1,39 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtractInstantiate = ExtractInstantiate;
+const index_1 = require("../../../system/memory/index");
+const enum_1 = require("../../types/enum");
+const union_1 = require("../../types/union");
+const index_2 = require("../../extends/index");
+const index_3 = require("../enum/index");
+const index_4 = require("../evaluate/index");
+const instantiate_1 = require("../instantiate");
+const extract_1 = require("../../action/extract");
+function ExtractUnion(types, right) {
+    return types.reduce((result, head) => {
+        return [...result, ...ExtractType(head, right)];
+    }, []);
+}
+function ExtractType(left, right) {
+    const check = (0, index_2.Extends)({}, left, right);
+    const result = index_2.ExtendsResult.IsExtendsTrueLike(check) ? [left] : [];
+    return result;
+}
+function ExtractAction(left, right) {
+    const remaining = ((0, enum_1.IsEnum)(left) ? ExtractUnion((0, index_3.EnumValuesToVariants)(left.enum), right) :
+        (0, union_1.IsUnion)(left) ? ExtractUnion((0, index_4.Flatten)(left.anyOf), right) :
+            ExtractType(left, right));
+    const result = (0, index_4.EvaluateUnion)(remaining);
+    return result;
+}
+function ExtractImmediate(context, state, left, right, options) {
+    const instantiatedLeft = (0, instantiate_1.InstantiateType)(context, state, left);
+    const instantiatedRight = (0, instantiate_1.InstantiateType)(context, state, right);
+    return index_1.Memory.Update(ExtractAction(instantiatedLeft, instantiatedRight), {}, options);
+}
+function ExtractInstantiate(context, state, left, right, options) {
+    return ((0, instantiate_1.CanInstantiate)(context, [left, right])
+        ? ExtractImmediate(context, state, left, right, options)
+        : (0, extract_1.ExtractDeferred)(left, right, options));
+}

package/build/cjs/type/engine/helpers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './keys-to-indexer';
+export * from './keys';
+export * from './union';

package/build/cjs/type/engine/helpers/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./keys-to-indexer"), exports);
+__exportStar(require("./keys"), exports);
+__exportStar(require("./union"), exports);

package/build/cjs/type/engine/helpers/keys-to-indexer.d.ts

@@ -0,0 +1,7 @@
+import { type TSchema } from '../../types/schema';
+import { type TLiteral, type TLiteralValue } from '../../types/literal';
+import { type TUnion } from '../../types/union';
+type TKeysToLiterals<Keys extends PropertyKey[], Result extends TLiteral[] = []> = (Keys extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? (Left extends TLiteralValue ? TKeysToLiterals<Right, [...Result, TLiteral<Left>]> : TKeysToLiterals<Right, Result>) : Result);
+export type TKeysToIndexer<Keys extends PropertyKey[], Literals extends TLiteral[] = TKeysToLiterals<Keys>, Result extends TSchema = TUnion<Literals>> = Result;
+export declare function KeysToIndexer<Keys extends PropertyKey[]>(keys: [...Keys]): TKeysToIndexer<Keys>;
+export {};

package/build/cjs/type/engine/helpers/keys-to-indexer.js

@@ -0,0 +1,18 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeysToIndexer = KeysToIndexer;
+const literal_1 = require("../../types/literal");
+const union_1 = require("../../types/union");
+function KeysToLiterals(keys) {
+    return keys.reduce((result, left) => {
+        return (0, literal_1.IsLiteralValue)(left)
+            ? [...result, (0, literal_1.Literal)(left)]
+            : result;
+    }, []);
+}
+function KeysToIndexer(keys) {
+    const literals = KeysToLiterals(keys);
+    const result = (0, union_1.Union)(literals);
+    return result;
+}

package/build/cjs/type/engine/helpers/keys.d.ts

@@ -0,0 +1,3 @@
+import { type TLiteralValue } from '../../types/literal';
+export type TConvertToIntegerKey<Value extends TLiteralValue, Normal extends string = `${Value}`, Result extends TLiteralValue = (Normal extends ` ${infer _ extends number}` ? Normal : Normal extends `${infer _ extends number} ` ? Normal : Normal extends `0${infer _ extends number}` ? Normal : Normal extends `-${infer _ extends number}` ? Normal : Normal extends `${infer Value extends number}` ? Value : Value)> = Result;
+export declare function ConvertToIntegerKey<Value extends TLiteralValue>(value: Value): TConvertToIntegerKey<Value>;

package/build/cjs/type/engine/helpers/keys.js

@@ -0,0 +1,11 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConvertToIntegerKey = ConvertToIntegerKey;
+const integerKeyPattern = new RegExp('^(?:0|[1-9][0-9]*)$');
+function ConvertToIntegerKey(value) {
+    const normal = `${value}`;
+    return (integerKeyPattern.test(normal)
+        ? parseInt(normal)
+        : value);
+}

package/build/cjs/type/engine/helpers/union.js

@@ -0,0 +1,3 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/cjs/type/engine/index.d.ts

@@ -0,0 +1,30 @@
+export { Instantiate, type TInstantiate } from './instantiate';
+export * from './awaited/index';
+export * from './conditional/index';
+export * from './constructor-parameters/index';
+export * from './cyclic/index';
+export * from './enum/index';
+export * from './evaluate/index';
+export * from './exclude/index';
+export * from './extract/index';
+export * from './helpers/index';
+export * from './indexed/index';
+export * from './instance-type/index';
+export * from './interface/index';
+export * from './intrinsics/index';
+export * from './keyof/index';
+export * from './mapped/index';
+export * from './module/index';
+export * from './non-nullable/index';
+export * from './object/index';
+export * from './omit/index';
+export * from './options/index';
+export * from './parameters/index';
+export * from './patterns/index';
+export * from './partial/index';
+export * from './pick/index';
+export * from './record/index';
+export * from './ref/index';
+export * from './required/index';
+export * from './return-type/index';
+export * from './template-literal/index';

package/build/cjs/type/engine/index.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Instantiate = void 0;
+// ------------------------------------------------------------------
+// Engine: Public
+// ------------------------------------------------------------------
+var instantiate_1 = require("./instantiate");
+Object.defineProperty(exports, "Instantiate", { enumerable: true, get: function () { return instantiate_1.Instantiate; } });
+// ------------------------------------------------------------------
+// Engine: Internals
+// ------------------------------------------------------------------
+__exportStar(require("./awaited/index"), exports);
+__exportStar(require("./conditional/index"), exports);
+__exportStar(require("./constructor-parameters/index"), exports);
+__exportStar(require("./cyclic/index"), exports);
+__exportStar(require("./enum/index"), exports);
+__exportStar(require("./evaluate/index"), exports);
+__exportStar(require("./exclude/index"), exports);
+__exportStar(require("./extract/index"), exports);
+__exportStar(require("./helpers/index"), exports);
+__exportStar(require("./indexed/index"), exports);
+__exportStar(require("./instance-type/index"), exports);
+__exportStar(require("./interface/index"), exports);
+__exportStar(require("./intrinsics/index"), exports);
+__exportStar(require("./keyof/index"), exports);
+__exportStar(require("./mapped/index"), exports);
+__exportStar(require("./module/index"), exports);
+__exportStar(require("./non-nullable/index"), exports);
+__exportStar(require("./object/index"), exports);
+__exportStar(require("./omit/index"), exports);
+__exportStar(require("./options/index"), exports);
+__exportStar(require("./parameters/index"), exports);
+__exportStar(require("./patterns/index"), exports);
+__exportStar(require("./partial/index"), exports);
+__exportStar(require("./pick/index"), exports);
+__exportStar(require("./record/index"), exports);
+__exportStar(require("./ref/index"), exports);
+__exportStar(require("./required/index"), exports);
+__exportStar(require("./return-type/index"), exports);
+__exportStar(require("./template-literal/index"), exports);

package/build/cjs/type/engine/indexable/from-cyclic.d.ts

@@ -0,0 +1,6 @@
+import { type TSchema } from '../../types/schema';
+import { type TProperties } from '../../types/properties';
+import { type TFromType } from './from-type';
+import { type TCyclicTarget } from '../cyclic/target';
+export type TFromCyclic<Defs extends TProperties, Ref extends string, Target extends TSchema = TCyclicTarget<Defs, Ref>, Result extends string[] = TFromType<Target>> = Result;
+export declare function FromCyclic<Defs extends TProperties, Ref extends string>(defs: Defs, ref: Ref): TFromCyclic<Defs, Ref>;

package/build/cjs/type/engine/indexable/from-cyclic.js

@@ -0,0 +1,11 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromCyclic = FromCyclic;
+const from_type_1 = require("./from-type");
+const target_1 = require("../cyclic/target");
+function FromCyclic(defs, ref) {
+    const target = (0, target_1.CyclicTarget)(defs, ref);
+    const result = (0, from_type_1.FromType)(target);
+    return result;
+}

package/build/cjs/type/engine/indexable/from-enum.d.ts

@@ -0,0 +1,6 @@
+import { type TSchema } from '../../types/schema';
+import { type TEnumValue } from '../../types/enum';
+import { type TEnumValuesToVariants } from '../enum/enum-to-union';
+import { type TFromUnion } from './from-union';
+export type TFromEnum<Values extends TEnumValue[], Variants extends TSchema[] = TEnumValuesToVariants<Values>, Result extends string[] = TFromUnion<Variants>> = Result;
+export declare function FromEnum<Values extends TEnumValue[]>(values: [...Values]): TFromEnum<Values>;

package/build/cjs/type/engine/indexable/from-enum.js

@@ -0,0 +1,11 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromEnum = FromEnum;
+const enum_to_union_1 = require("../enum/enum-to-union");
+const from_union_1 = require("./from-union");
+function FromEnum(values) {
+    const variants = (0, enum_to_union_1.EnumValuesToVariants)(values);
+    const result = (0, from_union_1.FromUnion)(variants);
+    return result;
+}

package/build/cjs/type/engine/indexable/from-intersect.d.ts

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema';
+import { type TEvaluateIntersect } from '../evaluate/evaluate';
+import { type TFromType } from './from-type';
+export type TFromIntersect<Types extends TSchema[], Evaluated extends TSchema = TEvaluateIntersect<Types>, Result extends string[] = TFromType<Evaluated>> = Result;
+export declare function FromIntersect<Types extends TSchema[]>(types: [...Types]): TFromIntersect<Types>;

package/build/cjs/type/engine/indexable/from-intersect.js

@@ -0,0 +1,11 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromIntersect = FromIntersect;
+const evaluate_1 = require("../evaluate/evaluate");
+const from_type_1 = require("./from-type");
+function FromIntersect(types) {
+    const evaluated = (0, evaluate_1.EvaluateIntersect)(types);
+    const result = (0, from_type_1.FromType)(evaluated);
+    return result;
+}

package/build/cjs/type/engine/indexable/from-literal.d.ts

@@ -0,0 +1,3 @@
+import { TLiteralValue } from '../../types/literal';
+export type TFromLiteral<Value extends TLiteralValue, Result extends string[] = [`${Value}`]> = Result;
+export declare function FromLiteral<Value extends TLiteralValue>(value: Value): TFromLiteral<Value>;

package/build/cjs/type/engine/indexable/from-literal.js

@@ -0,0 +1,8 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromLiteral = FromLiteral;
+function FromLiteral(value) {
+    const result = [`${value}`];
+    return result;
+}

package/build/cjs/type/engine/indexable/from-template-literal.d.ts

@@ -0,0 +1,5 @@
+import { type TSchema } from '../../types/schema';
+import { type TTemplateLiteralDecode } from '../template-literal/decode';
+import { type TFromType } from './from-type';
+export type TFromTemplateLiteral<Pattern extends string, Decoded extends TSchema = TTemplateLiteralDecode<Pattern>, Result extends string[] = TFromType<Decoded>> = Result;
+export declare function FromTemplateLiteral<Pattern extends string>(pattern: Pattern): TFromTemplateLiteral<Pattern>;