typebox 1.0.31 → 1.0.33

package/build/cjs/type/action/return-type.js

@@ -0,0 +1,15 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReturnTypeDeferred = ReturnTypeDeferred;
+exports.ReturnType = ReturnType;
+const deferred_1 = require("../types/deferred");
+const instantiate_1 = require("../engine/instantiate");
+/** Creates a deferred ReturnType action. */
+function ReturnTypeDeferred(type, options = {}) {
+    return (0, deferred_1.Deferred)('ReturnType', [type], options);
+}
+/** Applies a ReturnType action to the given type. */
+function ReturnType(type, options = {}) {
+    return (0, instantiate_1.Instantiate)({}, ReturnTypeDeferred(type, options));
+}

package/build/cjs/type/action/uncapitalize.d.ts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema';
+import { type TDeferred } from '../types/deferred';
+import { type TInstantiate } from '../engine/instantiate';
+/** Creates a deferred Uncapitalize action. */
+export type TUncapitalizeDeferred<Type extends TSchema> = (TDeferred<'Uncapitalize', [Type]>);
+/** Creates a deferred Uncapitalize action. */
+export declare function UncapitalizeDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TUncapitalizeDeferred<Type>;
+/** Applies a Uncapitalize action to the given type. */
+export type TUncapitalize<Type extends TSchema> = (TInstantiate<{}, TUncapitalizeDeferred<Type>>);
+/** Applies a Uncapitalize action to the given type. */
+export declare function Uncapitalize<Type extends TSchema>(type: Type, options?: TSchemaOptions): TUncapitalize<Type>;

package/build/cjs/type/action/uncapitalize.js

@@ -0,0 +1,15 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UncapitalizeDeferred = UncapitalizeDeferred;
+exports.Uncapitalize = Uncapitalize;
+const deferred_1 = require("../types/deferred");
+const instantiate_1 = require("../engine/instantiate");
+/** Creates a deferred Uncapitalize action. */
+function UncapitalizeDeferred(type, options = {}) {
+    return (0, deferred_1.Deferred)('Uncapitalize', [type], options);
+}
+/** Applies a Uncapitalize action to the given type. */
+function Uncapitalize(type, options = {}) {
+    return (0, instantiate_1.Instantiate)({}, UncapitalizeDeferred(type, options));
+}

package/build/cjs/type/action/uppercase.d.ts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema';
+import { type TDeferred } from '../types/deferred';
+import { type TInstantiate } from '../engine/instantiate';
+/** Creates a deferred Uppercase action. */
+export type TUppercaseDeferred<Type extends TSchema> = (TDeferred<'Uppercase', [Type]>);
+/** Creates a deferred Uppercase action. */
+export declare function UppercaseDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TUppercaseDeferred<Type>;
+/** Applies a Uppercase action to the given type. */
+export type TUppercase<Type extends TSchema> = (TInstantiate<{}, TUppercaseDeferred<Type>>);
+/** Applies a Uppercase action to the given type. */
+export declare function Uppercase<Type extends TSchema>(type: Type, options?: TSchemaOptions): TUppercase<Type>;

package/build/cjs/type/action/uppercase.js

@@ -0,0 +1,15 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UppercaseDeferred = UppercaseDeferred;
+exports.Uppercase = Uppercase;
+const deferred_1 = require("../types/deferred");
+const instantiate_1 = require("../engine/instantiate");
+/** Creates a deferred Uppercase action. */
+function UppercaseDeferred(type, options = {}) {
+    return (0, deferred_1.Deferred)('Uppercase', [type], options);
+}
+/** Applies a Uppercase action to the given type. */
+function Uppercase(type, options = {}) {
+    return (0, instantiate_1.Instantiate)({}, UppercaseDeferred(type, options));
+}

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

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

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

@@ -0,0 +1,10 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema';
+import { type TProperties } from '../../types/properties';
+import { type TPromise } from '../../types/promise';
+import { type TAwaitedDeferred } from '../../action/awaited';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate';
+type TAwaitedAction<Type extends TSchema> = (Type extends TPromise<infer Type extends TSchema> ? TAwaitedAction<Type> : Type);
+type TAwaitedImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TAwaitedAction<InstantiateType>;
+export type TAwaitedInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TAwaitedImmediate<Context, State, Type> : TAwaitedDeferred<Type>;
+export declare function AwaitedInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TAwaitedInstantiate<Context, State, Type>;
+export {};

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

@@ -0,0 +1,22 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AwaitedInstantiate = AwaitedInstantiate;
+const index_1 = require("../../../system/memory/index");
+const promise_1 = require("../../types/promise");
+const awaited_1 = require("../../action/awaited");
+const instantiate_1 = require("../instantiate");
+function AwaitedAction(type) {
+    return ((0, promise_1.IsPromise)(type)
+        ? AwaitedAction(type.item)
+        : type);
+}
+function AwaitedImmediate(context, state, type, options) {
+    const instantiatedType = (0, instantiate_1.InstantiateType)(context, state, type);
+    return index_1.Memory.Update(AwaitedAction(instantiatedType), {}, options);
+}
+function AwaitedInstantiate(context, state, type, options) {
+    return ((0, instantiate_1.CanInstantiate)(context, [type])
+        ? AwaitedImmediate(context, state, type, options)
+        : (0, awaited_1.AwaitedDeferred)(type, options));
+}

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

@@ -0,0 +1,20 @@
+import { type TSchema } from '../../types/schema';
+import { type TParameter } from '../../types/parameter';
+import { type TCallConstruct } from '../../types/call';
+import { type TRef } from '../../types/ref';
+import { type TGeneric } from '../../types/generic';
+import { type TProperties } from '../../types/properties';
+import { type TState } from '../instantiate';
+import { type TInstantiateType } from '../instantiate';
+import { type TInstantiateTypes } from '../instantiate';
+import { type TResolveTarget } from './resolve-target';
+import { type TResolveArgumentsContext } from './resolve-arguments';
+type TPeek<CallStack extends string[], Result extends string = CallStack extends [infer Left extends string, ...infer _ extends string[]] ? Left : ''> = Result;
+type TDeferredCall<Context extends TProperties, State extends TState, Target extends TSchema, Arguments extends TSchema[], InstantiatedArguments extends TSchema[] = TInstantiateTypes<Context, State, Arguments>, DeferredCall extends TSchema = TCallConstruct<Target, InstantiatedArguments>> = DeferredCall;
+type TTailCall<Context extends TProperties, State extends TState, Name extends string, Arguments extends TSchema[], DeferredCall extends TSchema = TDeferredCall<Context, State, TRef<Name>, Arguments>> = DeferredCall;
+type THeadCall<Context extends TProperties, State extends TState, Name extends string, Parameters extends TParameter[], Expression extends TSchema, Arguments extends TSchema[], InstantiatedArguments extends TSchema[] = TInstantiateTypes<Context, State, Arguments>, ArgumentsContext extends TProperties = TResolveArgumentsContext<Context, State, Parameters, InstantiatedArguments>, ReturnType extends TSchema = TInstantiateType<ArgumentsContext, {
+    callstack: [...State['callstack'], Name];
+}, Expression>> = TInstantiateType<Context, State, ReturnType>;
+export type TCallInstantiate<Context extends TProperties, State extends TState, Target extends TSchema, Arguments extends TSchema[], Resolved extends [string, TSchema] = TResolveTarget<Context, Target, Arguments>, Name extends string = Resolved[0], Type extends TSchema = Resolved[1], Result extends TSchema = (Type extends TGeneric<infer Parameters extends TParameter[], infer Expression extends TSchema> ? TPeek<State['callstack']> extends Name ? TTailCall<Context, State, Name, Arguments> : THeadCall<Context, State, Name, Parameters, Expression, Arguments> : TDeferredCall<Context, State, Target, Arguments>)> = Result;
+export declare function CallInstantiate<Context extends TProperties, State extends TState, Target extends TSchema, Arguments extends TSchema[]>(context: Context, state: State, target: Target, arguments_: [...Arguments]): TCallInstantiate<Context, State, Target, Arguments>;
+export {};

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

@@ -0,0 +1,41 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallInstantiate = CallInstantiate;
+const index_1 = require("../../../guard/index");
+const call_1 = require("../../types/call");
+const ref_1 = require("../../types/ref");
+const generic_1 = require("../../types/generic");
+const instantiate_1 = require("../instantiate");
+const instantiate_2 = require("../instantiate");
+// ----------------------------------------------------------------------------
+// Call: Infrastructure
+// ----------------------------------------------------------------------------
+const resolve_target_1 = require("./resolve-target");
+const resolve_arguments_1 = require("./resolve-arguments");
+function Peek(callstack) {
+    return (index_1.Guard.IsGreaterThan(callstack.length, 0) ? callstack[0] : '');
+}
+function DeferredCall(context, state, target, arguments_) {
+    const instantiatedArguments = (0, instantiate_2.InstantiateTypes)(context, state, arguments_);
+    const deferredCall = (0, call_1.CallConstruct)(target, instantiatedArguments);
+    return deferredCall;
+}
+function TailCall(context, state, name, arguments_) {
+    const deferredCall = DeferredCall(context, state, (0, ref_1.Ref)(name), arguments_);
+    return deferredCall;
+}
+function HeadCall(context, state, name, parameters, expression, arguments_) {
+    const instantiatedArguments = (0, instantiate_2.InstantiateTypes)(context, state, arguments_);
+    const argumentsContext = (0, resolve_arguments_1.ResolveArgumentsContext)(context, state, parameters, instantiatedArguments);
+    const returnType = (0, instantiate_1.InstantiateType)(argumentsContext, { callstack: [...state.callstack, name] }, expression);
+    return (0, instantiate_1.InstantiateType)(context, state, returnType);
+}
+function CallInstantiate(context, state, target, arguments_) {
+    const [name, type] = (0, resolve_target_1.ResolveTarget)(context, target, arguments_);
+    return ((0, generic_1.IsGeneric)(type)
+        ? index_1.Guard.IsEqual(Peek(state.callstack), name)
+            ? TailCall(context, state, name, arguments_)
+            : HeadCall(context, state, name, type.parameters, type.expression, arguments_)
+        : DeferredCall(context, state, target, arguments_));
+}

package/build/cjs/type/engine/call/resolve-arguments.d.ts

@@ -0,0 +1,13 @@
+import { Memory } from '../../../system/memory/index';
+import { type TSchema } from '../../types/schema';
+import { type TParameter } from '../../types/parameter';
+import { type TProperties } from '../../types/properties';
+import { type TState, type TInstantiateType } from '../instantiate';
+type TBindArgument<Context extends TProperties, State extends TState, Name extends string, Extends extends TSchema, Type extends TSchema, InstantiatedArgument extends TSchema = TInstantiateType<Context, State, Type>> = Memory.TAssign<Context, {
+    [_ in Name]: InstantiatedArgument;
+}>;
+type TBindArguments<Context extends TProperties, State extends TState, ParameterLeft extends TParameter, ParameterRight extends TParameter[], Arguments extends TSchema[], InstantiatedExtends extends TSchema = TInstantiateType<Context, State, ParameterLeft['extends']>, InstantiatedEquals extends TSchema = TInstantiateType<Context, State, ParameterLeft['equals']>> = (Arguments extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TBindParameters<TBindArgument<Context, State, ParameterLeft['name'], InstantiatedExtends, Left>, State, ParameterRight, Right> : TBindParameters<TBindArgument<Context, State, ParameterLeft['name'], InstantiatedExtends, InstantiatedEquals>, State, ParameterRight, []>);
+type TBindParameters<Context extends TProperties, State extends TState, Parameters extends TParameter[], Arguments extends TSchema[]> = (Parameters extends [infer Left extends TParameter, ...infer Right extends TParameter[]] ? TBindArguments<Context, State, Left, Right, Arguments> : Context);
+export type TResolveArgumentsContext<Context extends TProperties, State extends TState, Parameters extends TParameter[], Arguments extends TSchema[], Result extends TProperties = TBindParameters<Context, State, Parameters, Arguments>> = Result;
+export declare function ResolveArgumentsContext<Context extends TProperties, State extends TState, Parameters extends TParameter[], Arguments extends TSchema[]>(context: Context, state: State, parameters: [...Parameters], arguments_: [...Arguments]): TResolveArgumentsContext<Context, State, Parameters, Arguments>;
+export {};

package/build/cjs/type/engine/call/resolve-arguments.js

@@ -0,0 +1,42 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResolveArgumentsContext = ResolveArgumentsContext;
+const index_1 = require("../../../system/memory/index");
+const schema_1 = require("../../types/schema");
+const instantiate_1 = require("../instantiate");
+const index_2 = require("../../extends/index");
+const infer_1 = require("../../types/infer");
+const call_1 = require("../../types/call");
+// ------------------------------------------------------------------
+// AssertArgument
+// ------------------------------------------------------------------
+function AssertArgumentExtends(name, type, extends_) {
+    if ((0, infer_1.IsInfer)(type) || (0, call_1.IsCall)(type) || index_2.ExtendsResult.IsExtendsTrueLike((0, index_2.Extends)({}, type, extends_)))
+        return;
+    const cause = { parameter: name, extends: extends_, received: type };
+    // @ts-ignore - no definition for { cause } options 
+    throw new Error('Generic argument does not satify constraint', { cause });
+}
+function BindArgument(context, state, name, extends_, type) {
+    const instantiatedArgument = (0, instantiate_1.InstantiateType)(context, state, type);
+    AssertArgumentExtends(name, instantiatedArgument, extends_);
+    return index_1.Memory.Assign(context, { [name]: instantiatedArgument });
+}
+function BindArguments(context, state, parameterLeft, parameterRight, arguments_) {
+    const instantiatedExtends = (0, instantiate_1.InstantiateType)(context, state, parameterLeft.extends);
+    const instantiatedEquals = (0, instantiate_1.InstantiateType)(context, state, parameterLeft.equals);
+    const [left, ...right] = arguments_;
+    return ((0, schema_1.IsSchema)(left)
+        ? BindParameters(BindArgument(context, state, parameterLeft['name'], instantiatedExtends, left), state, parameterRight, right)
+        : BindParameters(BindArgument(context, state, parameterLeft['name'], instantiatedExtends, instantiatedEquals), state, parameterRight, []));
+}
+function BindParameters(context, state, parameters, arguments_) {
+    const [left, ...right] = parameters;
+    return ((0, schema_1.IsSchema)(left)
+        ? BindArguments(context, state, left, right, arguments_)
+        : context);
+}
+function ResolveArgumentsContext(context, state, parameters, arguments_) {
+    return BindParameters(context, state, parameters, arguments_);
+}

package/build/cjs/type/engine/call/resolve-target.d.ts

@@ -0,0 +1,25 @@
+import { type TSchema } from '../../types/schema';
+import { type TProperties } from '../../types/properties';
+import { type TGeneric } from '../../types/generic';
+import { type TRef } from '../../types/ref';
+import { type TParameter } from '../../types/parameter';
+import { type TNever } from '../../types/never';
+type TFromNotResolvable = ([
+    '(not-resolvable)',
+    TNever
+]);
+type TFromNotGeneric = ([
+    '(not-generic)',
+    TNever
+]);
+type TFromGeneric<Name extends string, Parameters extends TParameter[], Expression extends TSchema> = ([
+    Name,
+    TGeneric<Parameters, Expression>
+]);
+type TFromRef<Context extends TProperties, Ref extends string, Arguments extends TSchema[]> = (Ref extends keyof Context ? TFromType<Context, Ref, Context[Ref], Arguments> : TFromNotResolvable);
+type TFromType<Context extends TProperties, Name extends string, Type extends TSchema, Arguments extends TSchema[]> = (Type extends TGeneric<infer Parameters extends TParameter[], infer Expression extends TSchema> ? TFromGeneric<Name, Parameters, Expression> : Type extends TRef<infer Ref extends string> ? TFromRef<Context, Ref, Arguments> : TFromNotGeneric);
+/** Resolves a named generic target from the context, or returns TNever if it cannot be resolved or is not generic. */
+export type TResolveTarget<Context extends TProperties, Target extends TSchema, Arguments extends TSchema[], Result extends [string, TSchema] = TFromType<Context, '(anonymous)', Target, Arguments>> = Result;
+/** Resolves a named generic target from the context, or returns TNever if it cannot be resolved or is not generic. */
+export declare function ResolveTarget<Context extends TProperties, Target extends TSchema, Arguments extends TSchema[]>(context: Context, target: Target, arguments_: [...Arguments]): TFromType<Context, '(anonymous)', Target, Arguments>;
+export {};

package/build/cjs/type/engine/call/resolve-target.js

@@ -0,0 +1,30 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResolveTarget = ResolveTarget;
+const generic_1 = require("../../types/generic");
+const ref_1 = require("../../types/ref");
+const never_1 = require("../../types/never");
+function FromNotResolvable() {
+    return ['(not-resolvable)', (0, never_1.Never)()];
+}
+function FromNotGeneric() {
+    return ['(not-generic)', (0, never_1.Never)()];
+}
+function FromGeneric(name, parameters, expression) {
+    return [name, (0, generic_1.Generic)(parameters, expression)];
+}
+function FromRef(context, ref, arguments_) {
+    return (ref in context
+        ? FromType(context, ref, context[ref], arguments_)
+        : FromNotResolvable());
+}
+function FromType(context, name, target, arguments_) {
+    return ((0, generic_1.IsGeneric)(target) ? FromGeneric(name, target.parameters, target.expression) :
+        (0, ref_1.IsRef)(target) ? FromRef(context, target.$ref, arguments_) :
+            FromNotGeneric());
+}
+/** Resolves a named generic target from the context, or returns TNever if it cannot be resolved or is not generic. */
+function ResolveTarget(context, target, arguments_) {
+    return FromType(context, '(anonymous)', target, arguments_);
+}

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

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

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

@@ -0,0 +1,10 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema';
+import { type TUnion } from '../../types/union';
+import { type TProperties } from '../../types/properties';
+import { type TExtends, ExtendsResult } from '../../extends/index';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate';
+import { type TConditionalDeferred } from '../../action/conditional';
+type TConditionalImmediate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema, InstaniatedLeft extends TSchema = TInstantiateType<Context, State, Left>, InstaniatedRight extends TSchema = TInstantiateType<Context, State, Right>, ExtendsResult extends ExtendsResult.TResult = TExtends<Context, InstaniatedLeft, InstaniatedRight>> = (ExtendsResult extends ExtendsResult.TExtendsUnion<infer InferredContext extends TProperties> ? TUnion<[TInstantiateType<InferredContext, State, True>, TInstantiateType<Context, State, False>]> : ExtendsResult extends ExtendsResult.TExtendsTrue<infer InferredContext extends TProperties> ? TInstantiateType<InferredContext, State, True> : TInstantiateType<Context, State, False>);
+export type TConditionalInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema> = TCanInstantiate<Context, [Left, Right]> extends true ? TConditionalImmediate<Context, State, Left, Right, True, False> : TConditionalDeferred<Left, Right, True, False>;
+export declare function ConditionalInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema>(context: Context, state: State, left: Left, right: Right, true_: True, false_: False, options: TSchemaOptions): TConditionalInstantiate<Context, State, Left, Right, True, False>;
+export {};

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

@@ -0,0 +1,22 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConditionalInstantiate = ConditionalInstantiate;
+const index_1 = require("../../../system/memory/index");
+const union_1 = require("../../types/union");
+const index_2 = require("../../extends/index");
+const instantiate_1 = require("../instantiate");
+const conditional_1 = require("../../action/conditional");
+function ConditionalImmediate(context, state, left, right, true_, false_, options) {
+    const instantiatedLeft = (0, instantiate_1.InstantiateType)(context, state, left);
+    const instantiatedRight = (0, instantiate_1.InstantiateType)(context, state, right);
+    const extendsResult = (0, index_2.Extends)(context, instantiatedLeft, instantiatedRight);
+    return index_1.Memory.Update((index_2.ExtendsResult.IsExtendsUnion(extendsResult) ? (0, union_1.Union)([(0, instantiate_1.InstantiateType)(extendsResult.inferred, state, true_), (0, instantiate_1.InstantiateType)(context, state, false_)]) :
+        index_2.ExtendsResult.IsExtendsTrue(extendsResult) ? (0, instantiate_1.InstantiateType)(extendsResult.inferred, state, true_) :
+            (0, instantiate_1.InstantiateType)(context, state, false_)), {}, options);
+}
+function ConditionalInstantiate(context, state, left, right, true_, false_, options) {
+    return ((0, instantiate_1.CanInstantiate)(context, [left, right])
+        ? ConditionalImmediate(context, state, left, right, true_, false_, options)
+        : (0, conditional_1.ConditionalDeferred)(left, right, true_, false_, options));
+}

package/build/cjs/type/engine/constructor-parameters/index.d.ts

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

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

@@ -0,0 +1,14 @@
+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 TTuple } from '../../types/tuple';
+import { type TConstructorParametersDeferred } from '../../action/constructor-parameters';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate';
+type TConstructorParametersAction<Type extends TSchema> = (Type extends TConstructor<infer Parameters extends TSchema[], infer _ extends TSchema> ? TInstantiateType<{}, {
+    callstack: [];
+}, TTuple<Parameters>> : TNever);
+type TConstructorParametersImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TConstructorParametersAction<InstantiatedType>;
+export type TConstructorParametersInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TConstructorParametersImmediate<Context, State, Type> : TConstructorParametersDeferred<Type>;
+export declare function ConstructorParametersInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TConstructorParametersInstantiate<Context, State, Type>;
+export {};

package/build/cjs/type/engine/constructor-parameters/instantiate.js

@@ -0,0 +1,24 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstructorParametersInstantiate = ConstructorParametersInstantiate;
+const index_1 = require("../../../system/memory/index");
+const constructor_1 = require("../../types/constructor");
+const never_1 = require("../../types/never");
+const tuple_1 = require("../../types/tuple");
+const constructor_parameters_1 = require("../../action/constructor-parameters");
+const instantiate_1 = require("../instantiate");
+function ConstructorParametersAction(type) {
+    return ((0, constructor_1.IsConstructor)(type)
+        ? (0, instantiate_1.InstantiateType)({}, { callstack: [] }, (0, tuple_1.Tuple)(type.parameters))
+        : (0, never_1.Never)());
+}
+function ConstructorParametersImmediate(context, state, type, options) {
+    const instantiatedType = (0, instantiate_1.InstantiateType)(context, state, type);
+    return index_1.Memory.Update(ConstructorParametersAction(instantiatedType), {}, options);
+}
+function ConstructorParametersInstantiate(context, state, type, options) {
+    return ((0, instantiate_1.CanInstantiate)(context, [type])
+        ? ConstructorParametersImmediate(context, state, type, options)
+        : (0, constructor_parameters_1.ConstructorParametersDeferred)(type, options));
+}

package/build/cjs/type/engine/cyclic/candidates.d.ts

@@ -0,0 +1,9 @@
+import { type TUnreachable } from '../../../system/unreachable/index';
+import { type TProperties, TPropertyKeys } from '../../types/properties';
+import { type TCyclicCheck } from './check';
+type TResolveCandidateKeys<Context extends TProperties, Keys extends string[], Result extends string[] = []> = (Keys extends [infer Left extends string, ...infer Right extends string[]] ? Left extends keyof Context ? TCyclicCheck<[Left], Context, Context[Left]> extends true ? TResolveCandidateKeys<Context, Right, [...Result, Left]> : TResolveCandidateKeys<Context, Right, Result> : TUnreachable : Result);
+/** Returns keys for context types that need to be transformed to TCyclic. */
+export type TCyclicCandidates<Context extends TProperties, Keys extends string[] = TPropertyKeys<Context>, Result extends string[] = TResolveCandidateKeys<Context, Keys>> = Result;
+/** Returns keys for context types that need to be transformed to TCyclic. */
+export declare function CyclicCandidates<Context extends TProperties>(context: Context): TCyclicCandidates<Context>;
+export {};

package/build/cjs/type/engine/cyclic/candidates.js

@@ -0,0 +1,22 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CyclicCandidates = CyclicCandidates;
+const index_1 = require("../../../system/unreachable/index");
+const properties_1 = require("../../types/properties");
+const check_1 = require("./check");
+function ResolveCandidateKeys(context, keys) {
+    return keys.reduce((result, left) => {
+        return left in context
+            ? (0, check_1.CyclicCheck)([left], context, context[left])
+                ? [...result, left]
+                : result
+            : (0, index_1.Unreachable)();
+    }, []);
+}
+/** Returns keys for context types that need to be transformed to TCyclic. */
+function CyclicCandidates(context) {
+    const keys = (0, properties_1.PropertyKeys)(context);
+    const result = ResolveCandidateKeys(context, keys);
+    return result;
+}

package/build/cjs/type/engine/cyclic/check.d.ts

@@ -0,0 +1,24 @@
+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 TFunction } from '../../types/function';
+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, type TPropertyValues } 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 TInterfaceDeferred } from '../../action/interface';
+type TFromRef<Stack extends string[], Context extends TProperties, Ref extends string> = Ref extends Stack[number] ? true : TFromType<[...Stack, Ref], Context, Context[Ref]>;
+type TFromProperties<Stack extends string[], Context extends TProperties, Properties extends TProperties, Types extends TSchema[] = TPropertyValues<Properties>> = TFromTypes<Stack, Context, Types>;
+type TFromTypes<Stack extends string[], Context extends TProperties, Types extends TSchema[]> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromType<Stack, Context, Left> extends true ? true : TFromTypes<Stack, Context, Right> : false;
+type TFromType<Stack extends string[], Context extends TProperties, Type extends TSchema> = (Type extends TRef<infer Ref extends string> ? TFromRef<Stack, Context, Ref> : Type extends TArray<infer Type extends TSchema> ? TFromType<Stack, Context, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TFromType<Stack, Context, Type> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromTypes<Stack, Context, [...Parameters, InstanceType]> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromTypes<Stack, Context, [...Parameters, ReturnType]> : Type extends TInterfaceDeferred<TSchema[], infer Properties extends TProperties> ? TFromProperties<Stack, Context, Properties> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromTypes<Stack, Context, Types> : Type extends TIterator<infer Type extends TSchema> ? TFromType<Stack, Context, Type> : Type extends TObject<infer Properties extends TProperties> ? TFromProperties<Stack, Context, Properties> : Type extends TPromise<infer Type extends TSchema> ? TFromType<Stack, Context, Type> : Type extends TUnion<infer Types extends TSchema[]> ? TFromTypes<Stack, Context, Types> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTypes<Stack, Context, Types> : Type extends TRecord<string, infer Type extends TSchema> ? TFromType<Stack, Context, Type> : false);
+/** Performs a cyclic check on the given type. Initial key stack can be empty, but faster if specified */
+export type TCyclicCheck<Stack extends string[], Context extends TProperties, Type extends TSchema, Result extends boolean = TFromType<Stack, Context, Type>> = Result;
+/** Performs a cyclic check on the given type. Initial key stack can be empty, but faster if specified */
+export declare function CyclicCheck<Stack extends string[], Context extends TProperties, Type extends TSchema>(stack: [...Stack], context: Context, type: Type): TCyclicCheck<Stack, Context, Type>;
+export {};

package/build/cjs/type/engine/cyclic/check.js

@@ -0,0 +1,57 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CyclicCheck = CyclicCheck;
+const schema_1 = require("../../types/schema");
+const array_1 = require("../../types/array");
+const async_iterator_1 = require("../../types/async-iterator");
+const constructor_1 = require("../../types/constructor");
+const function_1 = require("../../types/function");
+const intersect_1 = require("../../types/intersect");
+const iterator_1 = require("../../types/iterator");
+const object_1 = require("../../types/object");
+const promise_1 = require("../../types/promise");
+const properties_1 = require("../../types/properties");
+const record_1 = require("../../types/record");
+const tuple_1 = require("../../types/tuple");
+const union_1 = require("../../types/union");
+const ref_1 = require("../../types/ref");
+const interface_1 = require("../../action/interface");
+function FromRef(stack, context, ref) {
+    return (stack.includes(ref)
+        ? true
+        : FromType([...stack, ref], context, context[ref]));
+}
+function FromProperties(stack, context, properties) {
+    const types = (0, properties_1.PropertyValues)(properties);
+    return FromTypes(stack, context, types);
+}
+function FromTypes(stack, context, types) {
+    const [left, ...right] = types;
+    return ((0, schema_1.IsSchema)(left)
+        ? FromType(stack, context, left)
+            ? true
+            : FromTypes(stack, context, right)
+        : false);
+}
+function FromType(stack, context, type) {
+    return ((0, ref_1.IsRef)(type) ? FromRef(stack, context, type.$ref) :
+        (0, array_1.IsArray)(type) ? FromType(stack, context, type.items) :
+            (0, async_iterator_1.IsAsyncIterator)(type) ? FromType(stack, context, type.iteratorItems) :
+                (0, constructor_1.IsConstructor)(type) ? FromTypes(stack, context, [...type.parameters, type.instanceType]) :
+                    (0, function_1.IsFunction)(type) ? FromTypes(stack, context, [...type.parameters, type.returnType]) :
+                        (0, interface_1.IsInterfaceDeferred)(type) ? FromProperties(stack, context, type.parameters[1]) :
+                            (0, intersect_1.IsIntersect)(type) ? FromTypes(stack, context, type.allOf) :
+                                (0, iterator_1.IsIterator)(type) ? FromType(stack, context, type.iteratorItems) :
+                                    (0, object_1.IsObject)(type) ? FromProperties(stack, context, type.properties) :
+                                        (0, promise_1.IsPromise)(type) ? FromType(stack, context, type.item) :
+                                            (0, union_1.IsUnion)(type) ? FromTypes(stack, context, type.anyOf) :
+                                                (0, tuple_1.IsTuple)(type) ? FromTypes(stack, context, type.items) :
+                                                    (0, record_1.IsRecord)(type) ? FromType(stack, context, (0, record_1.RecordValue)(type)) :
+                                                        false);
+}
+/** Performs a cyclic check on the given type. Initial key stack can be empty, but faster if specified */
+function CyclicCheck(stack, context, type) {
+    const result = FromType(stack, context, type);
+    return result;
+}

package/build/cjs/type/engine/cyclic/dependencies.d.ts

@@ -0,0 +1,25 @@
+import { type TUnreachable } from '../../../system/unreachable/index';
+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 TFunction } from '../../types/function';
+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, type TPropertyValues } 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 TInterfaceDeferred } from '../../action/interface';
+type TFromRef<Context extends TProperties, Ref extends string, Dependencies extends string[]> = Ref extends Dependencies[number] ? Dependencies : Ref extends keyof Context ? TFromType<Context, Context[Ref], [...Dependencies, Ref]> : TUnreachable;
+type TFromProperties<Context extends TProperties, Properties extends TProperties, Dependencies extends string[], Types extends TSchema[] = TPropertyValues<Properties>> = TFromTypes<Context, Types, Dependencies>;
+type TFromTypes<Context extends TProperties, Types extends TSchema[], Dependencies extends string[]> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromTypes<Context, Right, TFromType<Context, Left, Dependencies>> : Dependencies;
+type TFromType<Context extends TProperties, Type extends TSchema, Result extends string[]> = (Type extends TRef<infer Ref extends string> ? TFromRef<Context, Ref, Result> : Type extends TArray<infer Type extends TSchema> ? TFromType<Context, Type, Result> : Type extends TAsyncIterator<infer Type extends TSchema> ? TFromType<Context, Type, Result> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromTypes<Context, [...Parameters, InstanceType], Result> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromTypes<Context, [...Parameters, ReturnType], Result> : Type extends TInterfaceDeferred<TSchema[], infer Properties extends TProperties> ? TFromProperties<Context, Properties, Result> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromTypes<Context, Types, Result> : Type extends TIterator<infer Type extends TSchema> ? TFromType<Context, Type, Result> : Type extends TObject<infer Properties extends TProperties> ? TFromProperties<Context, Properties, Result> : Type extends TPromise<infer Type extends TSchema> ? TFromType<Context, Type, Result> : Type extends TUnion<infer Types extends TSchema[]> ? TFromTypes<Context, Types, Result> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTypes<Context, Types, Result> : Type extends TRecord<string, infer Type extends TSchema> ? TFromType<Context, Type, Result> : Result);
+/** Returns dependent cyclic keys for the given type. This function is used to dead-type-eliminate (DTE) for initializing TCyclic types. */
+export type TCyclicDependencies<Context extends TProperties, Key extends string, Type extends TSchema, Result extends string[] = TFromType<Context, Type, [Key]>> = Result;
+/** Returns dependent cyclic keys for the given type. This function is used to dead-type-eliminate (DTE) for initializing TCyclic types. */
+export declare function CyclicDependencies<Context extends TProperties, Key extends string, Type extends TSchema>(context: Context, key: Key, type: Type): TCyclicDependencies<Context, Key, Type>;
+export {};