typebox 1.1.33 → 1.1.35

package/build/type/engine/mapped/{mapped-operation.mjs → mapped_operation.mjs}

@@ -3,11 +3,11 @@
 import { Memory } from '../../../system/memory/index.mjs';
 import { IsLiteralNumber, IsLiteralString } from '../../types/literal.mjs';
 import { Object } from '../../types/object.mjs';
-import { IsTemplateLiteral } from '../../types/template-literal.mjs';
-import { TemplateLiteralDecode } from '../template-literal/decode.mjs';
+import { IsTemplateLiteral } from '../../types/template_literal.mjs';
+import { TemplateLiteralDecode } from '../template_literal/decode.mjs';
 import { InstantiateType } from '../instantiate.mjs';
 import { EvaluateIntersect } from '../evaluate/index.mjs';
-import { MappedVariants } from './mapped-variants.mjs';
+import { MappedVariants } from './mapped_variants.mjs';
 function CanonicalAs(instantiatedAs) {
     const result = IsTemplateLiteral(instantiatedAs)
         ? TemplateLiteralDecode(instantiatedAs.pattern)

package/build/type/engine/mapped/{mapped-variants.d.mts → mapped_variants.d.mts}

@@ -1,10 +1,10 @@
 import { type TSchema } from '../../types/index.mjs';
 import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
 import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
-import { type TTemplateLiteral } from '../../types/template-literal.mjs';
+import { type TTemplateLiteral } from '../../types/template_literal.mjs';
 import { type TUnion } from '../../types/union.mjs';
 import { type TEnumValuesToVariants } from '../enum/index.mjs';
-import { type TTemplateLiteralDecode } from '../template-literal/decode.mjs';
+import { type TTemplateLiteralDecode } from '../template_literal/decode.mjs';
 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 TFromLiteral<Value extends TLiteralValue, Result extends TSchema[] = Value extends number ? [TLiteral<`${Value}`>] : [TLiteral<Value>]> = Result;

package/build/type/engine/mapped/{mapped-variants.mjs → mapped_variants.mjs}

@@ -2,10 +2,10 @@
 import { Guard } from '../../../guard/index.mjs';
 import { Literal, IsLiteral } from '../../types/literal.mjs';
 import { IsEnum } from '../../types/enum.mjs';
-import { IsTemplateLiteral } from '../../types/template-literal.mjs';
+import { IsTemplateLiteral } from '../../types/template_literal.mjs';
 import { IsUnion } from '../../types/union.mjs';
 import { EnumValuesToVariants } from '../enum/index.mjs';
-import { TemplateLiteralDecode } from '../template-literal/decode.mjs';
+import { TemplateLiteralDecode } from '../template_literal/decode.mjs';
 function FromTemplateLiteral(pattern) {
     const decoded = TemplateLiteralDecode(pattern);
     const result = FromType(decoded);

package/build/type/engine/{non-nullable → non_nullable}/instantiate.d.mts

@@ -4,7 +4,7 @@ import { type TNull } from '../../types/null.mjs';
 import { type TUndefined } from '../../types/undefined.mjs';
 import { type TUnion } from '../../types/union.mjs';
 import { type TExcludeAction } from '../exclude/instantiate.mjs';
-import { type TNonNullableDeferred } from '../../action/non-nullable.mjs';
+import { type TNonNullableDeferred } from '../../action/non_nullable.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
 type TNonNullableOperation<Type extends TSchema, Excluded extends TSchema = TUnion<[TNull, TUndefined]>> = TExcludeAction<Type, Excluded>;
 export type TNonNullableAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TNonNullableOperation<Type> : TNonNullableDeferred<Type>> = Result;

package/build/type/engine/{non-nullable → non_nullable}/instantiate.mjs

@@ -4,7 +4,7 @@ import { Null } from '../../types/null.mjs';
 import { Undefined } from '../../types/undefined.mjs';
 import { Union } from '../../types/union.mjs';
 import { ExcludeAction } from '../exclude/instantiate.mjs';
-import { NonNullableDeferred } from '../../action/non-nullable.mjs';
+import { NonNullableDeferred } from '../../action/non_nullable.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
 function NonNullableOperation(type) {
     const excluded = Union([Null(), Undefined()]);

package/build/type/engine/object/collapse.d.mts

@@ -1,7 +1,7 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TObject } from '../../types/object.mjs';
-import { type TFromType } from './from-type.mjs';
+import { type TFromType } from './from_type.mjs';
 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

package/build/type/engine/object/collapse.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Object } from '../../types/object.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 /**
  * 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

package/build/type/engine/object/{from-cyclic.d.mts → from_cyclic.d.mts}

@@ -1,6 +1,6 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
-import { type TFromType } from './from-type.mjs';
+import { type TFromType } from './from_type.mjs';
 import { type TCyclicTarget } from '../cyclic/target.mjs';
 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/type/engine/object/{from-cyclic.mjs → from_cyclic.mjs}

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 import { CyclicTarget } from '../cyclic/target.mjs';
 export function FromCyclic(defs, ref) {
     const target = CyclicTarget(defs, ref);

package/build/type/engine/object/{from-intersect.d.mts → from_intersect.d.mts}

@@ -1,7 +1,7 @@
 import { Memory } from '../../../system/memory/index.mjs';
 import { type TSchema } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
-import { type TFromType } from './from-type.mjs';
+import { type TFromType } from './from_type.mjs';
 import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
 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];

package/build/type/engine/object/{from-intersect.mjs → from_intersect.mjs}

@@ -2,7 +2,7 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { Guard } from '../../../guard/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 import { EvaluateIntersect } from '../evaluate/evaluate.mjs';
 function CollapseIntersectProperties(left, right) {
     const leftKeys = Guard.Keys(left).filter((key) => !Guard.HasPropertyKey(right, key));

package/build/type/engine/object/{from-tuple.d.mts → from_tuple.d.mts}

@@ -1,6 +1,6 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
-import { type TTupleToObject } from '../tuple/to-object.mjs';
-import { type TFromType } from './from-type.mjs';
+import { type TTupleToObject } from '../tuple/to_object.mjs';
+import { type TFromType } from './from_type.mjs';
 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/type/engine/object/{from-tuple.mjs → from_tuple.mjs}

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { Tuple } from '../../types/tuple.mjs';
-import { TupleToObject } from '../tuple/to-object.mjs';
-import { FromType } from './from-type.mjs';
+import { TupleToObject } from '../tuple/to_object.mjs';
+import { FromType } from './from_type.mjs';
 export function FromTuple(types) {
     const object = TupleToObject(Tuple(types));
     const result = FromType(object);

package/build/type/engine/object/{from-type.d.mts → from_type.d.mts}

@@ -5,10 +5,10 @@ import { type TProperties } from '../../types/properties.mjs';
 import { type TObject } from '../../types/object.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
 import { type TUnion } from '../../types/union.mjs';
-import { type TFromCyclic } from './from-cyclic.mjs';
-import { type TFromIntersect } from './from-intersect.mjs';
-import { type TFromObject } from './from-object.mjs';
-import { type TFromTuple } from './from-tuple.mjs';
-import { type TFromUnion } from './from-union.mjs';
+import { type TFromCyclic } from './from_cyclic.mjs';
+import { type TFromIntersect } from './from_intersect.mjs';
+import { type TFromObject } from './from_object.mjs';
+import { type TFromTuple } from './from_tuple.mjs';
+import { type TFromUnion } from './from_union.mjs';
 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/type/engine/object/{from-type.mjs → from_type.mjs}

@@ -5,11 +5,11 @@ import { IsIntersect } from '../../types/intersect.mjs';
 import { IsObject } from '../../types/object.mjs';
 import { IsTuple } from '../../types/tuple.mjs';
 import { IsUnion } from '../../types/union.mjs';
-import { FromCyclic } from './from-cyclic.mjs';
-import { FromIntersect } from './from-intersect.mjs';
-import { FromObject } from './from-object.mjs';
-import { FromTuple } from './from-tuple.mjs';
-import { FromUnion } from './from-union.mjs';
+import { FromCyclic } from './from_cyclic.mjs';
+import { FromIntersect } from './from_intersect.mjs';
+import { FromObject } from './from_object.mjs';
+import { FromTuple } from './from_tuple.mjs';
+import { FromUnion } from './from_union.mjs';
 export function FromType(type) {
     return (IsCyclic(type) ? FromCyclic(type.$defs, type.$ref) :
         IsIntersect(type) ? FromIntersect(type.allOf) :

package/build/type/engine/object/{from-union.d.mts → from_union.d.mts}

@@ -2,7 +2,7 @@ import { type TUnreachable } from '../../../system/unreachable/index.mjs';
 import { type TSchema } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TEvaluateUnion } from '../evaluate/evaluate.mjs';
-import { type TFromType } from './from-type.mjs';
+import { type TFromType } from './from_type.mjs';
 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;

package/build/type/engine/object/{from-union.mjs → from_union.mjs}

@@ -2,7 +2,7 @@
 import { Guard } from '../../../guard/index.mjs';
 import { Unreachable } from '../../../system/unreachable/index.mjs';
 import { EvaluateUnion } from '../evaluate/evaluate.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 function CollapseUnionProperties(left, right) {
     const sharedKeys = Guard.Keys(left).filter((key) => key in right);
     const result = sharedKeys.reduce((result, key) => {

package/build/type/engine/omit/{from-type.d.mts → from_type.d.mts}

@@ -1,8 +1,8 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TObject } from '../../types/object.mjs';
-import { type TToIndexableKeys } from '../indexable/to-indexable-keys.mjs';
-import { type TToIndexable } from '../indexable/to-indexable.mjs';
+import { type TToIndexableKeys } from '../indexable/to_indexable_keys.mjs';
+import { type TToIndexable } from '../indexable/to_indexable.mjs';
 type TNormalKeys<Keys extends string[], UnionKeys extends string = Keys[number], Result extends string | number = (UnionKeys extends `${infer Value extends number}` ? UnionKeys | Value : UnionKeys)> = Result;
 type TFromKeys<Properties extends TProperties, Keys extends string[], Omitted extends TProperties = Omit<Properties, TNormalKeys<Keys>>, Result extends TProperties = {
     [Key in keyof Omitted]: Omitted[Key];

package/build/type/engine/omit/{from-type.mjs → from_type.mjs}

@@ -1,8 +1,8 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
 import { Object } from '../../types/object.mjs';
-import { ToIndexableKeys } from '../indexable/to-indexable-keys.mjs';
-import { ToIndexable } from '../indexable/to-indexable.mjs';
+import { ToIndexableKeys } from '../indexable/to_indexable_keys.mjs';
+import { ToIndexable } from '../indexable/to_indexable.mjs';
 function FromKeys(properties, keys) {
     const result = Guard.Keys(properties).reduce((result, key) => {
         return keys.includes(key) ? result : { ...result, [key]: properties[key] };

package/build/type/engine/omit/instantiate.d.mts

@@ -2,7 +2,7 @@ import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TOmitDeferred } from '../../action/omit.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
-import { type TFromType } from './from-type.mjs';
+import { type TFromType } from './from_type.mjs';
 export type TOmitAction<Type extends TSchema, Indexer extends TSchema, Result extends TSchema = TCanInstantiate<[Type, Indexer]> extends true ? TFromType<Type, Indexer> : TOmitDeferred<Type, Indexer>> = Result;
 export declare function OmitAction<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options: TSchemaOptions): TOmitAction<Type, Indexer>;
 export type TOmitInstantiate<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>> = TOmitAction<InstantiatedType, InstantiatedIndexer>;

package/build/type/engine/omit/instantiate.mjs

@@ -2,7 +2,7 @@
 import { Memory } from '../../../system/memory/index.mjs';
 import { OmitDeferred } from '../../action/omit.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 export function OmitAction(type, indexer, options) {
     const result = CanInstantiate([type, indexer])
         ? Memory.Update(FromType(type, indexer), {}, options)

package/build/type/engine/{readonly-object/from-cyclic.d.mts → partial/from_cyclic.d.mts}

@@ -2,7 +2,7 @@ import { Memory } from '../../../system/memory/index.mjs';
 import { type TSchema } from '../../types/schema.mjs';
 import { type TCyclic } from '../../types/cyclic.mjs';
 import { type TProperties } from '../../types/properties.mjs';
-import { type TFromType } from './from-type.mjs';
+import { type TFromType } from './from_type.mjs';
 import { type TCyclicTarget } from '../cyclic/target.mjs';
 export type TFromCyclic<Defs extends TProperties, Ref extends string, Target extends TSchema = TCyclicTarget<Defs, Ref>, Partial extends TSchema = TFromType<Target>, Result extends TSchema = TCyclic<Memory.TAssign<Defs, {
     [_ in Ref]: Partial;

package/build/type/engine/{readonly-object/from-cyclic.mjs → partial/from_cyclic.mjs}

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { Cyclic } from '../../types/cyclic.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 import { CyclicTarget } from '../cyclic/target.mjs';
 export function FromCyclic(defs, ref) {
     const target = CyclicTarget(defs, ref);

package/build/type/engine/partial/{from-intersect.d.mts → from_intersect.d.mts}

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

package/build/type/engine/partial/{from-intersect.mjs → from_intersect.mjs}

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 import { EvaluateIntersect } from '../evaluate/evaluate.mjs';
 export function FromIntersect(types) {
     const result = types.map(type => FromType(type));

package/build/type/engine/partial/{from-type.d.mts → from_type.d.mts}

@@ -4,9 +4,9 @@ import { type TIntersect } from '../../types/intersect.mjs';
 import { type TObject } from '../../types/object.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TUnion } from '../../types/union.mjs';
-import { type TFromCyclic } from './from-cyclic.mjs';
-import { type TFromIntersect } from './from-intersect.mjs';
-import { type TFromUnion } from './from-union.mjs';
-import { type TFromObject } from './from-object.mjs';
+import { type TFromCyclic } from './from_cyclic.mjs';
+import { type TFromIntersect } from './from_intersect.mjs';
+import { type TFromUnion } from './from_union.mjs';
+import { type TFromObject } from './from_object.mjs';
 export type TFromType<Type extends TSchema> = (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 TObject<infer Properties extends TProperties> ? TFromObject<Properties> : TObject<{}>);
 export declare function FromType<Type extends TSchema>(type: Type): TFromType<Type>;

package/build/type/engine/partial/{from-type.mjs → from_type.mjs}

@@ -4,10 +4,10 @@ import { IsCyclic } from '../../types/cyclic.mjs';
 import { IsIntersect } from '../../types/intersect.mjs';
 import { Object, IsObject } from '../../types/object.mjs';
 import { IsUnion } from '../../types/union.mjs';
-import { FromCyclic } from './from-cyclic.mjs';
-import { FromIntersect } from './from-intersect.mjs';
-import { FromUnion } from './from-union.mjs';
-import { FromObject } from './from-object.mjs';
+import { FromCyclic } from './from_cyclic.mjs';
+import { FromIntersect } from './from_intersect.mjs';
+import { FromUnion } from './from_union.mjs';
+import { FromObject } from './from_object.mjs';
 export function FromType(type) {
     return (IsCyclic(type) ? FromCyclic(type.$defs, type.$ref) :
         IsIntersect(type) ? FromIntersect(type.allOf) :

package/build/type/engine/{readonly-object/from-union.d.mts → partial/from_union.d.mts}

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

package/build/type/engine/{readonly-object/from-union.mjs → partial/from_union.mjs}

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Union } from '../../types/union.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 export function FromUnion(types) {
     const result = types.map(type => FromType(type));
     return Union(result);

package/build/type/engine/partial/instantiate.d.mts

@@ -1,7 +1,7 @@
 import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TPartialDeferred } from '../../action/partial.mjs';
-import { type TFromType } from './from-type.mjs';
+import { type TFromType } from './from_type.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
 export type TPartialAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<Type> : TPartialDeferred<Type>> = Result;
 export declare function PartialAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TPartialAction<Type>;

package/build/type/engine/partial/instantiate.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { PartialDeferred } from '../../action/partial.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
 export function PartialAction(type, options) {
     const result = CanInstantiate([type])

package/build/type/engine/pick/{from-type.d.mts → from_type.d.mts}

@@ -2,8 +2,8 @@ import { Memory } from '../../../system/memory/index.mjs';
 import { type TSchema } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TObject } from '../../types/object.mjs';
-import { type TToIndexableKeys } from '../indexable/to-indexable-keys.mjs';
-import { type TToIndexable } from '../indexable/to-indexable.mjs';
+import { type TToIndexableKeys } from '../indexable/to_indexable_keys.mjs';
+import { type TToIndexable } from '../indexable/to_indexable.mjs';
 type TComparable<Indexable extends TProperties> = (keyof Indexable extends string | number ? `${keyof Indexable}` : never);
 type TFromKeys<Indexable extends TProperties, Keys extends string[], Result extends TProperties = {}> = (Keys extends [infer Left extends string, ...infer Right extends string[]] ? Left extends TComparable<Indexable> ? TFromKeys<Indexable, Right, Memory.TAssign<Result, {
     [_ in Left]: Indexable[Left];

package/build/type/engine/pick/{from-type.mjs → from_type.mjs}

@@ -3,8 +3,8 @@
 import { Memory } from '../../../system/memory/index.mjs';
 import { Guard } from '../../../guard/index.mjs';
 import { Object } from '../../types/object.mjs';
-import { ToIndexableKeys } from '../indexable/to-indexable-keys.mjs';
-import { ToIndexable } from '../indexable/to-indexable.mjs';
+import { ToIndexableKeys } from '../indexable/to_indexable_keys.mjs';
+import { ToIndexable } from '../indexable/to_indexable.mjs';
 function FromKeys(properties, keys) {
     const result = Guard.Keys(properties).reduce((result, key) => {
         return keys.includes(key) ? Memory.Assign(result, { [key]: properties[key] }) : result;

package/build/type/engine/pick/instantiate.d.mts

@@ -2,7 +2,7 @@ import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TPickDeferred } from '../../action/pick.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
-import { type TFromType } from './from-type.mjs';
+import { type TFromType } from './from_type.mjs';
 export type TPickAction<Type extends TSchema, Indexer extends TSchema, Result extends TSchema = TCanInstantiate<[Type, Indexer]> extends true ? TFromType<Type, Indexer> : TPickDeferred<Type, Indexer>> = Result;
 export declare function PickAction<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options: TSchemaOptions): TPickAction<Type, Indexer>;
 export type TPickInstantiate<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>> = TPickAction<InstantiatedType, InstantiatedIndexer>;

package/build/type/engine/pick/instantiate.mjs

@@ -2,7 +2,7 @@
 import { Memory } from '../../../system/memory/index.mjs';
 import { PickDeferred } from '../../action/pick.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 export function PickAction(type, indexer, options) {
     const result = CanInstantiate([type, indexer])
         ? Memory.Update(FromType(type, indexer), {}, options)

package/build/type/engine/{partial/from-cyclic.d.mts → readonly_object/from_cyclic.d.mts}

@@ -2,7 +2,7 @@ import { Memory } from '../../../system/memory/index.mjs';
 import { type TSchema } from '../../types/schema.mjs';
 import { type TCyclic } from '../../types/cyclic.mjs';
 import { type TProperties } from '../../types/properties.mjs';
-import { type TFromType } from './from-type.mjs';
+import { type TFromType } from './from_type.mjs';
 import { type TCyclicTarget } from '../cyclic/target.mjs';
 export type TFromCyclic<Defs extends TProperties, Ref extends string, Target extends TSchema = TCyclicTarget<Defs, Ref>, Partial extends TSchema = TFromType<Target>, Result extends TSchema = TCyclic<Memory.TAssign<Defs, {
     [_ in Ref]: Partial;

package/build/type/engine/{required/from-cyclic.mjs → readonly_object/from_cyclic.mjs}

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { Cyclic } from '../../types/cyclic.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 import { CyclicTarget } from '../cyclic/target.mjs';
 export function FromCyclic(defs, ref) {
     const target = CyclicTarget(defs, ref);

package/build/type/engine/{readonly-object/from-intersect.d.mts → readonly_object/from_intersect.d.mts}

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

package/build/type/engine/{required/from-intersect.mjs → readonly_object/from_intersect.mjs}

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 import { EvaluateIntersect } from '../evaluate/evaluate.mjs';
 export function FromIntersect(types) {
     const result = types.map(type => FromType(type));

package/build/type/engine/{readonly-object/from-type.d.mts → readonly_object/from_type.d.mts}

@@ -6,11 +6,11 @@ import { type TObject } from '../../types/object.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
 import { type TUnion } from '../../types/union.mjs';
-import { type TFromArray } from './from-array.mjs';
-import { type TFromCyclic } from './from-cyclic.mjs';
-import { type TFromIntersect } from './from-intersect.mjs';
-import { type TFromObject } from './from-object.mjs';
-import { type TFromTuple } from './from-tuple.mjs';
-import { type TFromUnion } from './from-union.mjs';
+import { type TFromArray } from './from_array.mjs';
+import { type TFromCyclic } from './from_cyclic.mjs';
+import { type TFromIntersect } from './from_intersect.mjs';
+import { type TFromObject } from './from_object.mjs';
+import { type TFromTuple } from './from_tuple.mjs';
+import { type TFromUnion } from './from_union.mjs';
 export type TFromType<Type extends TSchema> = (Type extends TArray<infer Type extends TSchema> ? TFromArray<Type> : 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 TObject<infer Properties extends TProperties> ? TFromObject<Properties> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type);
 export declare function FromType<Type extends TSchema>(type: Type): TFromType<Type>;

package/build/type/engine/{readonly-object/from-type.mjs → readonly_object/from_type.mjs}

@@ -5,12 +5,12 @@ import { IsIntersect } from '../../types/intersect.mjs';
 import { IsObject } from '../../types/object.mjs';
 import { IsTuple } from '../../types/tuple.mjs';
 import { IsUnion } from '../../types/union.mjs';
-import { FromArray } from './from-array.mjs';
-import { FromCyclic } from './from-cyclic.mjs';
-import { FromIntersect } from './from-intersect.mjs';
-import { FromObject } from './from-object.mjs';
-import { FromTuple } from './from-tuple.mjs';
-import { FromUnion } from './from-union.mjs';
+import { FromArray } from './from_array.mjs';
+import { FromCyclic } from './from_cyclic.mjs';
+import { FromIntersect } from './from_intersect.mjs';
+import { FromObject } from './from_object.mjs';
+import { FromTuple } from './from_tuple.mjs';
+import { FromUnion } from './from_union.mjs';
 export function FromType(type) {
     return (IsArray(type) ? FromArray(type.items) :
         IsCyclic(type) ? FromCyclic(type.$defs, type.$ref) :

package/build/type/engine/{partial/from-union.d.mts → readonly_object/from_union.d.mts}

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

package/build/type/engine/{required/from-union.mjs → readonly_object/from_union.mjs}

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Union } from '../../types/union.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 export function FromUnion(types) {
     const result = types.map(type => FromType(type));
     return Union(result);

package/build/type/engine/{readonly-object → readonly_object}/instantiate.d.mts

@@ -1,7 +1,7 @@
 import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
-import { type TReadonlyObjectDeferred } from '../../action/readonly-object.mjs';
-import { type TFromType } from './from-type.mjs';
+import { type TReadonlyObjectDeferred } from '../../action/readonly_object.mjs';
+import { type TFromType } from './from_type.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
 export type TReadonlyObjectAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<Type> : TReadonlyObjectDeferred<Type>> = Result;
 export declare function ReadonlyObjectAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TReadonlyObjectAction<Type>;

package/build/type/engine/{readonly-object → readonly_object}/instantiate.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
-import { ReadonlyObjectDeferred } from '../../action/readonly-object.mjs';
-import { FromType } from './from-type.mjs';
+import { ReadonlyObjectDeferred } from '../../action/readonly_object.mjs';
+import { FromType } from './from_type.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
 export function ReadonlyObjectAction(type, options) {
     const result = CanInstantiate([type])

package/build/type/engine/record/{from-key.d.mts → from_key.d.mts}

@@ -8,17 +8,17 @@ import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
 import { type TNumber } from '../../types/number.mjs';
 import { type TObject } from '../../types/object.mjs';
 import { type TString } from '../../types/string.mjs';
-import { type TTemplateLiteral } from '../../types/template-literal.mjs';
+import { type TTemplateLiteral } from '../../types/template_literal.mjs';
 import { type TUnion } from '../../types/union.mjs';
-import { type TFromAnyKey } from './from-key-any.mjs';
-import { type TFromBooleanKey } from './from-key-boolean.mjs';
-import { type TFromEnumKey } from './from-key-enum.mjs';
-import { type TFromIntegerKey } from './from-key-integer.mjs';
-import { type TFromIntersectKey } from './from-key-intersect.mjs';
-import { type TFromLiteralKey } from './from-key-literal.mjs';
-import { type TFromNumberKey } from './from-key-number.mjs';
-import { type TFromStringKey } from './from-key-string.mjs';
-import { type TFromTemplateKey } from './from-key-template-literal.mjs';
-import { type TFromUnionKey } from './from-key-union.mjs';
+import { type TFromAnyKey } from './from_key_any.mjs';
+import { type TFromBooleanKey } from './from_key_boolean.mjs';
+import { type TFromEnumKey } from './from_key_enum.mjs';
+import { type TFromIntegerKey } from './from_key_integer.mjs';
+import { type TFromIntersectKey } from './from_key_intersect.mjs';
+import { type TFromLiteralKey } from './from_key_literal.mjs';
+import { type TFromNumberKey } from './from_key_number.mjs';
+import { type TFromStringKey } from './from_key_string.mjs';
+import { type TFromTemplateKey } from './from_key_template_literal.mjs';
+import { type TFromUnionKey } from './from_key_union.mjs';
 export type TFromKey<Key extends TSchema, Value extends TSchema, Result extends TSchema = (Key extends TAny ? TFromAnyKey<Value> : Key extends TBoolean ? TFromBooleanKey<Value> : Key extends TEnum<infer Values extends TEnumValue[]> ? TFromEnumKey<Values, Value> : Key extends TInteger ? TFromIntegerKey<Key, Value> : Key extends TIntersect<infer Types extends TSchema[]> ? TFromIntersectKey<Types, Value> : Key extends TLiteral<infer LiteralValue extends TLiteralValue> ? TFromLiteralKey<LiteralValue, Value> : Key extends TNumber ? TFromNumberKey<Key, Value> : Key extends TString ? TFromStringKey<Key, Value> : Key extends TTemplateLiteral<infer Pattern extends string> ? TFromTemplateKey<Pattern, Value> : Key extends TUnion<infer Types extends TSchema[]> ? TFromUnionKey<Types, Value> : TObject<{}>)> = Result;
 export declare function FromKey<Key extends TSchema, Value extends TSchema>(key: Key, value: Value): TFromKey<Key, Value>;

package/build/type/engine/record/{from-key.mjs → from_key.mjs}

@@ -9,21 +9,21 @@ import { IsLiteral } from '../../types/literal.mjs';
 import { IsNumber } from '../../types/number.mjs';
 import { Object } from '../../types/object.mjs';
 import { IsString } from '../../types/string.mjs';
-import { IsTemplateLiteral } from '../../types/template-literal.mjs';
+import { IsTemplateLiteral } from '../../types/template_literal.mjs';
 import { IsUnion } from '../../types/union.mjs';
 // ------------------------------------------------------------------
 // Keys and Deferred
 // ------------------------------------------------------------------
-import { FromAnyKey } from './from-key-any.mjs';
-import { FromBooleanKey } from './from-key-boolean.mjs';
-import { FromEnumKey } from './from-key-enum.mjs';
-import { FromIntegerKey } from './from-key-integer.mjs';
-import { FromIntersectKey } from './from-key-intersect.mjs';
-import { FromLiteralKey } from './from-key-literal.mjs';
-import { FromNumberKey } from './from-key-number.mjs';
-import { FromStringKey } from './from-key-string.mjs';
-import { FromTemplateKey } from './from-key-template-literal.mjs';
-import { FromUnionKey } from './from-key-union.mjs';
+import { FromAnyKey } from './from_key_any.mjs';
+import { FromBooleanKey } from './from_key_boolean.mjs';
+import { FromEnumKey } from './from_key_enum.mjs';
+import { FromIntegerKey } from './from_key_integer.mjs';
+import { FromIntersectKey } from './from_key_intersect.mjs';
+import { FromLiteralKey } from './from_key_literal.mjs';
+import { FromNumberKey } from './from_key_number.mjs';
+import { FromStringKey } from './from_key_string.mjs';
+import { FromTemplateKey } from './from_key_template_literal.mjs';
+import { FromUnionKey } from './from_key_union.mjs';
 export function FromKey(key, value) {
     const result = (IsAny(key) ? FromAnyKey(value) :
         IsBoolean(key) ? FromBooleanKey(value) :