typebox 1.1.33 → 1.1.34

package/build/type/engine/indexable/{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 string[] = TFromType<Target>> = Result;
 export declare function FromCyclic<Defs extends TProperties, Ref extends string>(defs: Defs, ref: Ref): TFromCyclic<Defs, Ref>;

package/build/type/engine/indexable/{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/indexable/{from-enum.d.mts → from_enum.d.mts}

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

package/build/type/engine/indexable/{from-enum.mjs → from_enum.mjs}

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
-import { EnumValuesToVariants } from '../enum/enum-to-union.mjs';
-import { FromUnion } from './from-union.mjs';
+import { EnumValuesToVariants } from '../enum/enum_to_union.mjs';
+import { FromUnion } from './from_union.mjs';
 export function FromEnum(values) {
     const variants = EnumValuesToVariants(values);
     const result = FromUnion(variants);

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

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

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

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

package/build/type/engine/indexable/{from-template-literal.d.mts → from_template_literal.d.mts}

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

package/build/type/engine/indexable/{from-template-literal.mjs → from_template_literal.mjs}

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
-import { TemplateLiteralDecode } from '../template-literal/decode.mjs';
-import { FromType } from './from-type.mjs';
+import { TemplateLiteralDecode } from '../template_literal/decode.mjs';
+import { FromType } from './from_type.mjs';
 export function FromTemplateLiteral(pattern) {
     const decoded = TemplateLiteralDecode(pattern);
     const result = FromType(decoded);

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

@@ -4,14 +4,14 @@ import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
 import { type TIntersect } from '../../types/intersect.mjs';
 import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
 import { type TProperties } from '../../types/properties.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 TFromCyclic } from './from-cyclic.mjs';
-import { type TFromEnum } from './from-enum.mjs';
-import { type TFromIntersect } from './from-intersect.mjs';
-import { type TFromLiteral } from './from-literal.mjs';
-import { type TFromTemplateLiteral } from './from-template-literal.mjs';
-import { type TFromUnion } from './from-union.mjs';
+import { type TFromCyclic } from './from_cyclic.mjs';
+import { type TFromEnum } from './from_enum.mjs';
+import { type TFromIntersect } from './from_intersect.mjs';
+import { type TFromLiteral } from './from_literal.mjs';
+import { type TFromTemplateLiteral } from './from_template_literal.mjs';
+import { type TFromUnion } from './from_union.mjs';
 export type TFromType<Indexer extends TSchema, Result extends string[] = (Indexer extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? TFromCyclic<Defs, Ref> : Indexer extends TEnum<infer Values extends TEnumValue[]> ? TFromEnum<Values> : Indexer extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Indexer extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Value> : Indexer extends TTemplateLiteral<infer Pattern extends string> ? TFromTemplateLiteral<Pattern> : Indexer extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : [
 ])> = Result;
 export declare function FromType<Indexer extends TSchema>(type: Indexer): TFromType<Indexer>;

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

@@ -3,14 +3,14 @@ import { IsCyclic } from '../../types/cyclic.mjs';
 import { IsEnum } from '../../types/enum.mjs';
 import { IsIntersect } from '../../types/intersect.mjs';
 import { IsLiteral } from '../../types/literal.mjs';
-import { IsTemplateLiteral } from '../../types/template-literal.mjs';
+import { IsTemplateLiteral } from '../../types/template_literal.mjs';
 import { IsUnion } from '../../types/union.mjs';
-import { FromCyclic } from './from-cyclic.mjs';
-import { FromEnum } from './from-enum.mjs';
-import { FromIntersect } from './from-intersect.mjs';
-import { FromLiteral } from './from-literal.mjs';
-import { FromTemplateLiteral } from './from-template-literal.mjs';
-import { FromUnion } from './from-union.mjs';
+import { FromCyclic } from './from_cyclic.mjs';
+import { FromEnum } from './from_enum.mjs';
+import { FromIntersect } from './from_intersect.mjs';
+import { FromLiteral } from './from_literal.mjs';
+import { FromTemplateLiteral } from './from_template_literal.mjs';
+import { FromUnion } from './from_union.mjs';
 export function FromType(type) {
     return (IsCyclic(type) ? FromCyclic(type.$defs, type.$ref) :
         IsEnum(type) ? FromEnum(type.enum) :

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

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

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

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 export function FromUnion(types) {
     return types.reduce((result, left) => {
         return [...result, ...FromType(left)];

package/build/type/engine/indexable/{to-indexable-keys.d.mts → to_indexable_keys.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';
 export type TToIndexableKeys<Indexer extends TSchema, Result extends string[] = TFromType<Indexer>> = Result;
 /**
  * Transforms a type meant as an Indexer into string[] array which is used by Indexable types

package/build/type/engine/indexable/{to-indexable-keys.mjs → to_indexable_keys.mjs}

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 /**
  * Transforms a type meant as an Indexer into string[] array which is used by Indexable types
  * like Index, Pick and Omit to select from property keys. This function should only be used

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

@@ -4,8 +4,8 @@ import { type TNumber } from '../../types/number.mjs';
 import { type TNever } from '../../types/never.mjs';
 import { type TPropertyKeys } from '../../types/properties.mjs';
 import { type TEvaluateUnion } from '../evaluate/evaluate.mjs';
-import { type TToIndexableKeys } from '../indexable/to-indexable-keys.mjs';
-import { type TExpandThis } from '../this/expand-this.mjs';
+import { type TToIndexableKeys } from '../indexable/to_indexable_keys.mjs';
+import { type TExpandThis } from '../this/expand_this.mjs';
 type TIndexProperty<Properties extends TProperties, Key extends string, CanonicalKey extends string = keyof Properties extends string | number ? `${keyof Properties}` : never, SelectedType extends TSchema = Key extends CanonicalKey ? Properties[Key] : TNever, Result extends TSchema = TExpandThis<Properties, SelectedType>> = Result;
 type TIndexProperties<Properties extends TProperties, Keys extends string[], Result extends TSchema[] = []> = (Keys extends [infer Left extends string, ...infer Right extends string[]] ? TIndexProperties<Properties, Right, [...Result, TIndexProperty<Properties, Left>]> : Result);
 type TFromIndexer<Properties extends TProperties, Indexer extends TSchema, Keys extends string[] = TToIndexableKeys<Indexer>, Variants extends TSchema[] = TIndexProperties<Properties, Keys>, Result extends TSchema = TEvaluateUnion<Variants>> = Result;

package/build/type/engine/indexed/{from-object.mjs → from_object.mjs}

@@ -3,9 +3,9 @@ import { IsNumber } from '../../types/number.mjs';
 import { Never } from '../../types/never.mjs';
 import { PropertyKeys } from '../../types/properties.mjs';
 import { EvaluateUnion } from '../evaluate/evaluate.mjs';
-import { ToIndexableKeys } from '../indexable/to-indexable-keys.mjs';
+import { ToIndexableKeys } from '../indexable/to_indexable_keys.mjs';
 import { IntegerKey } from '../../types/record.mjs';
-import { ExpandThis } from '../this/expand-this.mjs';
+import { ExpandThis } from '../this/expand_this.mjs';
 function IndexProperty(properties, key) {
     const selectedType = key in properties ? properties[key] : Never();
     const result = ExpandThis(properties, selectedType);

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

@@ -4,7 +4,7 @@ import { type TNumber } from '../../types/number.mjs';
 import { type TInteger } from '../../types/integer.mjs';
 import { type TEvaluateUnionFast } from '../evaluate/evaluate.mjs';
 import { type TExtends, ExtendsResult } from '../../extends/index.mjs';
-import { type TFormatArrayIndexer } from './array-indexer.mjs';
+import { type TFormatArrayIndexer } from './array_indexer.mjs';
 type TIndexElementsWithIndexer<Types extends TSchema[], Indexer extends TSchema, Result extends TSchema[] = []> = (Types extends [...infer Left extends TSchema[], infer Right extends TSchema] ? TExtends<{}, TLiteral<Left['length']>, Indexer> extends ExtendsResult.TExtendsTrueLike ? TIndexElementsWithIndexer<Left, Indexer, [Right, ...Result]> : TIndexElementsWithIndexer<Left, Indexer, Result> : Result);
 type TFromTupleWithIndexer<Types extends TSchema[], Indexer extends TSchema, ArrayIndexer extends TSchema = TFormatArrayIndexer<Indexer>, Elements extends TSchema[] = TIndexElementsWithIndexer<Types, ArrayIndexer>, Result extends TSchema = TEvaluateUnionFast<Elements>> = Result;
 type TFromTupleWithoutIndexer<Types extends TSchema[], Result extends TSchema = TEvaluateUnionFast<Types>> = Result;

package/build/type/engine/indexed/{from-tuple.mjs → from_tuple.mjs}

@@ -6,7 +6,7 @@ import { IsNumber } from '../../types/number.mjs';
 import { IsInteger } from '../../types/integer.mjs';
 import { EvaluateUnionFast } from '../evaluate/evaluate.mjs';
 import { Extends, ExtendsResult } from '../../extends/index.mjs';
-import { FormatArrayIndexer } from './array-indexer.mjs';
+import { FormatArrayIndexer } from './array_indexer.mjs';
 function IndexElementsWithIndexer(types, indexer) {
     return types.reduceRight((result, right, index) => {
         const check = Extends({}, Literal(index), indexer);

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

@@ -4,8 +4,8 @@ import { type TNever } from '../../types/never.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TObject } from '../../types/object.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
-import { type TFromArray } from './from-array.mjs';
-import { type TFromObject } from './from-object.mjs';
-import { type TFromTuple } from './from-tuple.mjs';
+import { type TFromArray } from './from_array.mjs';
+import { type TFromObject } from './from_object.mjs';
+import { type TFromTuple } from './from_tuple.mjs';
 export type TFromType<Type extends TSchema, Indexer extends TSchema> = (Type extends TArray<infer Type extends TSchema> ? TFromArray<Type, Indexer> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties, Indexer> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types, Indexer> : TNever);
 export declare function FromType<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer): TFromType<Type, Indexer>;

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

@@ -3,9 +3,9 @@ import { IsArray } from '../../types/array.mjs';
 import { Never } from '../../types/never.mjs';
 import { IsObject } from '../../types/object.mjs';
 import { IsTuple } from '../../types/tuple.mjs';
-import { FromArray } from './from-array.mjs';
-import { FromObject } from './from-object.mjs';
-import { FromTuple } from './from-tuple.mjs';
+import { FromArray } from './from_array.mjs';
+import { FromObject } from './from_object.mjs';
+import { FromTuple } from './from_tuple.mjs';
 export function FromType(type, indexer) {
     return (IsArray(type) ? FromArray(type.items, indexer) :
         IsObject(type) ? FromObject(type.properties, indexer) :

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

@@ -6,7 +6,7 @@ import { type TUnion } from '../../types/union.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
 import { type TIndexDeferred } from '../../action/indexed.mjs';
 import { type TCollapseToObject } from '../object/index.mjs';
-import { type TFromType } from './from-type.mjs';
+import { type TFromType } from './from_type.mjs';
 type TNormalizeType<Type extends TSchema, Result extends TSchema = (Type extends TCyclic | TIntersect | TUnion ? TCollapseToObject<Type> : Type)> = Result;
 export type TIndexAction<Type extends TSchema, Indexer extends TSchema, Result extends TSchema = TCanInstantiate<[Type, Indexer]> extends true ? TFromType<TNormalizeType<Type>, Indexer> : TIndexDeferred<Type, Indexer>> = Result;
 export declare function IndexAction<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options: TSchemaOptions): TIndexAction<Type, Indexer>;

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

@@ -6,7 +6,7 @@ import { IsUnion } from '../../types/union.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
 import { IndexDeferred } from '../../action/indexed.mjs';
 import { CollapseToObject } from '../object/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 function NormalizeType(type) {
     const result = (IsCyclic(type) || IsIntersect(type) || IsUnion(type) ? CollapseToObject(type) :
         type);

package/build/type/engine/{instance-type → instance_type}/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 TConstructor } from '../../types/constructor.mjs';
 import { type TNever } from '../../types/never.mjs';
-import { type TInstanceTypeDeferred } from '../../action/instance-type.mjs';
+import { type TInstanceTypeDeferred } from '../../action/instance_type.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
 type TInstanceTypeOperation<Type extends TSchema> = (Type extends TConstructor ? Type['instanceType'] : TNever);
 export type TInstanceTypeAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TInstanceTypeOperation<Type> : TInstanceTypeDeferred<Type>> = Result;

package/build/type/engine/{instance-type → instance_type}/instantiate.mjs

@@ -2,7 +2,7 @@
 import { Memory } from '../../../system/memory/index.mjs';
 import { IsConstructor } from '../../types/constructor.mjs';
 import { Never } from '../../types/never.mjs';
-import { InstanceTypeDeferred } from '../../action/instance-type.mjs';
+import { InstanceTypeDeferred } from '../../action/instance_type.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
 function InstanceTypeOperation(type) {
     return (IsConstructor(type)

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

@@ -3,7 +3,7 @@ import { type TOptional, type TOptionalAdd, type TOptionalRemove } from '../type
 import { type TReadonly, type TReadonlyAdd, type TReadonlyRemove } from '../types/_readonly.mjs';
 import { type TSchema } from '../types/schema.mjs';
 import { type TArray } from '../types/array.mjs';
-import { type TAsyncIterator } from '../types/async-iterator.mjs';
+import { type TAsyncIterator } from '../types/async_iterator.mjs';
 import { type TConstructor } from '../types/constructor.mjs';
 import { type TDeferred } from '../types/deferred.mjs';
 import { type TFunction } from '../types/function.mjs';
@@ -25,29 +25,29 @@ import { type TAwaitedInstantiate } from './awaited/instantiate.mjs';
 import { type TCallInstantiate } from './call/instantiate.mjs';
 import { type TCapitalizeInstantiate } from './intrinsics/instantiate.mjs';
 import { type TConditionalInstantiate } from './conditional/index.mjs';
-import { type TConstructorParametersInstantiate } from './constructor-parameters/instantiate.mjs';
+import { type TConstructorParametersInstantiate } from './constructor_parameters/instantiate.mjs';
 import { type TEvaluateInstantiate } from './evaluate/instantiate.mjs';
 import { type TExcludeInstantiate } from './exclude/instantiate.mjs';
 import { type TExtractInstantiate } from './extract/instantiate.mjs';
 import { type TIndexInstantiate } from './indexed/instantiate.mjs';
-import { type TInstanceTypeInstantiate } from './instance-type/instantiate.mjs';
+import { type TInstanceTypeInstantiate } from './instance_type/instantiate.mjs';
 import { type TInterfaceInstantiate } from './interface/instantiate.mjs';
 import { type TKeyOfInstantiate } from './keyof/instantiate.mjs';
 import { type TLowercaseInstantiate } from './intrinsics/instantiate.mjs';
 import { type TMappedInstantiate } from './mapped/instantiate.mjs';
 import { type TModuleInstantiate } from './module/instantiate.mjs';
-import { type TNonNullableInstantiate } from './non-nullable/instantiate.mjs';
+import { type TNonNullableInstantiate } from './non_nullable/instantiate.mjs';
 import { type TOmitInstantiate } from './omit/instantiate.mjs';
 import { type TOptionsInstantiate } from './options/instantiate.mjs';
 import { type TParametersInstantiate } from './parameters/instantiate.mjs';
 import { type TPartialInstantiate } from './partial/instantiate.mjs';
 import { type TPickInstantiate } from './pick/instantiate.mjs';
-import { type TReadonlyObjectInstantiate } from './readonly-object/instantiate.mjs';
+import { type TReadonlyObjectInstantiate } from './readonly_object/instantiate.mjs';
 import { type TRecordInstantiate } from './record/instantiate.mjs';
 import { type TRefInstantiate } from './ref/instantiate.mjs';
 import { type TRequiredInstantiate } from './required/instantiate.mjs';
-import { type TReturnTypeInstantiate } from './return-type/instantiate.mjs';
-import { type TTemplateLiteralInstantiate } from './template-literal/instantiate.mjs';
+import { type TReturnTypeInstantiate } from './return_type/instantiate.mjs';
+import { type TTemplateLiteralInstantiate } from './template_literal/instantiate.mjs';
 import { type TUncapitalizeInstantiate } from './intrinsics/instantiate.mjs';
 import { type TUppercaseInstantiate } from './intrinsics/instantiate.mjs';
 import { type TRestSpread } from './rest/index.mjs';

package/build/type/engine/instantiate.mjs

@@ -12,7 +12,7 @@ import { IsReadonly, ReadonlyAdd, ReadonlyRemove } from '../types/_readonly.mjs'
 // ------------------------------------------------------------------
 import { IsBase } from '../types/base.mjs';
 import { _Array_, IsArray, ArrayOptions } from '../types/array.mjs';
-import { AsyncIterator, IsAsyncIterator, AsyncIteratorOptions } from '../types/async-iterator.mjs';
+import { AsyncIterator, IsAsyncIterator, AsyncIteratorOptions } from '../types/async_iterator.mjs';
 import { Constructor, IsConstructor, ConstructorOptions } from '../types/constructor.mjs';
 import { Deferred, IsDeferred } from '../types/deferred.mjs';
 import { _Function_, IsFunction, FunctionOptions } from '../types/function.mjs';
@@ -38,29 +38,29 @@ import { AwaitedInstantiate } from './awaited/instantiate.mjs';
 import { CallInstantiate } from './call/instantiate.mjs';
 import { CapitalizeInstantiate } from './intrinsics/instantiate.mjs';
 import { ConditionalInstantiate } from './conditional/index.mjs';
-import { ConstructorParametersInstantiate } from './constructor-parameters/instantiate.mjs';
+import { ConstructorParametersInstantiate } from './constructor_parameters/instantiate.mjs';
 import { EvaluateInstantiate } from './evaluate/instantiate.mjs';
 import { ExcludeInstantiate } from './exclude/instantiate.mjs';
 import { ExtractInstantiate } from './extract/instantiate.mjs';
 import { IndexInstantiate } from './indexed/instantiate.mjs';
-import { InstanceTypeInstantiate } from './instance-type/instantiate.mjs';
+import { InstanceTypeInstantiate } from './instance_type/instantiate.mjs';
 import { InterfaceInstantiate } from './interface/instantiate.mjs';
 import { KeyOfInstantiate } from './keyof/instantiate.mjs';
 import { LowercaseInstantiate } from './intrinsics/instantiate.mjs';
 import { MappedInstantiate } from './mapped/instantiate.mjs';
 import { ModuleInstantiate } from './module/instantiate.mjs';
-import { NonNullableInstantiate } from './non-nullable/instantiate.mjs';
+import { NonNullableInstantiate } from './non_nullable/instantiate.mjs';
 import { OmitInstantiate } from './omit/instantiate.mjs';
 import { OptionsInstantiate } from './options/instantiate.mjs';
 import { ParametersInstantiate } from './parameters/instantiate.mjs';
 import { PartialInstantiate } from './partial/instantiate.mjs';
 import { PickInstantiate } from './pick/instantiate.mjs';
-import { ReadonlyObjectInstantiate } from './readonly-object/instantiate.mjs';
+import { ReadonlyObjectInstantiate } from './readonly_object/instantiate.mjs';
 import { RecordInstantiate } from './record/instantiate.mjs';
 import { RefInstantiate } from './ref/instantiate.mjs';
 import { RequiredInstantiate } from './required/instantiate.mjs';
-import { ReturnTypeInstantiate } from './return-type/instantiate.mjs';
-import { TemplateLiteralInstantiate } from './template-literal/instantiate.mjs';
+import { ReturnTypeInstantiate } from './return_type/instantiate.mjs';
+import { TemplateLiteralInstantiate } from './template_literal/instantiate.mjs';
 import { UncapitalizeInstantiate } from './intrinsics/instantiate.mjs';
 import { UppercaseInstantiate } from './intrinsics/instantiate.mjs';
 import { RestSpread } from './rest/index.mjs';

package/build/type/engine/intrinsics/{from-template-literal.d.mts → from_template_literal.d.mts}

@@ -1,6 +1,6 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TMappingType, type TMappingFunc } from './mapping.mjs';
-import { type TTemplateLiteralDecode } from '../template-literal/decode.mjs';
-import { type TFromType } from './from-type.mjs';
+import { type TTemplateLiteralDecode } from '../template_literal/decode.mjs';
+import { type TFromType } from './from_type.mjs';
 export type TFromTemplateLiteral<Mapping extends TMappingType, Pattern extends string, Decoded extends TSchema = TTemplateLiteralDecode<Pattern>, Result extends TSchema = TFromType<Mapping, Decoded>> = Result;
 export declare function FromTemplateLiteral(mapping: TMappingFunc, pattern: string): TSchema;

package/build/type/engine/intrinsics/{from-template-literal.mjs → from_template_literal.mjs}

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
-import { TemplateLiteralDecode } from '../template-literal/decode.mjs';
-import { FromType } from './from-type.mjs';
+import { TemplateLiteralDecode } from '../template_literal/decode.mjs';
+import { FromType } from './from_type.mjs';
 export function FromTemplateLiteral(mapping, pattern) {
     const decoded = TemplateLiteralDecode(pattern);
     const result = FromType(mapping, decoded);

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

@@ -1,10 +1,10 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TLiteral, type TLiteralValue } from '../../types/literal.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 TMappingType, type TMappingFunc } from './mapping.mjs';
-import { type TFromLiteral } from './from-literal.mjs';
-import { type TFromTemplateLiteral } from './from-template-literal.mjs';
-import { type TFromUnion } from './from-union.mjs';
+import { type TFromLiteral } from './from_literal.mjs';
+import { type TFromTemplateLiteral } from './from_template_literal.mjs';
+import { type TFromUnion } from './from_union.mjs';
 export type TFromType<Mapping extends TMappingType, Type extends TSchema> = (Type extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Mapping, Value> : Type extends TTemplateLiteral<infer Pattern extends string> ? TFromTemplateLiteral<Mapping, Pattern> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Mapping, Types> : Type);
 export declare function FromType(mapping: TMappingFunc, type: TSchema): TSchema;

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

@@ -1,10 +1,10 @@
 // deno-fmt-ignore-file
 import { IsLiteral } from '../../types/literal.mjs';
-import { IsTemplateLiteral } from '../../types/template-literal.mjs';
+import { IsTemplateLiteral } from '../../types/template_literal.mjs';
 import { IsUnion } from '../../types/union.mjs';
-import { FromLiteral } from './from-literal.mjs';
-import { FromTemplateLiteral } from './from-template-literal.mjs';
-import { FromUnion } from './from-union.mjs';
+import { FromLiteral } from './from_literal.mjs';
+import { FromTemplateLiteral } from './from_template_literal.mjs';
+import { FromUnion } from './from_union.mjs';
 export function FromType(mapping, type) {
     return (IsLiteral(type) ? FromLiteral(mapping, type.const) :
         IsTemplateLiteral(type) ? FromTemplateLiteral(mapping, type.pattern) :

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

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

package/build/type/engine/intrinsics/{from-union.mjs → 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(mapping, types) {
     const result = types.map(type => FromType(mapping, type));
     return Union(result);

package/build/type/engine/intrinsics/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 TMappingType } from './mapping.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';
 import { type TCapitalizeDeferred } from '../../action/capitalize.mjs';
 import { type TLowercaseDeferred } from '../../action/lowercase.mjs';

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

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
 import { CapitalizeDeferred } from '../../action/capitalize.mjs';
 import { LowercaseDeferred } from '../../action/lowercase.mjs';

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

@@ -6,10 +6,10 @@ import { type TNever } from '../../types/never.mjs';
 import { type TObject } from '../../types/object.mjs';
 import { type TRecord } from '../../types/record.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
-import { type TFromAny } from './from-any.mjs';
-import { type TFromArray } from './from-array.mjs';
-import { type TFromObject } from './from-object.mjs';
-import { type TFromRecord } from './from-record.mjs';
-import { type TFromTuple } from './from-tuple.mjs';
+import { type TFromAny } from './from_any.mjs';
+import { type TFromArray } from './from_array.mjs';
+import { type TFromObject } from './from_object.mjs';
+import { type TFromRecord } from './from_record.mjs';
+import { type TFromTuple } from './from_tuple.mjs';
 export type TFromType<Type extends TSchema> = (Type extends TAny ? TFromAny : Type extends TArray<infer Type extends TSchema> ? TFromArray<Type> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties> : Type extends TRecord ? TFromRecord<Type> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types> : TNever);
 export declare function FromType<Type extends TSchema>(type: Type): TFromType<Type>;

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

@@ -8,11 +8,11 @@ import { IsTuple } from '../../types/tuple.mjs';
 // ------------------------------------------------------------------
 // Computed
 // ------------------------------------------------------------------
-import { FromAny } from './from-any.mjs';
-import { FromArray } from './from-array.mjs';
-import { FromObject } from './from-object.mjs';
-import { FromRecord } from './from-record.mjs';
-import { FromTuple } from './from-tuple.mjs';
+import { FromAny } from './from_any.mjs';
+import { FromArray } from './from_array.mjs';
+import { FromObject } from './from_object.mjs';
+import { FromRecord } from './from_record.mjs';
+import { FromTuple } from './from_tuple.mjs';
 export function FromType(type) {
     return (IsAny(type) ? FromAny() :
         IsArray(type) ? FromArray(type.items) :

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

@@ -6,7 +6,7 @@ import { type TUnion } from '../../types/union.mjs';
 import { type TKeyOfDeferred } from '../../action/keyof.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
 import { type TCollapseToObject } from '../object/index.mjs';
-import { type TFromType } from './from-type.mjs';
+import { type TFromType } from './from_type.mjs';
 type TNormalizeType<Type extends TSchema, Result extends TSchema = (Type extends TCyclic | TIntersect | TUnion ? TCollapseToObject<Type> : Type)> = Result;
 export type TKeyOfAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<TNormalizeType<Type>> : TKeyOfDeferred<Type>> = Result;
 export declare function KeyOfAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TKeyOfAction<Type>;

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

@@ -9,7 +9,7 @@ import { CollapseToObject } from '../object/index.mjs';
 // ------------------------------------------------------------------
 // Computed
 // ------------------------------------------------------------------
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 function NormalizeType(type) {
     const result = (IsCyclic(type) || IsIntersect(type) || IsUnion(type) ? CollapseToObject(type) : type);
     return result;

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

@@ -3,7 +3,7 @@ import { type TProperties } from '../../types/properties.mjs';
 import { type TIdentifier } from '../../types/identifier.mjs';
 import { type TMappedDeferred } from '../../action/mapped.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
-import { type TMappedOperation } from './mapped-operation.mjs';
+import { type TMappedOperation } from './mapped_operation.mjs';
 export type TMappedAction<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TMappedOperation<Context, State, Identifier, Type, As, Property> : TMappedDeferred<Identifier, Type, As, Property>> = Result;
 export declare function MappedAction<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema>(context: Context, state: State, identifier: Identifier, type: Type, as: As, property: Property, options: TSchemaOptions): TMappedAction<Context, State, Identifier, Type, As, Property>;
 export type TMappedInstantiate<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema, InstaniatedType extends TSchema = TInstantiateType<Context, State, Type>> = TMappedAction<Context, State, Identifier, InstaniatedType, As, Property>;

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

@@ -2,7 +2,7 @@
 import { Memory } from '../../../system/memory/index.mjs';
 import { MappedDeferred } from '../../action/mapped.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
-import { MappedOperation } from './mapped-operation.mjs';
+import { MappedOperation } from './mapped_operation.mjs';
 export function MappedAction(context, state, identifier, type, as, property, options) {
     const result = CanInstantiate([type])
         ? Memory.Update(MappedOperation(context, state, identifier, type, as, property), {}, options)

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

@@ -4,11 +4,11 @@ import { type TLiteral } from '../../types/literal.mjs';
 import { type TObject } from '../../types/object.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TIdentifier } from '../../types/identifier.mjs';
-import { type TTemplateLiteral } from '../../types/template-literal.mjs';
-import { type TTemplateLiteralDecode } from '../template-literal/decode.mjs';
+import { type TTemplateLiteral } from '../../types/template_literal.mjs';
+import { type TTemplateLiteralDecode } from '../template_literal/decode.mjs';
 import { type TState, type TInstantiateType } from '../instantiate.mjs';
 import { type TEvaluateIntersect } from '../evaluate/index.mjs';
-import { type TMappedVariants } from './mapped-variants.mjs';
+import { type TMappedVariants } from './mapped_variants.mjs';
 type TCanonicalAs<InstantiatedAs extends TSchema, Result extends TSchema = InstantiatedAs extends TTemplateLiteral<infer Pattern extends string> ? TTemplateLiteralDecode<Pattern> : InstantiatedAs> = Result;
 type TMappedVariant<Context extends TProperties, State extends TState, Identifier extends TIdentifier, Variant extends TSchema, As extends TSchema, Property extends TSchema, VariantContext extends TProperties = Memory.TAssign<Context, {
     [_ in Identifier['name']]: Variant;

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;