typebox 1.1.32 → 1.1.34

package/build/type/engine/{template-literal → template_literal}/decode.mjs

@@ -3,10 +3,10 @@ import { Guard } from '../../../guard/index.mjs';
 import { Unreachable } from '../../../system/unreachable/index.mjs';
 import { Literal, IsLiteral } from '../../types/literal.mjs';
 import { String } from '../../types/string.mjs';
-import { IsTemplateLiteral } from '../../types/template-literal.mjs';
+import { IsTemplateLiteral } from '../../types/template_literal.mjs';
 import { Union, IsUnion } from '../../types/union.mjs';
 import { ParsePatternIntoTypes } from '../patterns/pattern.mjs';
-import { IsTemplateLiteralFinite } from './is-finite.mjs';
+import { IsTemplateLiteralFinite } from './is_finite.mjs';
 import { TemplateLiteralCreate } from './create.mjs';
 function FromLiteralPush(variants, value, result = []) {
     return Guard.TakeLeft(variants, (left, right) => FromLiteralPush(right, value, [...result, `${left}${value}`]), () => result);

package/build/type/engine/{template-literal → template_literal}/encode.d.mts

@@ -2,14 +2,14 @@ import { type TSchema } from '../../types/schema.mjs';
 import { type TEnum, type TEnumValue } from '../../types/enum.mjs';
 import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
 import { type TUnion } from '../../types/union.mjs';
-import { type TTemplateLiteral, TTemplateLiteralDeferred } from '../../types/template-literal.mjs';
+import { type TTemplateLiteral, type TTemplateLiteralDeferred } from '../../types/template_literal.mjs';
 import { type TBigInt, BigIntPattern } from '../../types/bigint.mjs';
 import { type TString, StringPattern } from '../../types/string.mjs';
 import { type TNumber, NumberPattern } from '../../types/number.mjs';
 import { type TInteger, IntegerPattern } from '../../types/integer.mjs';
 import { type TBoolean } from '../../types/boolean.mjs';
 import { NeverPattern } from '../../types/never.mjs';
-import { type TEnumValuesToVariants } from '../enum/enum-to-union.mjs';
+import { type TEnumValuesToVariants } from '../enum/enum_to_union.mjs';
 import { type TTemplateLiteralAction } from './instantiate.mjs';
 type TJoinString<Input extends string[], Result extends string = ''> = (Input extends [infer Left extends string, ...infer Right extends string[]] ? Result extends '' ? TJoinString<Right, Left> : TJoinString<Right, `${Result}|${Left}`> : Result);
 type TUnwrapTemplateLiteralPattern<Pattern extends string> = (Pattern extends `^${infer Pattern extends string}$` ? Pattern : never);

package/build/type/engine/{template-literal → template_literal}/encode.mjs

@@ -3,7 +3,7 @@ import { Guard } from '../../../guard/index.mjs';
 import { IsEnum } from '../../types/enum.mjs';
 import { Literal, IsLiteral } from '../../types/literal.mjs';
 import { Union, IsUnion } from '../../types/union.mjs';
-import { IsTemplateLiteral, IsTemplateLiteralDeferred } from '../../types/template-literal.mjs';
+import { IsTemplateLiteral, IsTemplateLiteralDeferred } from '../../types/template_literal.mjs';
 import { IsBigInt, BigIntPattern } from '../../types/bigint.mjs';
 import { IsString, StringPattern } from '../../types/string.mjs';
 import { IsNumber, NumberPattern } from '../../types/number.mjs';
@@ -11,7 +11,7 @@ import { IsInteger, IntegerPattern } from '../../types/integer.mjs';
 import { IsBoolean } from '../../types/boolean.mjs';
 import { NeverPattern } from '../../types/never.mjs';
 import { TemplateLiteralCreate } from './create.mjs';
-import { EnumValuesToVariants } from '../enum/enum-to-union.mjs';
+import { EnumValuesToVariants } from '../enum/enum_to_union.mjs';
 import { TemplateLiteralAction } from './instantiate.mjs';
 function JoinString(input) {
     return input.join('|');

package/build/type/engine/{template-literal → template_literal}/index.d.mts

@@ -2,5 +2,5 @@ export * from './create.mjs';
 export * from './decode.mjs';
 export * from './encode.mjs';
 export * from './static.mjs';
-export * from './is-finite.mjs';
-export * from './is-pattern.mjs';
+export * from './is_finite.mjs';
+export * from './is_pattern.mjs';

package/build/type/engine/{template-literal → template_literal}/index.mjs

@@ -2,5 +2,5 @@ export * from './create.mjs';
 export * from './decode.mjs';
 export * from './encode.mjs';
 export * from './static.mjs';
-export * from './is-finite.mjs';
-export * from './is-pattern.mjs';
+export * from './is_finite.mjs';
+export * from './is_pattern.mjs';

package/build/type/engine/{template-literal → template_literal}/instantiate.d.mts

@@ -1,6 +1,6 @@
 import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
-import { type TTemplateLiteralDeferred } from '../../types/template-literal.mjs';
+import { type TTemplateLiteralDeferred } from '../../types/template_literal.mjs';
 import { type TTemplateLiteralEncode } from './encode.mjs';
 import { type TState, type TInstantiateTypes, type TCanInstantiate } from '../instantiate.mjs';
 export type TTemplateLiteralAction<Types extends TSchema[], Result extends TSchema = TCanInstantiate<Types> extends true ? TTemplateLiteralEncode<Types> : TTemplateLiteralDeferred<Types>> = Result;

package/build/type/engine/{template-literal → template_literal}/instantiate.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
-import { TemplateLiteralDeferred } from '../../types/template-literal.mjs';
+import { TemplateLiteralDeferred } from '../../types/template_literal.mjs';
 import { TemplateLiteralEncode } from './encode.mjs';
 import { InstantiateTypes, CanInstantiate } from '../instantiate.mjs';
 export function TemplateLiteralAction(types, options) {

package/build/type/engine/this/{expand-this.d.mts → expand_this.d.mts}

@@ -1,5 +1,5 @@
 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 TFunction } from '../../types/function.mjs';
 import { type TIterator } from '../../types/iterator.mjs';

package/build/type/engine/this/{expand-this.mjs → expand_this.mjs}

@@ -1,11 +1,11 @@
 // deno-fmt-ignore-file
-import { IsArray, Array } from '../../types/array.mjs';
-import { IsAsyncIterator, AsyncIterator } from '../../types/async-iterator.mjs';
+import { IsArray, _Array_ } from '../../types/array.mjs';
+import { IsAsyncIterator, AsyncIterator } from '../../types/async_iterator.mjs';
 import { IsConstructor, Constructor } from '../../types/constructor.mjs';
-import { IsFunction, Function } from '../../types/function.mjs';
+import { IsFunction, _Function_ } from '../../types/function.mjs';
 import { IsIterator, Iterator } from '../../types/iterator.mjs';
 import { IsIntersect, Intersect } from '../../types/intersect.mjs';
-import { Object } from '../../types/object.mjs';
+import { _Object_ } from '../../types/object.mjs';
 import { IsPromise, Promise } from '../../types/promise.mjs';
 import { IsTuple, Tuple } from '../../types/tuple.mjs';
 import { IsThis } from '../../types/this.mjs';
@@ -14,16 +14,16 @@ function FromTypes(properties, types) {
     return types.map(type => FromType(properties, type));
 }
 export function FromType(properties, type) {
-    return (IsArray(type) ? Array(FromType(properties, type.items)) :
+    return (IsArray(type) ? _Array_(FromType(properties, type.items)) :
         IsAsyncIterator(type) ? AsyncIterator(FromType(properties, type.iteratorItems)) :
             IsConstructor(type) ? Constructor(FromTypes(properties, type.parameters), FromType(properties, type.instanceType)) :
-                IsFunction(type) ? Function(FromTypes(properties, type.parameters), FromType(properties, type.returnType)) :
+                IsFunction(type) ? _Function_(FromTypes(properties, type.parameters), FromType(properties, type.returnType)) :
                     IsIterator(type) ? Iterator(FromType(properties, type.iteratorItems)) :
                         IsPromise(type) ? Promise(FromType(properties, type.item)) :
                             IsTuple(type) ? Tuple(FromTypes(properties, type.items)) :
                                 IsUnion(type) ? Union(FromTypes(properties, type.anyOf)) :
                                     IsIntersect(type) ? Intersect(FromTypes(properties, type.allOf)) :
-                                        IsThis(type) ? Object(properties) :
+                                        IsThis(type) ? _Object_(properties) :
                                             type);
 }
 export function ExpandThis(properties, type) {

package/build/type/extends/any.d.mts

@@ -3,7 +3,7 @@ import { type TProperties } from '../types/properties.mjs';
 import { type TInfer } from '../types/infer.mjs';
 import { type TAny } from '../types/any.mjs';
 import { type TUnknown } from '../types/unknown.mjs';
-import { type TExtendsRight } from './extends-right.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
 import * as Result from './result.mjs';
 export type TExtendsAny<Inferred extends TProperties, Left extends TAny, Right extends TSchema> = (Right extends TInfer ? TExtendsRight<Inferred, Left, Right> : Right extends TAny ? Result.TExtendsTrue<Inferred> : Right extends TUnknown ? Result.TExtendsTrue<Inferred> : Result.TExtendsUnion<Inferred>);
 export declare function ExtendsAny<Inferred extends TProperties, Left extends TAny, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsAny<Inferred, Left, Right>;

package/build/type/extends/any.mjs

@@ -2,7 +2,7 @@
 import { IsInfer } from '../types/infer.mjs';
 import { IsAny } from '../types/any.mjs';
 import { IsUnknown } from '../types/unknown.mjs';
-import { ExtendsRight } from './extends-right.mjs';
+import { ExtendsRight } from './extends_right.mjs';
 import * as Result from './result.mjs';
 export function ExtendsAny(inferred, left, right) {
     return (IsInfer(right) ? ExtendsRight(inferred, left, right) :

package/build/type/extends/array.d.mts

@@ -2,8 +2,8 @@ import { type TSchema } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
 import { type TArray } from '../types/array.mjs';
 import { type TImmutable } from '../types/_immutable.mjs';
-import { type TExtendsRight } from './extends-right.mjs';
-import { type TExtendsLeft } from './extends-left.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
 import * as Result from './result.mjs';
 type TExtendsImmutable<Left extends TSchema, Right extends TSchema, IsImmutableLeft extends boolean = Left extends TImmutable ? true : false, IsImmutableRight extends boolean = Right extends TImmutable ? true : false, Result extends boolean = [
     IsImmutableLeft,

package/build/type/extends/array.mjs

@@ -1,8 +1,8 @@
 // deno-fmt-ignore-file
 import { IsArray } from '../types/array.mjs';
 import { IsImmutable } from '../types/_immutable.mjs';
-import { ExtendsRight } from './extends-right.mjs';
-import { ExtendsLeft } from './extends-left.mjs';
+import { ExtendsRight } from './extends_right.mjs';
+import { ExtendsLeft } from './extends_left.mjs';
 import * as Result from './result.mjs';
 function ExtendsImmutable(left, right) {
     const isImmutableLeft = IsImmutable(left);

package/build/type/extends/{async-iterator.d.mts → async_iterator.d.mts}

@@ -1,7 +1,7 @@
 import { type TSchema } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
-import { type TAsyncIterator } from '../types/async-iterator.mjs';
-import { type TExtendsRight } from './extends-right.mjs';
-import { type TExtendsLeft } from './extends-left.mjs';
+import { type TAsyncIterator } from '../types/async_iterator.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
 export type TExtendsAsyncIterator<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Right extends TAsyncIterator<infer Type extends TSchema> ? TExtendsLeft<Inferred, Left, Type> : TExtendsRight<Inferred, TAsyncIterator<Left>, Right>);
 export declare function ExtendsAsyncIterator<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsAsyncIterator<Inferred, Left, Right>;

package/build/type/extends/{async-iterator.mjs → async_iterator.mjs}

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
-import { AsyncIterator, IsAsyncIterator } from '../types/async-iterator.mjs';
-import { ExtendsRight } from './extends-right.mjs';
-import { ExtendsLeft } from './extends-left.mjs';
+import { AsyncIterator, IsAsyncIterator } from '../types/async_iterator.mjs';
+import { ExtendsRight } from './extends_right.mjs';
+import { ExtendsLeft } from './extends_left.mjs';
 export function ExtendsAsyncIterator(inferred, left, right) {
     return (IsAsyncIterator(right)
         ? ExtendsLeft(inferred, left, right.iteratorItems)

package/build/type/extends/bigint.d.mts

@@ -1,7 +1,7 @@
 import { type TSchema } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
 import { type TBigInt } from '../types/bigint.mjs';
-import { type TExtendsRight } from './extends-right.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
 import * as Result from './result.mjs';
 export type TExtendsBigInt<Inferred extends TProperties, Left extends TBigInt, Right extends TSchema> = (Right extends TBigInt ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, Left, Right>);
 export declare function ExtendsBigInt<Inferred extends TProperties, Left extends TBigInt, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsBigInt<Inferred, Left, Right>;

package/build/type/extends/bigint.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { IsBigInt } from '../types/bigint.mjs';
-import { ExtendsRight } from './extends-right.mjs';
+import { ExtendsRight } from './extends_right.mjs';
 import * as Result from './result.mjs';
 export function ExtendsBigInt(inferred, left, right) {
     return (IsBigInt(right)

package/build/type/extends/boolean.d.mts

@@ -1,7 +1,7 @@
 import { type TSchema } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
 import { type TBoolean } from '../types/boolean.mjs';
-import { type TExtendsRight } from './extends-right.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
 import * as Result from './result.mjs';
 export type TExtendsBoolean<Inferred extends TProperties, Left extends TBoolean, Right extends TSchema> = (Right extends TBoolean ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, Left, Right>);
 export declare function ExtendsBoolean<Inferred extends TProperties, Left extends TBoolean, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsBoolean<Inferred, Left, Right>;

package/build/type/extends/boolean.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { IsBoolean } from '../types/boolean.mjs';
-import { ExtendsRight } from './extends-right.mjs';
+import { ExtendsRight } from './extends_right.mjs';
 import * as Result from './result.mjs';
 export function ExtendsBoolean(inferred, left, right) {
     return (IsBoolean(right)

package/build/type/extends/constructor.d.mts

@@ -5,6 +5,6 @@ import { type TConstructor } from '../types/constructor.mjs';
 import { type TUnknown } from '../types/unknown.mjs';
 import * as Result from './result.mjs';
 import { type TExtendsParameters } from './parameters.mjs';
-import { type TExtendsReturnType } from './return-type.mjs';
+import { type TExtendsReturnType } from './return_type.mjs';
 export type TExtendsConstructor<Inferred extends TProperties, Parameters extends TSchema[], InstanceType extends TSchema, Right extends TSchema> = (Right extends TAny ? Result.TExtendsTrue<Inferred> : Right extends TUnknown ? Result.TExtendsTrue<Inferred> : Right extends TConstructor ? TExtendsParameters<Inferred, Parameters, Right['parameters']> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsReturnType<Inferred, InstanceType, Right['instanceType']> : Result.TExtendsFalse : Result.TExtendsFalse);
 export declare function ExtendsConstructor<Inferred extends TProperties, Parameters extends TSchema[], InstanceType extends TSchema, Right extends TSchema>(inferred: Inferred, parameters: [...Parameters], returnType: InstanceType, right: Right): TExtendsConstructor<Inferred, Parameters, InstanceType, Right>;

package/build/type/extends/constructor.mjs

@@ -7,7 +7,7 @@ import * as Result from './result.mjs';
 // Parameters | ReturnType
 // ------------------------------------------------------------------ 
 import { ExtendsParameters } from './parameters.mjs';
-import { ExtendsReturnType } from './return-type.mjs';
+import { ExtendsReturnType } from './return_type.mjs';
 export function ExtendsConstructor(inferred, parameters, returnType, right) {
     return (IsAny(right) ? Result.ExtendsTrue(inferred) :
         IsUnknown(right) ? Result.ExtendsTrue(inferred) :

package/build/type/extends/enum.d.mts

@@ -1,7 +1,7 @@
 import { type TSchema } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
 import { type TEnum } from '../types/enum.mjs';
-import { type TExtendsLeft } from './extends-left.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
 import { type TEnumToUnion } from '../engine/enum/index.mjs';
 export type TExtendsEnum<Inferred extends TProperties, Left extends TEnum, Right extends TSchema> = (TExtendsLeft<Inferred, TEnumToUnion<Left>, Right>);
 export declare function ExtendsEnum<Inferred extends TProperties, Left extends TEnum, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsEnum<Inferred, Left, Right>;

package/build/type/extends/enum.mjs

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { ExtendsLeft } from './extends-left.mjs';
+import { ExtendsLeft } from './extends_left.mjs';
 import { EnumToUnion } from '../engine/enum/index.mjs';
 export function ExtendsEnum(inferred, left, right) {
     return ExtendsLeft(inferred, EnumToUnion(left), right);

package/build/type/extends/extends.d.mts

@@ -3,7 +3,7 @@ import { type TProperties } from '../types/properties.mjs';
 import { type TCyclic } from '../types/cyclic.mjs';
 import { type TUnknown } from '../types/unknown.mjs';
 import { type TUnsafe } from '../types/unsafe.mjs';
-import { type TExtendsLeft } from './extends-left.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
 import { type TCyclicExtends } from '../engine/cyclic/index.mjs';
 type TCanonical<Type extends TSchema> = (Type extends TCyclic ? TCyclicExtends<Type> : Type extends TUnsafe ? TUnknown : Type);
 /** Performs a structural extends check on left and right types and yields inferred types on right if specified. */

package/build/type/extends/extends.mjs

@@ -2,7 +2,7 @@
 import { IsCyclic } from '../types/cyclic.mjs';
 import { Unknown } from '../types/unknown.mjs';
 import { IsUnsafe } from '../types/unsafe.mjs';
-import { ExtendsLeft } from './extends-left.mjs';
+import { ExtendsLeft } from './extends_left.mjs';
 import { CyclicExtends } from '../engine/cyclic/index.mjs';
 function Canonical(type) {
     return (IsCyclic(type) ? CyclicExtends(type) :

package/build/type/extends/{extends-left.d.mts → extends_left.d.mts}

@@ -1,6 +1,6 @@
 import { type TExtendsAny } from './any.mjs';
 import { type TExtendsArray } from './array.mjs';
-import { type TExtendsAsyncIterator } from './async-iterator.mjs';
+import { type TExtendsAsyncIterator } from './async_iterator.mjs';
 import { type TExtendsBigInt } from './bigint.mjs';
 import { type TExtendsBoolean } from './boolean.mjs';
 import { type TExtendsConstructor } from './constructor.mjs';
@@ -17,7 +17,7 @@ import { type TExtendsObject } from './object.mjs';
 import { type TExtendsPromise } from './promise.mjs';
 import { type TExtendsString } from './string.mjs';
 import { type TExtendsSymbol } from './symbol.mjs';
-import { type TExtendsTemplateLiteral } from './template-literal.mjs';
+import { type TExtendsTemplateLiteral } from './template_literal.mjs';
 import { type TExtendsTuple } from './tuple.mjs';
 import { type TExtendsUndefined } from './undefined.mjs';
 import { type TExtendsUnion } from './union.mjs';
@@ -25,7 +25,7 @@ import { type TExtendsUnknown } from './unknown.mjs';
 import { type TExtendsVoid } from './void.mjs';
 import { type TAny } from '../types/any.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 TBigInt } from '../types/bigint.mjs';
 import { type TBoolean } from '../types/boolean.mjs';
 import { type TConstructor } from '../types/constructor.mjs';
@@ -43,7 +43,7 @@ import { type TPromise } from '../types/promise.mjs';
 import { type TSchema } from '../types/schema.mjs';
 import { type TString } from '../types/string.mjs';
 import { type TSymbol } from '../types/symbol.mjs';
-import { type TTemplateLiteral } from '../types/template-literal.mjs';
+import { type TTemplateLiteral } from '../types/template_literal.mjs';
 import { type TTuple } from '../types/tuple.mjs';
 import { type TUndefined } from '../types/undefined.mjs';
 import { type TUnknown } from '../types/unknown.mjs';

package/build/type/extends/{extends-left.mjs → extends_left.mjs}

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { ExtendsAny } from './any.mjs';
 import { ExtendsArray } from './array.mjs';
-import { ExtendsAsyncIterator } from './async-iterator.mjs';
+import { ExtendsAsyncIterator } from './async_iterator.mjs';
 import { ExtendsBigInt } from './bigint.mjs';
 import { ExtendsBoolean } from './boolean.mjs';
 import { ExtendsConstructor } from './constructor.mjs';
@@ -18,7 +18,7 @@ import { ExtendsObject } from './object.mjs';
 import { ExtendsPromise } from './promise.mjs';
 import { ExtendsString } from './string.mjs';
 import { ExtendsSymbol } from './symbol.mjs';
-import { ExtendsTemplateLiteral } from './template-literal.mjs';
+import { ExtendsTemplateLiteral } from './template_literal.mjs';
 import { ExtendsTuple } from './tuple.mjs';
 import { ExtendsUndefined } from './undefined.mjs';
 import { ExtendsUnion } from './union.mjs';
@@ -29,7 +29,7 @@ import { ExtendsVoid } from './void.mjs';
 // ----------------------------------------------------------------------------
 import { IsAny } from '../types/any.mjs';
 import { IsArray } from '../types/array.mjs';
-import { IsAsyncIterator } from '../types/async-iterator.mjs';
+import { IsAsyncIterator } from '../types/async_iterator.mjs';
 import { IsBigInt } from '../types/bigint.mjs';
 import { IsBoolean } from '../types/boolean.mjs';
 import { IsConstructor } from '../types/constructor.mjs';
@@ -46,7 +46,7 @@ import { IsObject } from '../types/object.mjs';
 import { IsPromise } from '../types/promise.mjs';
 import { IsString } from '../types/string.mjs';
 import { IsSymbol } from '../types/symbol.mjs';
-import { IsTemplateLiteral } from '../types/template-literal.mjs';
+import { IsTemplateLiteral } from '../types/template_literal.mjs';
 import { IsTuple } from '../types/tuple.mjs';
 import { IsUndefined } from '../types/undefined.mjs';
 import { IsUnknown } from '../types/unknown.mjs';

package/build/type/extends/{extends-right.d.mts → extends_right.d.mts}

@@ -5,12 +5,12 @@ import { type TAny } from '../types/any.mjs';
 import { type TEnum, type TEnumValue } from '../types/enum.mjs';
 import { type TInfer } from '../types/infer.mjs';
 import { type TIntersect } from '../types/intersect.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 TUnknown } from '../types/unknown.mjs';
-import { type TExtendsLeft } from './extends-left.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
 import * as Result from './result.mjs';
-import { type TTemplateLiteralDecode } from '../engine/template-literal/decode.mjs';
+import { type TTemplateLiteralDecode } from '../engine/template_literal/decode.mjs';
 import { type TEnumValuesToUnion } from '../engine/enum/index.mjs';
 type TExtendsRightInfer<Inferred extends TProperties, Name extends string, Left extends TSchema, Right extends TSchema, Result extends Result.TResult = (TExtendsLeft<Inferred, Left, Right> extends Result.TExtendsTrueLike<infer CheckInferred extends TProperties> ? Result.TExtendsTrue<Memory.TAssign<Memory.TAssign<Inferred, CheckInferred>, {
     [_ in Name]: Left;

package/build/type/extends/{extends-right.mjs → extends_right.mjs}

@@ -5,12 +5,12 @@ import { IsAny } from '../types/any.mjs';
 import { IsEnum } from '../types/enum.mjs';
 import { IsInfer } from '../types/infer.mjs';
 import { IsIntersect } from '../types/intersect.mjs';
-import { IsTemplateLiteral } from '../types/template-literal.mjs';
+import { IsTemplateLiteral } from '../types/template_literal.mjs';
 import { IsUnion } from '../types/union.mjs';
 import { IsUnknown } from '../types/unknown.mjs';
-import { ExtendsLeft } from './extends-left.mjs';
+import { ExtendsLeft } from './extends_left.mjs';
 import * as Result from './result.mjs';
-import { TemplateLiteralDecode } from '../engine/template-literal/decode.mjs';
+import { TemplateLiteralDecode } from '../engine/template_literal/decode.mjs';
 import { EnumValuesToUnion } from '../engine/enum/index.mjs';
 function ExtendsRightInfer(inferred, name, left, right) {
     return Result.Match(ExtendsLeft(inferred, left, right), checkInferred => Result.ExtendsTrue(Memory.Assign(Memory.Assign(inferred, checkInferred), { [name]: left })), () => Result.ExtendsFalse());

package/build/type/extends/function.d.mts

@@ -5,6 +5,6 @@ import { type TFunction } from '../types/function.mjs';
 import { type TUnknown } from '../types/unknown.mjs';
 import * as Result from './result.mjs';
 import { type TExtendsParameters } from './parameters.mjs';
-import { type TExtendsReturnType } from './return-type.mjs';
+import { type TExtendsReturnType } from './return_type.mjs';
 export type TExtendsFunction<Inferred extends TProperties, Parameters extends TSchema[], ReturnType extends TSchema, Right extends TSchema> = (Right extends TAny ? Result.TExtendsTrue<Inferred> : Right extends TUnknown ? Result.TExtendsTrue<Inferred> : Right extends TFunction ? TExtendsParameters<Inferred, Parameters, Right['parameters']> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsReturnType<Inferred, ReturnType, Right['returnType']> : Result.TExtendsFalse : Result.TExtendsFalse);
 export declare function ExtendsFunction<Inferred extends TProperties, Parameters extends TSchema[], ReturnType extends TSchema, Right extends TSchema>(inferred: Inferred, parameters: [...Parameters], returnType: ReturnType, right: Right): TExtendsFunction<Inferred, Parameters, ReturnType, Right>;

package/build/type/extends/function.mjs

@@ -7,7 +7,7 @@ import * as Result from './result.mjs';
 // Parameters | ReturnType
 // ------------------------------------------------------------------ 
 import { ExtendsParameters } from './parameters.mjs';
-import { ExtendsReturnType } from './return-type.mjs';
+import { ExtendsReturnType } from './return_type.mjs';
 export function ExtendsFunction(inferred, parameters, returnType, right) {
     return (IsAny(right) ? Result.ExtendsTrue(inferred) :
         IsUnknown(right) ? Result.ExtendsTrue(inferred) :

package/build/type/extends/inference.d.mts

@@ -5,7 +5,7 @@ import { type TArray } from '../types/array.mjs';
 import { type TUnknown } from '../types/unknown.mjs';
 import { type TProperties } from '../types/properties.mjs';
 import { type TTuple } from '../types/tuple.mjs';
-import { type TExtendsLeft } from './extends-left.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
 import { type TUnion } from '../types/union.mjs';
 import { type TInfer } from '../types/infer.mjs';
 import { type TRest } from '../types/rest.mjs';

package/build/type/extends/inference.mjs

@@ -6,7 +6,7 @@ import { Guard } from '../../guard/index.mjs';
 import { IsArray } from '../types/array.mjs';
 import { IsUnknown } from '../types/unknown.mjs';
 import { Tuple } from '../types/tuple.mjs';
-import { ExtendsLeft } from './extends-left.mjs';
+import { ExtendsLeft } from './extends_left.mjs';
 import { Union } from '../types/union.mjs';
 // ----------------------------------------------------------------------------
 // Operator

package/build/type/extends/integer.d.mts

@@ -2,7 +2,7 @@ import { type TSchema } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
 import { type TInteger } from '../types/integer.mjs';
 import { type TNumber } from '../types/number.mjs';
-import { type TExtendsRight } from './extends-right.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
 import * as Result from './result.mjs';
 export type TExtendsInteger<Inferred extends TProperties, Left extends TInteger, Right extends TSchema> = (Right extends TInteger ? Result.TExtendsTrue<Inferred> : Right extends TNumber ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, Left, Right>);
 export declare function ExtendsInteger<Inferred extends TProperties, Left extends TInteger, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsInteger<Inferred, Left, Right>;

package/build/type/extends/integer.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { IsInteger } from '../types/integer.mjs';
 import { IsNumber } from '../types/number.mjs';
-import { ExtendsRight } from './extends-right.mjs';
+import { ExtendsRight } from './extends_right.mjs';
 import * as Result from './result.mjs';
 export function ExtendsInteger(inferred, left, right) {
     return (IsInteger(right) ? Result.ExtendsTrue(inferred) :

package/build/type/extends/intersect.d.mts

@@ -1,6 +1,6 @@
 import { type TProperties } from '../types/properties.mjs';
 import { type TSchema } from '../types/schema.mjs';
-import { type TExtendsLeft } from './extends-left.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
 import { type TEvaluateIntersect } from '../engine/evaluate/index.mjs';
 export type TExtendsIntersect<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema, Evaluated extends TSchema = TEvaluateIntersect<Left>> = TExtendsLeft<Inferred, Evaluated, Right>;
 export declare function ExtendsIntersect<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsIntersect<Inferred, Left, Right>;

package/build/type/extends/intersect.mjs

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { ExtendsLeft } from './extends-left.mjs';
+import { ExtendsLeft } from './extends_left.mjs';
 // ----------------------------------------------------------------------------
 // ExtendsIntersect
 //

package/build/type/extends/iterator.d.mts

@@ -1,7 +1,7 @@
 import { type TSchema } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
 import { type TIterator } from '../types/iterator.mjs';
-import { type TExtendsRight } from './extends-right.mjs';
-import { type TExtendsLeft } from './extends-left.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
 export type TExtendsIterator<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Right extends TIterator<infer Type extends TSchema> ? TExtendsLeft<Inferred, Left, Type> : TExtendsRight<Inferred, TIterator<Left>, Right>);
 export declare function ExtendsIterator<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsIterator<Inferred, Left, Right>;

package/build/type/extends/iterator.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { Iterator, IsIterator } from '../types/iterator.mjs';
-import { ExtendsRight } from './extends-right.mjs';
-import { ExtendsLeft } from './extends-left.mjs';
+import { ExtendsRight } from './extends_right.mjs';
+import { ExtendsLeft } from './extends_left.mjs';
 export function ExtendsIterator(inferred, left, right) {
     return (IsIterator(right)
         ? ExtendsLeft(inferred, left, right.iteratorItems)

package/build/type/extends/literal.d.mts

@@ -1,4 +1,4 @@
-import { TUnreachable } from '../../system/unreachable/unreachable.mjs';
+import { type TUnreachable } from '../../system/unreachable/unreachable.mjs';
 import { type TSchema } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
 import { type TLiteral, type TLiteralValue } from '../types/literal.mjs';
@@ -6,7 +6,7 @@ import { type TBigInt } from '../types/bigint.mjs';
 import { type TBoolean } from '../types/boolean.mjs';
 import { type TNumber } from '../types/number.mjs';
 import { type TString } from '../types/string.mjs';
-import { type TExtendsRight } from './extends-right.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
 import * as Result from './result.mjs';
 type TExtendsLiteralValue<Inferred extends TProperties, Left extends TLiteralValue, Right extends TLiteralValue> = (Left extends Right ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse);
 type TExtendsLiteralBigInt<Inferred extends TProperties, Left extends bigint, Right extends TSchema> = (Right extends TLiteral<infer Value extends bigint> ? TExtendsLiteralValue<Inferred, Left, Value> : Right extends TBigInt ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, TLiteral<Left>, Right>);

package/build/type/extends/literal.mjs

@@ -1,12 +1,12 @@
 // deno-fmt-ignore-file
-import { Unreachable } from '../../system/unreachable/unreachable.mjs';
 import { Guard } from '../../guard/index.mjs';
+import { Unreachable } from '../../system/unreachable/unreachable.mjs';
 import { IsLiteral, Literal } from '../types/literal.mjs';
 import { IsBigInt } from '../types/bigint.mjs';
 import { IsBoolean } from '../types/boolean.mjs';
 import { IsNumber } from '../types/number.mjs';
 import { IsString } from '../types/string.mjs';
-import { ExtendsRight } from './extends-right.mjs';
+import { ExtendsRight } from './extends_right.mjs';
 import * as Result from './result.mjs';
 function ExtendsLiteralValue(inferred, left, right) {
     return (left === right

package/build/type/extends/never.d.mts

@@ -2,7 +2,7 @@ import { type TSchema } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
 import { type TNever } from '../types/never.mjs';
 import { type TInfer } from '../types/infer.mjs';
-import { type TExtendsRight } from './extends-right.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
 import * as Result from './result.mjs';
 export type TExtendsNever<Inferred extends TProperties, Left extends TNever, Right extends TSchema> = (Right extends TInfer ? TExtendsRight<Inferred, Left, Right> : Result.TExtendsTrue<Inferred>);
 export declare function ExtendsNever<Inferred extends TProperties, Left extends TNever, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsNever<Inferred, Left, Right>;

package/build/type/extends/never.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { IsInfer } from '../types/infer.mjs';
-import { ExtendsRight } from './extends-right.mjs';
+import { ExtendsRight } from './extends_right.mjs';
 import * as Result from './result.mjs';
 export function ExtendsNever(inferred, left, right) {
     return (IsInfer(right)

package/build/type/extends/null.d.mts

@@ -1,7 +1,7 @@
 import { type TSchema } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
 import { type TNull } from '../types/null.mjs';
-import { type TExtendsRight } from './extends-right.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
 import * as Result from './result.mjs';
 export type TExtendsNull<Inferred extends TProperties, Left extends TNull, Right extends TSchema> = (Right extends TNull ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, Left, Right>);
 export declare function ExtendsNull<Inferred extends TProperties, Left extends TNull, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsNull<Inferred, Left, Right>;

package/build/type/extends/null.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { IsNull } from '../types/null.mjs';
-import { ExtendsRight } from './extends-right.mjs';
+import { ExtendsRight } from './extends_right.mjs';
 import * as Result from './result.mjs';
 export function ExtendsNull(inferred, left, right) {
     return (IsNull(right)

package/build/type/extends/number.d.mts

@@ -1,7 +1,7 @@
 import { type TSchema } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
 import { type TNumber } from '../types/number.mjs';
-import { type TExtendsRight } from './extends-right.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
 import * as Result from './result.mjs';
 export type TExtendsNumber<Inferred extends TProperties, Left extends TNumber, Right extends TSchema> = (Right extends TNumber ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, Left, Right>);
 export declare function ExtendsNumber<Inferred extends TProperties, Left extends TNumber, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsNumber<Inferred, Left, Right>;