typebox 1.0.31 → 1.0.33

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

@@ -0,0 +1,11 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromTemplateLiteral = FromTemplateLiteral;
+const decode_1 = require("../template-literal/decode");
+const from_type_1 = require("./from-type");
+function FromTemplateLiteral(pattern) {
+    const decoded = (0, decode_1.TemplateLiteralDecode)(pattern);
+    const result = (0, from_type_1.FromType)(decoded);
+    return result;
+}

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

@@ -0,0 +1,17 @@
+import { type TSchema } from '../../types/schema';
+import { type TCyclic } from '../../types/cyclic';
+import { type TEnum, type TEnumValue } from '../../types/enum';
+import { type TIntersect } from '../../types/intersect';
+import { type TLiteral, type TLiteralValue } from '../../types/literal';
+import { type TProperties } from '../../types/properties';
+import { type TTemplateLiteral } from '../../types/template-literal';
+import { type TUnion } from '../../types/union';
+import { TFromCyclic } from './from-cyclic';
+import { TFromEnum } from './from-enum';
+import { TFromIntersect } from './from-intersect';
+import { TFromLiteral } from './from-literal';
+import { TFromTemplateLiteral } from './from-template-literal';
+import { TFromUnion } from './from-union';
+export type TFromType<Indexer extends TSchema, Result extends string[] = (Indexer extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? TFromCyclic<Defs, Ref> : Indexer extends TEnum<infer Values extends TEnumValue[]> ? TFromEnum<Values> : Indexer extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Indexer extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Value> : Indexer extends TTemplateLiteral<infer Pattern extends string> ? TFromTemplateLiteral<Pattern> : Indexer extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : [
+])> = Result;
+export declare function FromType<Indexer extends TSchema>(type: Indexer): TFromType<Indexer>;

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

@@ -0,0 +1,25 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromType = FromType;
+const cyclic_1 = require("../../types/cyclic");
+const enum_1 = require("../../types/enum");
+const intersect_1 = require("../../types/intersect");
+const literal_1 = require("../../types/literal");
+const template_literal_1 = require("../../types/template-literal");
+const union_1 = require("../../types/union");
+const from_cyclic_1 = require("./from-cyclic");
+const from_enum_1 = require("./from-enum");
+const from_intersect_1 = require("./from-intersect");
+const from_literal_1 = require("./from-literal");
+const from_template_literal_1 = require("./from-template-literal");
+const from_union_1 = require("./from-union");
+function FromType(type) {
+    return ((0, cyclic_1.IsCyclic)(type) ? (0, from_cyclic_1.FromCyclic)(type.$defs, type.$ref) :
+        (0, enum_1.IsEnum)(type) ? (0, from_enum_1.FromEnum)(type.enum) :
+            (0, intersect_1.IsIntersect)(type) ? (0, from_intersect_1.FromIntersect)(type.allOf) :
+                (0, literal_1.IsLiteral)(type) ? (0, from_literal_1.FromLiteral)(type.const) :
+                    (0, template_literal_1.IsTemplateLiteral)(type) ? (0, from_template_literal_1.FromTemplateLiteral)(type.pattern) :
+                        (0, union_1.IsUnion)(type) ? (0, from_union_1.FromUnion)(type.anyOf) :
+                            []);
+}

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

@@ -0,0 +1,4 @@
+import { type TSchema } from '../../types/schema';
+import { type TFromType } from './from-type';
+export type TFromUnion<Types extends TSchema[], Result extends string[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromUnion<Right, [...Result, ...TFromType<Left>]> : Result);
+export declare function FromUnion<Types extends TSchema[]>(types: [...Types]): TFromUnion<Types>;

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

@@ -0,0 +1,10 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromUnion = FromUnion;
+const from_type_1 = require("./from-type");
+function FromUnion(types) {
+    return types.reduce((result, left) => {
+        return [...result, ...(0, from_type_1.FromType)(left)];
+    }, []);
+}

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

@@ -0,0 +1,10 @@
+import { type TSchema } from '../../types/schema';
+import { type TFromType } from './from-type';
+export type TToIndexableKeys<Indexer extends TSchema, Result extends string[] = TFromType<Indexer>> = Result;
+/**
+ * Transforms a type meant as an Indexer into string[] array which is used by Indexable types
+ * like Index, Pick and Omit to select from property keys. This function should only be used
+ * for Object key selection, and not for Array / Tuple key selection as Array-Like structures
+ * require TNumber indexing support.
+ */
+export declare function ToIndexableKeys<Indexer extends TSchema>(type: Indexer): TToIndexableKeys<Indexer>;

package/build/cjs/type/engine/indexable/to-indexable-keys.js

@@ -0,0 +1,15 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToIndexableKeys = ToIndexableKeys;
+const from_type_1 = require("./from-type");
+/**
+ * Transforms a type meant as an Indexer into string[] array which is used by Indexable types
+ * like Index, Pick and Omit to select from property keys. This function should only be used
+ * for Object key selection, and not for Array / Tuple key selection as Array-Like structures
+ * require TNumber indexing support.
+ */
+function ToIndexableKeys(type) {
+    const result = (0, from_type_1.FromType)(type);
+    return result;
+}

package/build/cjs/type/engine/indexable/to-indexable.d.ts

@@ -0,0 +1,9 @@
+import { type TUnreachable } from '../../../system/unreachable/index';
+import { type TSchema } from '../../types/schema';
+import { type TProperties } from '../../types/properties';
+import { type TObject } from '../../types/object';
+import { type TCollapseToObject } from '../object/index';
+/** Transforms a type into a TProperties used for indexing operations */
+export type TToIndexable<Type extends TSchema, Collapsed extends TSchema = TCollapseToObject<Type>, Result extends TProperties = (Collapsed extends TObject<infer Properties extends TProperties> ? Properties : TUnreachable)> = Result;
+/** Transforms a type into a TProperties used for indexing operations */
+export declare function ToIndexable<Type extends TSchema>(type: Type): TToIndexable<Type>;

package/build/cjs/type/engine/indexable/to-indexable.js

@@ -0,0 +1,17 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToIndexable = ToIndexable;
+const index_1 = require("../../../system/unreachable/index");
+const object_1 = require("../../types/object");
+const index_2 = require("../object/index");
+// deno-coverage-ignore-start - symmetric unreachable
+/** Transforms a type into a TProperties used for indexing operations */
+function ToIndexable(type) {
+    const collapsed = (0, index_2.CollapseToObject)(type);
+    const result = (0, object_1.IsObject)(collapsed)
+        ? collapsed.properties
+        : (0, index_1.Unreachable)();
+    return result;
+}
+// deno-coverage-ignore-stop

package/build/cjs/type/engine/indexed/array-indexer.d.ts

@@ -0,0 +1,12 @@
+import { type TSchema } from '../../types/schema';
+import { type TUnion } from '../../types/union';
+import { type TIntersect } from '../../types/intersect';
+import { type TLiteral, type TLiteralValue } from '../../types/literal';
+import { type TConvertToIntegerKey } from '../helpers/keys';
+type TConvertLiteral<Value extends TLiteralValue, Result extends TSchema = TLiteral<TConvertToIntegerKey<Value>>> = Result;
+type TArrayIndexerTypes<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TArrayIndexerTypes<Right, [...Result, TFormatArrayIndexer<Left>]> : Result);
+/** Formats embedded integer-like strings on an Indexer to be number values inline with TS indexing | coercion behaviors. */
+export type TFormatArrayIndexer<Type extends TSchema, Result extends TSchema = (Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TArrayIndexerTypes<Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TArrayIndexerTypes<Types>> : Type extends TLiteral<infer Value extends TLiteralValue> ? TConvertLiteral<Value> : Type)> = Result;
+/** Formats embedded integer-like strings on an Indexer to be number values inline with TS indexing | coercion behaviors. */
+export declare function FormatArrayIndexer<Type extends TSchema>(type: Type): TFormatArrayIndexer<Type>;
+export {};

package/build/cjs/type/engine/indexed/array-indexer.js

@@ -0,0 +1,21 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormatArrayIndexer = FormatArrayIndexer;
+const union_1 = require("../../types/union");
+const intersect_1 = require("../../types/intersect");
+const literal_1 = require("../../types/literal");
+const keys_1 = require("../helpers/keys");
+function ConvertLiteral(value) {
+    return (0, literal_1.Literal)((0, keys_1.ConvertToIntegerKey)(value));
+}
+function ArrayIndexerTypes(types) {
+    return types.map(type => FormatArrayIndexer(type));
+}
+/** Formats embedded integer-like strings on an Indexer to be number values inline with TS indexing | coercion behaviors. */
+function FormatArrayIndexer(type) {
+    return ((0, intersect_1.IsIntersect)(type) ? (0, intersect_1.Intersect)(ArrayIndexerTypes(type.allOf)) :
+        (0, union_1.IsUnion)(type) ? (0, union_1.Union)(ArrayIndexerTypes(type.anyOf)) :
+            (0, literal_1.IsLiteral)(type) ? ConvertLiteral(type.const) :
+                type);
+}

package/build/cjs/type/engine/indexed/from-array.d.ts

@@ -0,0 +1,15 @@
+import { type TSchema } from '../../types/schema';
+import { type TIntersect } from '../../types/intersect';
+import { type TUnion } from '../../types/union';
+import { type TLiteral, type TLiteralValue } from '../../types/literal';
+import { type TNumber } from '../../types/number';
+import { type TNever } from '../../types/never';
+import { type TExtends, ExtendsResult } from '../../extends/index';
+import { type TConvertToIntegerKey } from '../helpers/keys';
+type TNormalizeLiteral<Value extends TLiteralValue, Result extends TSchema = TLiteral<TConvertToIntegerKey<Value>>> = Result;
+type TNormalizeIndexerTypes<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TNormalizeIndexerTypes<Right, [...Result, TNormalizeIndexer<Left>]> : Result);
+export type TNormalizeIndexer<Type extends TSchema, Result extends TSchema = (Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TNormalizeIndexerTypes<Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TNormalizeIndexerTypes<Types>> : Type extends TLiteral<infer Value extends TLiteralValue> ? TNormalizeLiteral<Value> : Type)> = Result;
+export declare function NormalizeIndexer<Type extends TSchema>(type: Type): TNormalizeIndexer<Type>;
+export type TFromArray<Type extends TSchema, Indexer extends TSchema, NormalizedIndexer extends TSchema = TNormalizeIndexer<Indexer>, Check extends ExtendsResult.TResult = TExtends<{}, NormalizedIndexer, TNumber>, Result extends TSchema = Check extends ExtendsResult.TExtendsTrueLike ? Type : TNever> = Result;
+export declare function FromArray<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer): TFromArray<Type, Indexer>;
+export {};

package/build/cjs/type/engine/indexed/from-array.js

@@ -0,0 +1,30 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NormalizeIndexer = NormalizeIndexer;
+exports.FromArray = FromArray;
+const intersect_1 = require("../../types/intersect");
+const union_1 = require("../../types/union");
+const literal_1 = require("../../types/literal");
+const number_1 = require("../../types/number");
+const never_1 = require("../../types/never");
+const index_1 = require("../../extends/index");
+const keys_1 = require("../helpers/keys");
+function NormalizeLiteral(value) {
+    return (0, literal_1.Literal)((0, keys_1.ConvertToIntegerKey)(value));
+}
+function NormalizeIndexerTypes(types) {
+    return types.map(type => NormalizeIndexer(type));
+}
+function NormalizeIndexer(type) {
+    return ((0, intersect_1.IsIntersect)(type) ? (0, intersect_1.Intersect)(NormalizeIndexerTypes(type.allOf)) :
+        (0, union_1.IsUnion)(type) ? (0, union_1.Union)(NormalizeIndexerTypes(type.anyOf)) :
+            (0, literal_1.IsLiteral)(type) ? NormalizeLiteral(type.const) :
+                type);
+}
+function FromArray(type, indexer) {
+    const normalizedIndexer = NormalizeIndexer(indexer);
+    const check = (0, index_1.Extends)({}, normalizedIndexer, (0, number_1.Number)());
+    const result = index_1.ExtendsResult.IsExtendsTrueLike(check) ? type : (0, never_1.Never)();
+    return result;
+}

package/build/cjs/type/engine/indexed/from-object.d.ts

@@ -0,0 +1,9 @@
+import { type TProperties } from '../../types/properties';
+import { type TSchema } from '../../types/schema';
+import { type TEvaluateUnion } from '../evaluate/evaluate';
+import { type TToIndexableKeys } from '../indexable/to-indexable-keys';
+type TSelectProperty<Properties extends TProperties, Key extends string, PropertyKey extends string = keyof Properties extends string | number ? `${keyof Properties}` : never, Result extends TSchema[] = Key extends PropertyKey ? [Properties[Key]] : []> = Result;
+type TSelectProperties<Properties extends TProperties, Keys extends string[], Result extends TSchema[] = []> = (Keys extends [infer Left extends string, ...infer Right extends string[]] ? TSelectProperties<Properties, Right, [...Result, ...TSelectProperty<Properties, Left>]> : Result);
+export type TFromObject<Properties extends TProperties, Indexer extends TSchema, Keys extends string[] = TToIndexableKeys<Indexer>, Variants extends TSchema[] = TSelectProperties<Properties, Keys>, Result extends TSchema = TEvaluateUnion<Variants>> = Result;
+export declare function FromObject<Properties extends TProperties, Indexer extends TSchema>(properties: Properties, indexer: Indexer): TFromObject<Properties, Indexer>;
+export {};

package/build/cjs/type/engine/indexed/from-object.js

@@ -0,0 +1,21 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromObject = FromObject;
+const evaluate_1 = require("../evaluate/evaluate");
+const to_indexable_keys_1 = require("../indexable/to-indexable-keys");
+function SelectProperty(properties, indexer) {
+    const result = indexer in properties ? [properties[indexer]] : [];
+    return result;
+}
+function SelectProperties(properties, indexer) {
+    return indexer.reduce((result, left) => {
+        return [...result, ...SelectProperty(properties, left)];
+    }, []);
+}
+function FromObject(properties, indexer) {
+    const keys = (0, to_indexable_keys_1.ToIndexableKeys)(indexer);
+    const variants = SelectProperties(properties, keys);
+    const result = (0, evaluate_1.EvaluateUnion)(variants);
+    return result;
+}

package/build/cjs/type/engine/indexed/from-tuple.d.ts

@@ -0,0 +1,13 @@
+import { type TSchema } from '../../types/schema';
+import { type TLiteral } from '../../types/literal';
+import { type TNumber } from '../../types/number';
+import { type TInteger } from '../../types/integer';
+import { type TEvaluateUnion } from '../evaluate/evaluate';
+import { type TExtends, ExtendsResult } from '../../extends/index';
+import { type TFormatArrayIndexer } from './array-indexer';
+type TIndexElementsWithIndexer<Types extends TSchema[], Indexer extends TSchema, Result extends TSchema[] = []> = (Types extends [...infer Left extends TSchema[], infer Right extends TSchema] ? TExtends<{}, TLiteral<Left['length']>, Indexer> extends ExtendsResult.TExtendsTrueLike ? TIndexElementsWithIndexer<Left, Indexer, [Right, ...Result]> : TIndexElementsWithIndexer<Left, Indexer, Result> : Result);
+type TFromTupleWithIndexer<Types extends TSchema[], Indexer extends TSchema, ArrayIndexer extends TSchema = TFormatArrayIndexer<Indexer>, Elements extends TSchema[] = TIndexElementsWithIndexer<Types, ArrayIndexer>, Result extends TSchema = TEvaluateUnion<Elements>> = Result;
+type TFromTupleWithoutIndexer<Types extends TSchema[], Result extends TSchema = TEvaluateUnion<Types>> = Result;
+export type TFromTuple<Types extends TSchema[], Indexer extends TSchema, Result extends TSchema = (Indexer extends TNumber | TInteger ? TFromTupleWithoutIndexer<Types> : TFromTupleWithIndexer<Types, Indexer>)> = Result;
+export declare function FromTuple<Types extends TSchema[], Indexer extends TSchema>(types: [...Types], indexer: Indexer): TFromTuple<Types, Indexer>;
+export {};

package/build/cjs/type/engine/indexed/from-tuple.js

@@ -0,0 +1,31 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromTuple = FromTuple;
+const literal_1 = require("../../types/literal");
+const number_1 = require("../../types/number");
+const integer_1 = require("../../types/integer");
+const evaluate_1 = require("../evaluate/evaluate");
+const index_1 = require("../../extends/index");
+const array_indexer_1 = require("./array-indexer");
+function IndexElementsWithIndexer(types, indexer) {
+    return types.reduceRight((result, right, index) => {
+        const check = (0, index_1.Extends)({}, (0, literal_1.Literal)(index), indexer);
+        return index_1.ExtendsResult.IsExtendsTrueLike(check)
+            ? [right, ...result]
+            : result;
+    }, []);
+}
+function FromTupleWithIndexer(types, indexer) {
+    const formattedArrayIndexer = (0, array_indexer_1.FormatArrayIndexer)(indexer);
+    const elements = IndexElementsWithIndexer(types, formattedArrayIndexer);
+    return (0, evaluate_1.EvaluateUnion)(elements);
+}
+function FromTupleWithoutIndexer(types) {
+    return (0, evaluate_1.EvaluateUnion)(types);
+}
+function FromTuple(types, indexer) {
+    return ((0, number_1.IsNumber)(indexer) || (0, integer_1.IsInteger)(indexer)
+        ? FromTupleWithoutIndexer(types)
+        : FromTupleWithIndexer(types, indexer));
+}

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

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

package/build/cjs/type/engine/indexed/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/indexed/instantiate.d.ts

@@ -0,0 +1,21 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema';
+import { type TArray } from '../../types/array';
+import { type TCyclic } from '../../types/cyclic';
+import { type TIntersect } from '../../types/intersect';
+import { type TNever } from '../../types/never';
+import { type TProperties } from '../../types/properties';
+import { type TObject } from '../../types/object';
+import { type TTuple } from '../../types/tuple';
+import { type TUnion } from '../../types/union';
+import { type TFromArray } from './from-array';
+import { type TFromObject } from './from-object';
+import { type TFromTuple } from './from-tuple';
+import { type TState, type TInstantiateType, TCanInstantiate } from '../instantiate';
+import { type TIndexDeferred } from '../../action/indexed';
+import { type TCollapseToObject } from '../object/index';
+type TNormalizeType<Type extends TSchema, Result extends TSchema = (Type extends TCyclic | TIntersect | TUnion ? TCollapseToObject<Type> : Type)> = Result;
+type TIndexAction<Type extends TSchema, Indexer extends TSchema, Normal extends TSchema = TNormalizeType<Type>> = (Normal extends TArray<infer Type extends TSchema> ? TFromArray<Type, Indexer> : Normal extends TObject<infer Properties extends TProperties> ? TFromObject<Properties, Indexer> : Normal extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types, Indexer> : TNever);
+type TIndexImmediate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>, InstantiatedIndexer extends TSchema = TInstantiateType<Context, State, Indexer>> = TIndexAction<InstantiatedType, InstantiatedIndexer>;
+export type TIndexInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema> = TCanInstantiate<Context, [Type, Indexer]> extends true ? TIndexImmediate<Context, State, Type, Indexer> : TIndexDeferred<Type, Indexer>;
+export declare function IndexInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema>(context: Context, state: State, type: Type, indexer: Indexer, options: TSchemaOptions): TIndexInstantiate<Context, State, Type, Indexer>;
+export {};

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

@@ -0,0 +1,40 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexInstantiate = IndexInstantiate;
+const index_1 = require("../../../system/memory/index");
+const array_1 = require("../../types/array");
+const cyclic_1 = require("../../types/cyclic");
+const intersect_1 = require("../../types/intersect");
+const never_1 = require("../../types/never");
+const object_1 = require("../../types/object");
+const tuple_1 = require("../../types/tuple");
+const union_1 = require("../../types/union");
+const from_array_1 = require("./from-array");
+const from_object_1 = require("./from-object");
+const from_tuple_1 = require("./from-tuple");
+const instantiate_1 = require("../instantiate");
+const indexed_1 = require("../../action/indexed");
+const index_2 = require("../object/index");
+function NormalizeType(type) {
+    const result = ((0, cyclic_1.IsCyclic)(type) || (0, intersect_1.IsIntersect)(type) || (0, union_1.IsUnion)(type) ? (0, index_2.CollapseToObject)(type) :
+        type);
+    return result;
+}
+function IndexAction(type, indexer) {
+    const normal = NormalizeType(type);
+    return ((0, array_1.IsArray)(normal) ? (0, from_array_1.FromArray)(normal.items, indexer) :
+        (0, object_1.IsObject)(normal) ? (0, from_object_1.FromObject)(normal.properties, indexer) :
+            (0, tuple_1.IsTuple)(normal) ? (0, from_tuple_1.FromTuple)(normal.items, indexer) :
+                (0, never_1.Never)());
+}
+function IndexImmediate(context, state, type, indexer, options) {
+    const instantiatedType = (0, instantiate_1.InstantiateType)(context, state, type);
+    const instantiatedIndexer = (0, instantiate_1.InstantiateType)(context, state, indexer);
+    return index_1.Memory.Update(IndexAction(instantiatedType, instantiatedIndexer), {}, options);
+}
+function IndexInstantiate(context, state, type, indexer, options) {
+    return ((0, instantiate_1.CanInstantiate)(context, [type, indexer])
+        ? IndexImmediate(context, state, type, indexer, options)
+        : (0, indexed_1.IndexDeferred)(type, indexer, options));
+}

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

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

package/build/cjs/type/engine/instance-type/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/instance-type/instantiate.d.ts

@@ -0,0 +1,12 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema';
+import { type TProperties } from '../../types/properties';
+import { type TConstructor } from '../../types/constructor';
+import { type TNever } from '../../types/never';
+import { type TInstanceTypeDeferred } from '../../action/instance-type';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate';
+type TInstanceTypeAction<Type extends TSchema> = (Type extends TConstructor<infer _Parameters extends TSchema[], infer InstanceType extends TSchema> ? InstanceType : TNever);
+export type TInstanceTypeImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TInstanceTypeAction<InstantiatedType>;
+export declare function InstanceTypeImmediate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TInstanceTypeImmediate<Context, State, Type>;
+export type TInstanceTypeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TInstanceTypeImmediate<Context, State, Type> : TInstanceTypeDeferred<Type>;
+export declare function InstanceTypeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options?: TSchemaOptions): TInstanceTypeInstantiate<Context, State, Type>;
+export {};

package/build/cjs/type/engine/instance-type/instantiate.js

@@ -0,0 +1,24 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstanceTypeImmediate = InstanceTypeImmediate;
+exports.InstanceTypeInstantiate = InstanceTypeInstantiate;
+const index_1 = require("../../../system/memory/index");
+const constructor_1 = require("../../types/constructor");
+const never_1 = require("../../types/never");
+const instance_type_1 = require("../../action/instance-type");
+const instantiate_1 = require("../instantiate");
+function InstanceTypeAction(type) {
+    return ((0, constructor_1.IsConstructor)(type)
+        ? type.instanceType
+        : (0, never_1.Never)());
+}
+function InstanceTypeImmediate(context, state, type, options) {
+    const instantiatedType = (0, instantiate_1.InstantiateType)(context, state, type);
+    return index_1.Memory.Update(InstanceTypeAction(instantiatedType), {}, options);
+}
+function InstanceTypeInstantiate(context, state, type, options = {}) {
+    return ((0, instantiate_1.CanInstantiate)(context, [type])
+        ? InstanceTypeImmediate(context, state, type, options)
+        : (0, instance_type_1.InstanceTypeDeferred)(type, options));
+}

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

@@ -0,0 +1,162 @@
+import { type TOptional, TOptionalAdd, TOptionalRemove } from '../types/_optional';
+import { type TReadonly, TReadonlyAdd, TReadonlyRemove } from '../types/_readonly';
+import { type TSchema } from '../types/schema';
+import { type TArray } from '../types/array';
+import { type TAsyncIterator } from '../types/async-iterator';
+import { type TConstructor } from '../types/constructor';
+import { type TDeferred } from '../types/deferred';
+import { type TFunction } from '../types/function';
+import { type TCall } from '../types/call';
+import { type TIdentifier } from '../types/identifier';
+import { type TIntersect } from '../types/intersect';
+import { type TIterator } from '../types/iterator';
+import { type TObject } from '../types/object';
+import { type TPromise } from '../types/promise';
+import { type TProperties } from '../types/properties';
+import { type TRecord } from '../types/record';
+import { type TTuple } from '../types/tuple';
+import { type TUnion } from '../types/union';
+import { type TRef } from '../types/ref';
+import { type TRest } from '../types/rest';
+import { type TReadonlyAddAction, type TReadonlyRemoveAction } from '../action/_readonly';
+import { type TOptionalAddAction, type TOptionalRemoveAction } from '../action/_optional';
+import { type TAwaitedInstantiate } from './awaited/instantiate';
+import { type TCallInstantiate } from './call/instantiate';
+import { type TCapitalizeInstantiate } from './intrinsics/instantiate';
+import { type TConditionalInstantiate } from './conditional/index';
+import { type TConstructorParametersInstantiate } from './constructor-parameters/instantiate';
+import { type TEvaluateInstantiate } from './evaluate/instantiate';
+import { type TExcludeInstantiate } from './exclude/instantiate';
+import { type TExtractInstantiate } from './extract/instantiate';
+import { type TIndexInstantiate } from './indexed/instantiate';
+import { type TInstanceTypeInstantiate } from './instance-type/instantiate';
+import { type TInterfaceInstantiate } from './interface/instantiate';
+import { type TKeyOfInstantiate } from './keyof/instantiate';
+import { type TLowercaseInstantiate } from './intrinsics/instantiate';
+import { type TMappedInstantiate } from './mapped/instantiate';
+import { type TModuleInstantiate } from './module/instantiate';
+import { type TNonNullableInstantiate } from './non-nullable/instantiate';
+import { type TOmitInstantiate } from './omit/instantiate';
+import { type TOptionsInstantiate } from './options/instantiate';
+import { type TParametersInstantiate } from './parameters/instantiate';
+import { type TPartialInstantiate } from './partial/instantiate';
+import { type TPickInstantiate } from './pick/instantiate';
+import { type TRecordInstantiate } from './record/instantiate';
+import { type TRefInstantiate } from './ref/instantiate';
+import { type TRequiredInstantiate } from './required/instantiate';
+import { type TReturnTypeInstantiate } from './return-type/instantiate';
+import { type TTemplateLiteralInstantiate } from './template-literal/instantiate';
+import { type TUncapitalizeInstantiate } from './intrinsics/instantiate';
+import { type TUppercaseInstantiate } from './intrinsics/instantiate';
+import { type TRestSpread } from './rest/index';
+export interface TState {
+    callstack: string[];
+}
+type TCanInstantiateRef<Context extends TProperties, Ref extends string> = (Ref extends keyof Context ? true : false);
+type TCanInstantiateType<Context extends TProperties, Type extends TSchema> = (Type extends TIntersect<infer Types extends TSchema[]> ? TCanInstantiate<Context, Types> : Type extends TUnion<infer Types extends TSchema[]> ? TCanInstantiate<Context, Types> : Type extends TRef<infer Ref extends string> ? TCanInstantiateRef<Context, Ref> : true);
+export type TCanInstantiate<Context extends TProperties, Types extends TSchema[]> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TCanInstantiateType<Context, Left> extends true ? TCanInstantiate<Context, Right> : false : true;
+export declare function CanInstantiate<Context extends TProperties, Types extends TSchema[]>(context: Context, types: [...Types]): TCanInstantiate<Context, Types>;
+type ModifierAction = 'add' | 'remove' | 'none';
+type TModifierActions<Type extends TSchema, Readonly extends ModifierAction, Optional extends ModifierAction> = (Type extends TReadonlyRemoveAction<infer Type extends TSchema> ? TModifierActions<Type, 'remove', Optional> : Type extends TOptionalRemoveAction<infer Type extends TSchema> ? TModifierActions<Type, Readonly, 'remove'> : Type extends TReadonlyAddAction<infer Type extends TSchema> ? TModifierActions<Type, 'add', Optional> : Type extends TOptionalAddAction<infer Type extends TSchema> ? TModifierActions<Type, Readonly, 'add'> : [
+    Type,
+    Readonly,
+    Optional
+]);
+type TApplyReadonly<Action extends ModifierAction, Type extends TSchema> = (Action extends 'remove' ? TReadonlyRemove<Type> : Action extends 'add' ? TReadonlyAdd<Type> : Type);
+type TApplyOptional<Action extends ModifierAction, Type extends TSchema> = (Action extends 'remove' ? TOptionalRemove<Type> : Action extends 'add' ? TOptionalAdd<Type> : Type);
+export type TInstantiateProperties<Context extends TProperties, State extends TState, Properties extends TProperties, Result extends TProperties = {
+    [Key in keyof Properties]: TInstantiateType<Context, State, Properties[Key]>;
+}> = Result;
+export declare function InstantiateProperties<Context extends TProperties, State extends TState, Properties extends TProperties>(context: Context, state: State, properties: TProperties): TInstantiateProperties<Context, State, Properties>;
+export type TInstantiateElements<Context extends TProperties, State extends TState, Types extends TSchema[], Elements extends TSchema[] = TInstantiateTypes<Context, State, Types>, Result extends TSchema[] = TRestSpread<Elements>> = Result;
+export declare function InstantiateElements<Context extends TProperties, State extends TState, Types extends TSchema[]>(context: Context, state: State, types: [...Types]): TInstantiateElements<Context, State, Types>;
+export type TInstantiateTypes<Context extends TProperties, State extends TState, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TInstantiateTypes<Context, State, Right, [...Result, TInstantiateType<Context, State, Left>]> : Result);
+export declare function InstantiateTypes<Context extends TProperties, State extends TState, Types extends TSchema[]>(context: Context, state: State, types: [...Types]): TInstantiateTypes<Context, State, Types>;
+type TInstantiateDeferred<Context extends TProperties, State extends TState, Action extends string, Parameters extends TSchema[]> = ([
+    Action,
+    Parameters
+] extends ['Awaited', [infer Type extends TSchema]] ? TAwaitedInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Capitalize', [infer Type extends TSchema]] ? TCapitalizeInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Conditional', [infer Left extends TSchema, infer Right extends TSchema, infer True extends TSchema, infer False extends TSchema]] ? TConditionalInstantiate<Context, State, Left, Right, True, False> : [
+    Action,
+    Parameters
+] extends ['ConstructorParameters', [infer Type extends TSchema]] ? TConstructorParametersInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Evaluate', [infer Type extends TSchema]] ? TEvaluateInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Exclude', [infer Left extends TSchema, infer Right extends TSchema]] ? TExcludeInstantiate<Context, State, Left, Right> : [
+    Action,
+    Parameters
+] extends ['Extract', [infer Left extends TSchema, infer Right extends TSchema]] ? TExtractInstantiate<Context, State, Left, Right> : [
+    Action,
+    Parameters
+] extends ['Index', [infer Type extends TSchema, infer Indexer extends TSchema]] ? TIndexInstantiate<Context, State, Type, Indexer> : [
+    Action,
+    Parameters
+] extends ['InstanceType', [infer Type extends TSchema]] ? TInstanceTypeInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Interface', [infer Heritage extends TSchema[], infer Properties extends TProperties]] ? TInterfaceInstantiate<Context, State, Heritage, Properties> : [
+    Action,
+    Parameters
+] extends ['KeyOf', [infer Type extends TSchema]] ? TKeyOfInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Lowercase', [infer Type extends TSchema]] ? TLowercaseInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Mapped', [infer Name extends TIdentifier, infer Key extends TSchema, infer As extends TSchema, infer Property extends TSchema]] ? TMappedInstantiate<Context, State, Name, Key, As, Property> : [
+    Action,
+    Parameters
+] extends ['Module', [infer Properties extends TProperties]] ? TModuleInstantiate<Context, State, Properties> : [
+    Action,
+    Parameters
+] extends ['NonNullable', [infer Type extends TSchema]] ? TNonNullableInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Pick', [infer Type extends TSchema, infer Indexer extends TSchema]] ? TPickInstantiate<Context, State, Type, Indexer> : [
+    Action,
+    Parameters
+] extends ['Options', [infer Type extends TSchema, infer Options extends TSchema]] ? TOptionsInstantiate<Context, State, Type, Options> : [
+    Action,
+    Parameters
+] extends ['Parameters', [infer Type extends TSchema]] ? TParametersInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Partial', [infer Type extends TSchema]] ? TPartialInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Omit', [infer Type extends TSchema, infer Indexer extends TSchema]] ? TOmitInstantiate<Context, State, Type, Indexer> : [
+    Action,
+    Parameters
+] extends ['Record', [infer Key extends TSchema, infer Value extends TSchema]] ? TRecordInstantiate<Context, State, Key, Value> : [
+    Action,
+    Parameters
+] extends ['Required', [infer Type extends TSchema]] ? TRequiredInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['ReturnType', [infer Type extends TSchema]] ? TReturnTypeInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['TemplateLiteral', [infer Types extends TSchema[]]] ? TTemplateLiteralInstantiate<Context, State, Types> : [
+    Action,
+    Parameters
+] extends ['Uncapitalize', [infer Type extends TSchema]] ? TUncapitalizeInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['Uppercase', [infer Type extends TSchema]] ? TUppercaseInstantiate<Context, State, Type> : TDeferred<Action, Parameters>);
+export type TInstantiateType<Context extends TProperties, State extends TState, Input extends TSchema, ModifierState extends [TSchema, ModifierAction, ModifierAction] = TModifierActions<Input, Input extends TReadonly<Input> ? 'add' : 'none', Input extends TOptional<Input> ? 'add' : 'none'>, Type extends TSchema = ModifierState[0], Instantiated extends TSchema = (Type extends TRef<infer Ref extends string> ? TRefInstantiate<Context, State, Ref> : Type extends TArray<infer Type extends TSchema> ? TArray<TInstantiateType<Context, State, Type>> : Type extends TAsyncIterator<infer Type extends TSchema> ? TAsyncIterator<TInstantiateType<Context, State, Type>> : Type extends TCall<infer Target extends TSchema, infer Parameters extends TSchema[]> ? TCallInstantiate<Context, State, Target, Parameters> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TConstructor<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, InstanceType>> : Type extends TDeferred<infer Action extends string, infer Types extends TSchema[]> ? TInstantiateDeferred<Context, State, Action, Types> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, ReturnType>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TInstantiateTypes<Context, State, Types>> : Type extends TIterator<infer Type extends TSchema> ? TIterator<TInstantiateType<Context, State, Type>> : Type extends TObject<infer Properties extends TProperties> ? TObject<TInstantiateProperties<Context, State, Properties>> : Type extends TPromise<infer Type extends TSchema> ? TPromise<TInstantiateType<Context, State, Type>> : Type extends TRecord<infer Key extends string, infer Type extends TSchema> ? TRecord<Key, TInstantiateType<Context, State, Type>> : Type extends TRest<infer Type extends TSchema> ? TRest<TInstantiateType<Context, State, Type>> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TInstantiateElements<Context, State, Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TInstantiateTypes<Context, State, Types>> : Type)> = TApplyReadonly<ModifierState[1], TApplyOptional<ModifierState[2], Instantiated>>;
+export declare function InstantiateType<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, input: Type): TInstantiateType<Context, State, Type>;
+/** Instantiates computed schematics using the given context and type. */
+export type TInstantiate<Context extends TProperties, Type extends TSchema> = (TInstantiateType<Context, {
+    callstack: [];
+}, Type>);
+/** Instantiates computed schematics using the given context and type. */
+export declare function Instantiate<Context extends TProperties, Type extends TSchema>(context: Context, type: Type): TInstantiate<Context, Type>;
+export {};