typebox 1.0.31 → 1.0.33

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

@@ -0,0 +1,47 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyOfAction = KeyOfAction;
+exports.KeyOfImmediate = KeyOfImmediate;
+exports.KeyOfInstantiate = KeyOfInstantiate;
+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 record_1 = require("../../types/record");
+const tuple_1 = require("../../types/tuple");
+const union_1 = require("../../types/union");
+const keyof_1 = require("../../action/keyof");
+const instantiate_1 = require("../instantiate");
+const index_2 = require("../object/index");
+// ------------------------------------------------------------------
+// Computed
+// ------------------------------------------------------------------
+const from_array_1 = require("./from-array");
+const from_object_1 = require("./from-object");
+const from_record_1 = require("./from-record");
+const from_tuple_1 = require("./from-tuple");
+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 KeyOfAction(type) {
+    const normal = NormalizeType(type);
+    return ((0, array_1.IsArray)(normal) ? (0, from_array_1.FromArray)(normal.items) :
+        (0, object_1.IsObject)(normal) ? (0, from_object_1.FromObject)(normal.properties) :
+            (0, record_1.IsRecord)(normal) ? (0, from_record_1.FromRecord)(normal) :
+                (0, tuple_1.IsTuple)(normal) ? (0, from_tuple_1.FromTuple)(normal.items) :
+                    (0, never_1.Never)());
+}
+function KeyOfImmediate(context, state, type, options) {
+    const instantiatedType = (0, instantiate_1.InstantiateType)(context, state, type);
+    return index_1.Memory.Update(KeyOfAction(instantiatedType), {}, options);
+}
+function KeyOfInstantiate(context, state, type, options) {
+    return ((0, instantiate_1.CanInstantiate)(context, [type])
+        ? KeyOfImmediate(context, state, type, options)
+        : (0, keyof_1.KeyOfDeferred)(type, options));
+}

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

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

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

@@ -0,0 +1,28 @@
+import { Memory } from '../../../system/memory/index';
+import { type TSchema, type TSchemaOptions } from '../../types/schema';
+import { type TLiteral } from '../../types/literal';
+import { type TObject } from '../../types/object';
+import { type TProperties } from '../../types/properties';
+import { type TIdentifier } from '../../types/identifier';
+import { type TMappedKeys } from './mapped-keys';
+import { type TTemplateLiteral } from '../../types/template-literal';
+import { type TMappedDeferred } from '../../action/mapped';
+import { type TTemplateLiteralDecode } from '../template-literal/decode';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate';
+type TInstantiateKeyAs<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, ContextWithKey extends TProperties = Memory.TAssign<Context, {
+    [_ in Identifier['name']]: Key;
+}>, InstantiatedKeyAs extends TSchema = TInstantiateType<ContextWithKey, State, As>, Result extends TSchema = InstantiatedKeyAs extends TTemplateLiteral<infer Pattern extends string> ? TTemplateLiteralDecode<Pattern> : InstantiatedKeyAs> = Result;
+type TInstantiateProperty<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Key extends TSchema, Property extends TSchema, ContextWithKey extends TProperties = Memory.TAssign<Context, {
+    [_ in Identifier['name']]: Key;
+}>, InstantiatedProperty extends TSchema = TInstantiateType<ContextWithKey, State, Property>> = InstantiatedProperty;
+type TMappedProperty<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, Property extends TSchema, InstantiatedProperty extends TSchema = TInstantiateProperty<Context, State, Identifier, Key, Property>, InstantiatedKeyAs extends TSchema = TInstantiateKeyAs<Context, State, Identifier, Key, As>, Result extends TProperties = (InstantiatedKeyAs extends TLiteral<string | number> ? {
+    [_ in InstantiatedKeyAs['const']]: InstantiatedProperty;
+} : {})> = Result;
+type TMappedProperties<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Keys extends TSchema[], As extends TSchema, Type extends TSchema, Result extends TProperties = {}> = (Keys extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TMappedProperties<Context, State, Identifier, Right, As, Type, Result & TMappedProperty<Context, State, Identifier, Left, As, Type>> : Result);
+type TMappedAction<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, Property extends TSchema, Keys extends TSchema[] = TMappedKeys<Key>, Mapped extends TProperties = TMappedProperties<Context, State, Identifier, Keys, As, Property>, Result extends TSchema = TObject<{
+    [Key in keyof Mapped]: Mapped[Key];
+}>> = Result;
+type TMappedImmediate<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, Property extends TSchema, InstantiatedKey extends TSchema = TInstantiateType<Context, State, Key>> = TMappedAction<Context, State, Identifier, InstantiatedKey, As, Property>;
+export type TMappedInstantiate<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, Property extends TSchema> = TCanInstantiate<Context, [Key]> extends true ? TMappedImmediate<Context, State, Identifier, Key, As, Property> : TMappedDeferred<Identifier, Key, As, Property>;
+export declare function MappedInstantiate<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, Property extends TSchema>(context: Context, state: State, identifier: Identifier, key: Key, as: As, property: Property, options: TSchemaOptions): TMappedInstantiate<Context, State, Identifier, Key, As, Property>;
+export {};

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

@@ -0,0 +1,50 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MappedInstantiate = MappedInstantiate;
+const index_1 = require("../../../system/memory/index");
+const literal_1 = require("../../types/literal");
+const object_1 = require("../../types/object");
+const mapped_keys_1 = require("./mapped-keys");
+const template_literal_1 = require("../../types/template-literal");
+const mapped_1 = require("../../action/mapped");
+const decode_1 = require("../template-literal/decode");
+const instantiate_1 = require("../instantiate");
+function InstantiateKeyAs(context, state, identifier, key, as) {
+    const contextWithKey = index_1.Memory.Assign(context, { [identifier['name']]: key });
+    const instantiatedKeyAs = (0, instantiate_1.InstantiateType)(contextWithKey, state, as);
+    const result = (0, template_literal_1.IsTemplateLiteral)(instantiatedKeyAs) ? (0, decode_1.TemplateLiteralDecode)(instantiatedKeyAs.pattern) : instantiatedKeyAs;
+    return result;
+}
+function InstantiateProperty(context, state, identifier, key, property) {
+    const contextWithKey = index_1.Memory.Assign(context, { [identifier['name']]: key });
+    const instantiatedProperty = (0, instantiate_1.InstantiateType)(contextWithKey, state, property);
+    return instantiatedProperty;
+}
+function MappedProperty(context, state, identifier, key, as, property) {
+    const instantiatedProperty = InstantiateProperty(context, state, identifier, key, property);
+    const instantiatedKeyAs = InstantiateKeyAs(context, state, identifier, key, as);
+    return ((0, literal_1.IsLiteralString)(instantiatedKeyAs) || (0, literal_1.IsLiteralNumber)(instantiatedKeyAs)
+        ? { [instantiatedKeyAs.const]: instantiatedProperty }
+        : {});
+}
+function MappedProperties(context, state, identifier, keys, as, type) {
+    return keys.reduce((result, left) => {
+        return { ...result, ...MappedProperty(context, state, identifier, left, as, type) };
+    }, {});
+}
+function MappedAction(context, state, identifier, key, as, type) {
+    const keys = (0, mapped_keys_1.MappedKeys)(key);
+    const mapped = MappedProperties(context, state, identifier, keys, as, type);
+    const result = (0, object_1.Object)(mapped);
+    return result;
+}
+function MappedImmediate(context, state, identifier, key, as, property, options) {
+    const instantiatedKey = (0, instantiate_1.InstantiateType)(context, state, key);
+    return index_1.Memory.Update(MappedAction(context, state, identifier, instantiatedKey, as, property), {}, options);
+}
+function MappedInstantiate(context, state, identifier, key, as, property, options) {
+    return ((0, instantiate_1.CanInstantiate)(context, [key])
+        ? MappedImmediate(context, state, identifier, key, as, property, options)
+        : (0, mapped_1.MappedDeferred)(identifier, key, as, property, options));
+}

package/build/cjs/type/engine/mapped/mapped-keys.d.ts

@@ -0,0 +1,14 @@
+import { type TSchema } from '../../types/index';
+import { type TLiteral } from '../../types/literal';
+import { type TEnum, type TEnumValue } from '../../types/enum';
+import { type TTemplateLiteral } from '../../types/template-literal';
+import { type TUnion } from '../../types/union';
+import { type TEnumValuesToVariants } from '../enum/index';
+import { type TTemplateLiteralDecode } from '../template-literal/decode';
+type TFromTemplateLiteral<Pattern extends string, Decoded extends TSchema = TTemplateLiteralDecode<Pattern>, Result extends TSchema = TFromType<Decoded>> = Result;
+type TFromUnion<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromUnion<Right, [...Result, ...TFromType<Left>]> : Result);
+type TFromType<Type extends TSchema, Result extends TSchema[] = (Type extends TEnum<infer Values extends TEnumValue[]> ? TFromUnion<TEnumValuesToVariants<Values>> : Type extends TLiteral<string | number> ? [Type] : Type extends TTemplateLiteral<infer Pattern extends string> ? TFromTemplateLiteral<Pattern> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : [
+])> = Result;
+export type TMappedKeys<Type extends TSchema, Result extends TSchema[] = TFromType<Type>> = Result;
+export declare function MappedKeys<Type extends TSchema>(type: Type): TMappedKeys<Type>;
+export {};

package/build/cjs/type/engine/mapped/mapped-keys.js

@@ -0,0 +1,32 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MappedKeys = MappedKeys;
+const literal_1 = require("../../types/literal");
+const enum_1 = require("../../types/enum");
+const template_literal_1 = require("../../types/template-literal");
+const union_1 = require("../../types/union");
+const index_1 = require("../enum/index");
+const decode_1 = require("../template-literal/decode");
+function FromTemplateLiteral(pattern) {
+    const decoded = (0, decode_1.TemplateLiteralDecode)(pattern);
+    const result = FromType(decoded);
+    return result;
+}
+function FromUnion(types) {
+    return types.reduce((result, left) => {
+        return [...result, ...FromType(left)];
+    }, []);
+}
+function FromType(type) {
+    const result = ((0, enum_1.IsEnum)(type) ? FromUnion((0, index_1.EnumValuesToVariants)(type.enum)) :
+        (0, literal_1.IsLiteralString)(type) || (0, literal_1.IsLiteralNumber)(type) ? [type] :
+            (0, template_literal_1.IsTemplateLiteral)(type) ? FromTemplateLiteral(type.pattern) :
+                (0, union_1.IsUnion)(type) ? FromUnion(type.anyOf) :
+                    []);
+    return result;
+}
+function MappedKeys(type) {
+    const result = FromType(type);
+    return result;
+}

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

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

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

@@ -0,0 +1,21 @@
+import { Memory } from '../../../system/memory/index';
+import { type TSchemaOptions } from '../../types/schema';
+import { type TProperties } from '../../types/properties';
+import { type TState } from '../instantiate';
+import { type TCyclicCandidates } from '../cyclic/candidates';
+import { type TInstantiateCyclic } from '../cyclic/instantiate';
+import { type TInstantiateType } from '../instantiate';
+type TInstantiateCyclics<Context extends TProperties, CyclicKeys extends string[], Result extends TProperties = {
+    [Key in Extract<keyof Context, CyclicKeys[number]>]: TInstantiateCyclic<Context, Key, Context[Key]>;
+}> = Result;
+type TInstantiateNonCyclics<Context extends TProperties, CyclicKeys extends string[], Result extends TProperties = {
+    [Key in Exclude<keyof Context, CyclicKeys[number]>]: TInstantiateType<Context, {
+        callstack: [];
+    }, Context[Key]>;
+}> = Result;
+type TInstantiateModule<Context extends TProperties, CyclicCandidates extends string[] = TCyclicCandidates<Context>, InstantiatedCyclics extends TProperties = TInstantiateCyclics<Context, CyclicCandidates>, InstantiatedNonCyclics extends TProperties = TInstantiateNonCyclics<Context, CyclicCandidates>, InstantiatedModule extends TProperties = InstantiatedCyclics & InstantiatedNonCyclics> = {
+    [Key in keyof InstantiatedModule]: InstantiatedModule[Key];
+} & {};
+export type TModuleInstantiate<Context extends TProperties, _State extends TState, Properties extends TProperties, ModuleContext extends TProperties = Memory.TAssign<Context, Properties>, InstantiatedModule extends TProperties = TInstantiateModule<ModuleContext>> = InstantiatedModule;
+export declare function ModuleInstantiate<Context extends TProperties, State extends TState, Properties extends TProperties>(context: Context, _state: State, properties: Properties, options: TSchemaOptions): TModuleInstantiate<Context, State, Properties>;
+export {};

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

@@ -0,0 +1,36 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleInstantiate = ModuleInstantiate;
+const index_1 = require("../../../guard/index");
+const index_2 = require("../../../system/memory/index");
+// ------------------------------------------------------------------
+// Module: Instantiation Infrastructure
+// ------------------------------------------------------------------
+const candidates_1 = require("../cyclic/candidates");
+const instantiate_1 = require("../cyclic/instantiate");
+const instantiate_2 = require("../instantiate");
+function InstantiateCyclics(context, cyclicKeys) {
+    const keys = index_1.Guard.Keys(context).filter(key => cyclicKeys.includes(key));
+    return keys.reduce((result, key) => {
+        return { ...result, [key]: (0, instantiate_1.InstantiateCyclic)(context, key, context[key]) };
+    }, {});
+}
+function InstantiateNonCyclics(context, cyclicKeys) {
+    const keys = index_1.Guard.Keys(context).filter(key => !cyclicKeys.includes(key));
+    return keys.reduce((result, key) => {
+        return { ...result, [key]: (0, instantiate_2.InstantiateType)(context, { callstack: [] }, context[key]) };
+    }, {});
+}
+function InstantiateModule(context, options) {
+    const cyclicCandidates = (0, candidates_1.CyclicCandidates)(context);
+    const instantiatedCyclics = InstantiateCyclics(context, cyclicCandidates);
+    const instantiatedNonCyclics = InstantiateNonCyclics(context, cyclicCandidates);
+    const instantiatedModule = { ...instantiatedCyclics, ...instantiatedNonCyclics };
+    return index_2.Memory.Update(instantiatedModule, {}, options);
+}
+function ModuleInstantiate(context, _state, properties, options) {
+    const moduleContext = index_2.Memory.Assign(context, properties);
+    const instantiatedModule = InstantiateModule(moduleContext, options);
+    return instantiatedModule;
+}

package/build/cjs/type/engine/non-nullable/index.d.ts

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

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

@@ -0,0 +1,15 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema';
+import { type TProperties } from '../../types/properties';
+import { type TNull } from '../../types/null';
+import { type TUndefined } from '../../types/undefined';
+import { type TUnion } from '../../types/union';
+import { type TExcludeInstantiate } from '../exclude/instantiate';
+import { type TNonNullableDeferred } from '../../action/non-nullable';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate';
+type TNonNullableAction<Type extends TSchema, Excluded extends TSchema = TUnion<[TNull, TUndefined]>> = TExcludeInstantiate<{}, {
+    callstack: [];
+}, Type, Excluded>;
+type TNonNullableImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>, Result extends TSchema = TNonNullableAction<InstantiatedType>> = Result;
+export type TNonNullableInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TNonNullableImmediate<Context, State, Type> : TNonNullableDeferred<Type>;
+export declare function NonNullableInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TNonNullableInstantiate<Context, State, Type>;
+export {};

package/build/cjs/type/engine/non-nullable/instantiate.js

@@ -0,0 +1,24 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NonNullableInstantiate = NonNullableInstantiate;
+const index_1 = require("../../../system/memory/index");
+const null_1 = require("../../types/null");
+const undefined_1 = require("../../types/undefined");
+const union_1 = require("../../types/union");
+const instantiate_1 = require("../exclude/instantiate");
+const non_nullable_1 = require("../../action/non-nullable");
+const instantiate_2 = require("../instantiate");
+function NonNullableAction(type) {
+    const excluded = (0, union_1.Union)([(0, null_1.Null)(), (0, undefined_1.Undefined)()]);
+    return (0, instantiate_1.ExcludeInstantiate)({}, { callstack: [] }, type, excluded, {});
+}
+function NonNullableImmediate(context, state, type, options) {
+    const instantiatedType = (0, instantiate_2.InstantiateType)(context, state, type);
+    return index_1.Memory.Update(NonNullableAction(instantiatedType), {}, options);
+}
+function NonNullableInstantiate(context, state, type, options) {
+    return ((0, instantiate_2.CanInstantiate)(context, [type])
+        ? NonNullableImmediate(context, state, type, options)
+        : (0, non_nullable_1.NonNullableDeferred)(type, options));
+}

package/build/cjs/type/engine/object/collapse.d.ts

@@ -0,0 +1,12 @@
+import { type TSchema } from '../../types/schema';
+import { type TProperties } from '../../types/properties';
+import { type TObject } from '../../types/object';
+import { type TFromType } from './from-type';
+export type TCollapseToObject<Type extends TSchema, Properties extends TProperties = TFromType<Type>, Result extends TSchema = TObject<Properties>> = Result;
+/**
+ * Collapses a type into a TObject schema. This is a lossy fast path used to
+ * normalize arbitrary TSchema types into a TObject structure. This function is
+ * primarily used in indexing operations where a normalized object structure
+ * is required. If the type cannot be collapsed, an empty object schema is returned.
+ */
+export declare function CollapseToObject<Type extends TSchema>(type: Type): TCollapseToObject<Type>;

package/build/cjs/type/engine/object/collapse.js

@@ -0,0 +1,17 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollapseToObject = CollapseToObject;
+const object_1 = require("../../types/object");
+const from_type_1 = require("./from-type");
+/**
+ * Collapses a type into a TObject schema. This is a lossy fast path used to
+ * normalize arbitrary TSchema types into a TObject structure. This function is
+ * primarily used in indexing operations where a normalized object structure
+ * is required. If the type cannot be collapsed, an empty object schema is returned.
+ */
+function CollapseToObject(type) {
+    const properties = (0, from_type_1.FromType)(type);
+    const result = (0, object_1.Object)(properties);
+    return result;
+}

package/build/cjs/type/engine/object/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 TProperties = 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/object/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/object/from-intersect.d.ts

@@ -0,0 +1,17 @@
+import { Memory } from '../../../system/memory/index';
+import { type TSchema } from '../../types/schema';
+import { type TProperties } from '../../types/properties';
+import { type TFromType } from './from-type';
+import { type TEvaluateIntersect } from '../evaluate/evaluate';
+type TCollapseIntersectProperties<Left extends TProperties, Right extends TProperties, LeftKeys extends keyof Left = Exclude<keyof Left, keyof Right>, RightKeys extends keyof Right = Exclude<keyof Right, keyof Left>, SharedKeys extends keyof Left & keyof Right = Extract<keyof Left, keyof Right>, LeftProperties extends TProperties = {
+    [Key in LeftKeys]: Left[Key];
+}, RightProperties extends TProperties = {
+    [Key in RightKeys]: Right[Key];
+}, SharedProperties extends TProperties = {
+    [Key in SharedKeys]: TEvaluateIntersect<[Left[Key], Right[Key]]>;
+}, Unique extends TProperties = Memory.TAssign<LeftProperties, RightProperties>, Shared extends TProperties = Memory.TAssign<Unique, SharedProperties>> = Shared;
+export type TFromIntersect<Types extends TSchema[], Result extends TProperties = {}> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromIntersect<Right, TCollapseIntersectProperties<Result, TFromType<Left>>> : {
+    [Key in keyof Result]: Result[Key];
+});
+export declare function FromIntersect<Types extends TSchema[]>(types: [...Types]): TFromIntersect<Types>;
+export {};

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

@@ -0,0 +1,24 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromIntersect = FromIntersect;
+const index_1 = require("../../../system/memory/index");
+const index_2 = require("../../../guard/index");
+const from_type_1 = require("./from-type");
+const evaluate_1 = require("../evaluate/evaluate");
+function CollapseIntersectProperties(left, right) {
+    const leftKeys = index_2.Guard.Keys(left).filter((key) => !index_2.Guard.HasPropertyKey(right, key));
+    const rightKeys = index_2.Guard.Keys(right).filter((key) => !index_2.Guard.HasPropertyKey(left, key));
+    const sharedKeys = index_2.Guard.Keys(left).filter((key) => index_2.Guard.HasPropertyKey(right, key));
+    const leftProperties = leftKeys.reduce((result, key) => ({ ...result, [key]: left[key] }), {});
+    const rightProperties = rightKeys.reduce((result, key) => ({ ...result, [key]: right[key] }), {});
+    const sharedProperties = sharedKeys.reduce((result, key) => ({ ...result, [key]: (0, evaluate_1.EvaluateIntersect)([left[key], right[key]]) }), {});
+    const unique = index_1.Memory.Assign(leftProperties, rightProperties);
+    const shared = index_1.Memory.Assign(unique, sharedProperties);
+    return shared;
+}
+function FromIntersect(types) {
+    return types.reduce((result, left) => {
+        return CollapseIntersectProperties(result, (0, from_type_1.FromType)(left));
+    }, {});
+}

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

@@ -0,0 +1,3 @@
+import { type TProperties } from '../../types/properties';
+export type TFromObject<Properties extends TProperties> = (Properties);
+export declare function FromObject<Properties extends TProperties>(properties: Properties): TFromObject<Properties>;

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

@@ -0,0 +1,7 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromObject = FromObject;
+function FromObject(properties) {
+    return properties;
+}

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

@@ -0,0 +1,6 @@
+import { type TSchema } from '../../types/schema';
+import { type TTuple } from '../../types/tuple';
+import { type TTupleToObject } from '../tuple/to-object';
+import { type TFromType } from './from-type';
+export type TFromTuple<Types extends TSchema[], Object extends TSchema = TTupleToObject<TTuple<Types>>, Result extends TSchema = TFromType<Object>> = Result;
+export declare function FromTuple<Types extends TSchema[]>(types: [...Types]): TFromTuple<Types>;

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

@@ -0,0 +1,12 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromTuple = FromTuple;
+const tuple_1 = require("../../types/tuple");
+const to_object_1 = require("../tuple/to-object");
+const from_type_1 = require("./from-type");
+function FromTuple(types) {
+    const object = (0, to_object_1.TupleToObject)((0, tuple_1.Tuple)(types));
+    const result = (0, from_type_1.FromType)(object);
+    return result;
+}

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

@@ -0,0 +1,14 @@
+import { type TSchema } from '../../types/schema';
+import { type TCyclic } from '../../types/cyclic';
+import { type TIntersect } from '../../types/intersect';
+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 TFromCyclic } from './from-cyclic';
+import { type TFromIntersect } from './from-intersect';
+import { type TFromObject } from './from-object';
+import { type TFromTuple } from './from-tuple';
+import { type TFromUnion } from './from-union';
+export type TFromType<Type extends TSchema, Result extends TProperties = (Type extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? TFromCyclic<Defs, Ref> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties> : {})> = Result;
+export declare function FromType<Type extends TSchema>(type: Type): TFromType<Type>;

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

@@ -0,0 +1,22 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromType = FromType;
+const cyclic_1 = require("../../types/cyclic");
+const intersect_1 = require("../../types/intersect");
+const object_1 = require("../../types/object");
+const tuple_1 = require("../../types/tuple");
+const union_1 = require("../../types/union");
+const from_cyclic_1 = require("./from-cyclic");
+const from_intersect_1 = require("./from-intersect");
+const from_object_1 = require("./from-object");
+const from_tuple_1 = require("./from-tuple");
+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, intersect_1.IsIntersect)(type) ? (0, from_intersect_1.FromIntersect)(type.allOf) :
+            (0, union_1.IsUnion)(type) ? (0, from_union_1.FromUnion)(type.anyOf) :
+                (0, tuple_1.IsTuple)(type) ? (0, from_tuple_1.FromTuple)(type.items) :
+                    (0, object_1.IsObject)(type) ? (0, from_object_1.FromObject)(type.properties) :
+                        {});
+}

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

@@ -0,0 +1,12 @@
+import { type TUnreachable } from '../../../system/unreachable/index';
+import { type TSchema } from '../../types/schema';
+import { type TProperties } from '../../types/properties';
+import { type TEvaluateUnion } from '../evaluate/evaluate';
+import { type TFromType } from './from-type';
+type TCollapseUnionProperties<Left extends TProperties, Right extends TProperties, SharedKeys extends PropertyKey = keyof Left & keyof Right, Result extends TProperties = {
+    [Key in SharedKeys]: TEvaluateUnion<[Left[Key], Right[Key]]>;
+}> = Result;
+type TReduceVariants<Types extends TSchema[], Result extends TProperties> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TReduceVariants<Right, TCollapseUnionProperties<Result, TFromType<Left>>> : Result);
+export type TFromUnion<Types extends TSchema[]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TReduceVariants<Right, TFromType<Left>> : TUnreachable);
+export declare function FromUnion<Types extends TSchema[]>(types: [...Types]): TFromUnion<Types>;
+export {};

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

@@ -0,0 +1,29 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromUnion = FromUnion;
+const index_1 = require("../../../system/unreachable/index");
+const index_2 = require("../../../guard/index");
+const schema_1 = require("../../types/schema");
+const evaluate_1 = require("../evaluate/evaluate");
+const from_type_1 = require("./from-type");
+function CollapseUnionProperties(left, right) {
+    const sharedKeys = index_2.Guard.Keys(left).filter((key) => key in right);
+    const result = sharedKeys.reduce((result, key) => {
+        return { ...result, [key]: (0, evaluate_1.EvaluateUnion)([left[key], right[key]]) };
+    }, {});
+    return result;
+}
+function ReduceVariants(types, result) {
+    const [left, ...right] = types;
+    return ((0, schema_1.IsSchema)(left)
+        ? ReduceVariants(right, CollapseUnionProperties(result, (0, from_type_1.FromType)(left)))
+        : result);
+}
+function FromUnion(types) {
+    const [left, ...right] = types;
+    return ((0, schema_1.IsSchema)(left)
+        ? ReduceVariants(right, (0, from_type_1.FromType)(left))
+        : (0, index_1.Unreachable)());
+}
+// deno-coverage-ignore-stop

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

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

package/build/cjs/type/engine/object/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("./collapse"), exports);

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

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

package/build/cjs/type/engine/omit/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);