typebox 1.1.31 → 1.1.32

package/build/guard/guard.d.mts

@@ -43,8 +43,12 @@ export declare function GraphemeCount(value: string): number;
 export declare function IsMaxLength(value: string, length: number): boolean;
 /** Returns true if the string has at least the given number of graphemes */
 export declare function IsMinLength(value: string, length: number): boolean;
+/** Returns true if all elements from offset satisfy the callback, short-circuiting on the first failure */
 export declare function Every<T>(value: T[], offset: number, callback: (value: T, index: number) => boolean): boolean;
+/** Returns true if all elements from offset satisfy the callback, visiting every element regardless of failure */
 export declare function EveryAll<T>(value: T[], offset: number, callback: (value: T, index: number) => boolean): boolean;
+/** Takes the left-most element from an array and dispatches to the true arm, or the false arm if empty */
+export declare function TakeLeft<T, True extends (left: T, right: T[]) => unknown, False extends () => unknown>(array: T[], true_: True, false_: False): ReturnType<True> | ReturnType<False>;
 /** Returns true if this value has this property key */
 export declare function HasPropertyKey<Key extends PropertyKey>(value: object, key: Key): value is {
     [_ in Key]: unknown;

package/build/guard/guard.mjs

@@ -145,6 +145,7 @@ export function IsMinLength(value, length) {
 // --------------------------------------------------------------------------
 // Array
 // --------------------------------------------------------------------------
+/** Returns true if all elements from offset satisfy the callback, short-circuiting on the first failure */
 export function Every(value, offset, callback) {
     for (let index = offset; index < value.length; index++) {
         if (!callback(value[index], index))
@@ -152,6 +153,7 @@ export function Every(value, offset, callback) {
     }
     return true;
 }
+/** Returns true if all elements from offset satisfy the callback, visiting every element regardless of failure */
 export function EveryAll(value, offset, callback) {
     let result = true;
     for (let index = offset; index < value.length; index++) {
@@ -160,6 +162,10 @@ export function EveryAll(value, offset, callback) {
     }
     return result;
 }
+/** Takes the left-most element from an array and dispatches to the true arm, or the false arm if empty */
+export function TakeLeft(array, true_, false_) {
+    return (IsEqual(array.length, 0) ? false_() : true_(array[0], array.slice(1)));
+}
 // --------------------------------------------------------------------------
 // Object
 // --------------------------------------------------------------------------

package/build/type/engine/call/resolve-arguments.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
 import { Memory } from '../../../system/memory/index.mjs';
-import { IsSchema } from '../../types/schema.mjs';
 import { InstantiateType } from '../instantiate.mjs';
 import { Extends, ExtendsResult } from '../../extends/index.mjs';
 import { IsInfer } from '../../types/infer.mjs';
@@ -23,16 +23,10 @@ function BindArgument(context, state, name, extends_, type) {
 function BindArguments(context, state, parameterLeft, parameterRight, arguments_) {
     const instantiatedExtends = InstantiateType(context, state, parameterLeft.extends);
     const instantiatedEquals = InstantiateType(context, state, parameterLeft.equals);
-    const [left, ...right] = arguments_;
-    return (IsSchema(left)
-        ? BindParameters(BindArgument(context, state, parameterLeft['name'], instantiatedExtends, left), state, parameterRight, right)
-        : BindParameters(BindArgument(context, state, parameterLeft['name'], instantiatedExtends, instantiatedEquals), state, parameterRight, []));
+    return Guard.TakeLeft(arguments_, (left, right) => BindParameters(BindArgument(context, state, parameterLeft['name'], instantiatedExtends, left), state, parameterRight, right), () => BindParameters(BindArgument(context, state, parameterLeft['name'], instantiatedExtends, instantiatedEquals), state, parameterRight, []));
 }
 function BindParameters(context, state, parameters, arguments_) {
-    const [left, ...right] = parameters;
-    return (IsSchema(left)
-        ? BindArguments(context, state, left, right, arguments_)
-        : context);
+    return Guard.TakeLeft(parameters, (left, right) => BindArguments(context, state, left, right, arguments_), () => context);
 }
 export function ResolveArgumentsContext(context, state, parameters, arguments_) {
     return BindParameters(context, state, parameters, arguments_);

package/build/type/engine/cyclic/check.mjs

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { IsSchema } from '../../types/schema.mjs';
+import { Guard } from '../../../guard/index.mjs';
 import { IsArray } from '../../types/array.mjs';
 import { IsAsyncIterator } from '../../types/async-iterator.mjs';
 import { IsConstructor } from '../../types/constructor.mjs';
@@ -24,12 +24,9 @@ function FromProperties(stack, context, properties) {
     return FromTypes(stack, context, types);
 }
 function FromTypes(stack, context, types) {
-    const [left, ...right] = types;
-    return (IsSchema(left)
-        ? FromType(stack, context, left)
-            ? true
-            : FromTypes(stack, context, right)
-        : false);
+    return Guard.TakeLeft(types, (left, right) => FromType(stack, context, left)
+        ? true
+        : FromTypes(stack, context, right), () => false);
 }
 function FromType(stack, context, type) {
     return (IsRef(type) ? FromRef(stack, context, type.$ref) :

package/build/type/engine/evaluate/distribute.mjs

@@ -1,7 +1,6 @@
 // deno-fmt-ignore-file
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
-import { IsSchema } from '../../types/schema.mjs';
 import { IsUnion } from '../../types/union.mjs';
 import { IsObject } from '../../types/object.mjs';
 import { IsTuple } from '../../types/tuple.mjs';
@@ -32,24 +31,15 @@ function DistributeOperation(left, right) {
     return result;
 }
 function DistributeType(type, types, result = []) {
-    const [left, ...right] = types;
-    return (!Guard.IsUndefined(left) // TSchema[]
-        ? DistributeType(type, right, [...result, DistributeOperation(type, left)])
-        : result.length === 0
-            ? [type]
-            : result);
+    return Guard.TakeLeft(types, (left, right) => DistributeType(type, right, [...result, DistributeOperation(type, left)]), () => Guard.IsEqual(result.length, 0)
+        ? [type]
+        : result);
 }
 function DistributeUnion(types, distribution, result = []) {
-    const [left, ...right] = types;
-    return (IsSchema(left)
-        ? DistributeUnion(right, distribution, [...result, ...Distribute([left], distribution)])
-        : result);
+    return Guard.TakeLeft(types, (left, right) => DistributeUnion(right, distribution, [...result, ...Distribute([left], distribution)]), () => result);
 }
 export function Distribute(types, result = []) {
-    const [left, ...right] = types;
-    return (IsSchema(left)
-        ? IsUnion(left)
-            ? Distribute(right, DistributeUnion(left.anyOf, result))
-            : Distribute(right, DistributeType(left, result))
-        : result);
+    return Guard.TakeLeft(types, (left, right) => IsUnion(left)
+        ? Distribute(right, DistributeUnion(left.anyOf, result))
+        : Distribute(right, DistributeType(left, result)), () => result);
 }

package/build/type/engine/instantiate.mjs

@@ -11,7 +11,6 @@ import { IsReadonly, ReadonlyAdd, ReadonlyRemove } from '../types/_readonly.mjs'
 // Types
 // ------------------------------------------------------------------
 import { IsBase } from '../types/base.mjs';
-import { IsSchema } from '../types/schema.mjs';
 import { Array, IsArray, ArrayOptions } from '../types/array.mjs';
 import { AsyncIterator, IsAsyncIterator, AsyncIteratorOptions } from '../types/async-iterator.mjs';
 import { Constructor, IsConstructor, ConstructorOptions } from '../types/constructor.mjs';
@@ -66,12 +65,9 @@ import { UncapitalizeInstantiate } from './intrinsics/instantiate.mjs';
 import { UppercaseInstantiate } from './intrinsics/instantiate.mjs';
 import { RestSpread } from './rest/index.mjs';
 export function CanInstantiate(types) {
-    const [left, ...right] = types;
-    return (IsSchema(left)
-        ? IsRef(left)
-            ? false
-            : CanInstantiate(right)
-        : true);
+    return Guard.TakeLeft(types, (left, right) => IsRef(left)
+        ? false
+        : CanInstantiate(right), () => true);
 }
 function ModifierActions(type, readonly, optional) {
     return (IsReadonlyRemoveAction(type) ? ModifierActions(type.type, 'remove', optional) :

package/build/type/engine/object/from-union.mjs

@@ -1,7 +1,6 @@
 // deno-fmt-ignore-file
-import { Unreachable } from '../../../system/unreachable/index.mjs';
 import { Guard } from '../../../guard/index.mjs';
-import { IsSchema } from '../../types/schema.mjs';
+import { Unreachable } from '../../../system/unreachable/index.mjs';
 import { EvaluateUnion } from '../evaluate/evaluate.mjs';
 import { FromType } from './from-type.mjs';
 function CollapseUnionProperties(left, right) {
@@ -12,15 +11,9 @@ function CollapseUnionProperties(left, right) {
     return result;
 }
 function ReduceVariants(types, result) {
-    const [left, ...right] = types;
-    return (IsSchema(left)
-        ? ReduceVariants(right, CollapseUnionProperties(result, FromType(left)))
-        : result);
+    return Guard.TakeLeft(types, (left, right) => ReduceVariants(right, CollapseUnionProperties(result, FromType(left))), () => result);
 }
 export function FromUnion(types) {
-    const [left, ...right] = types;
-    return (IsSchema(left)
-        ? ReduceVariants(right, FromType(left))
-        : Unreachable());
+    return Guard.TakeLeft(types, (left, right) => ReduceVariants(right, FromType(left)), () => Unreachable());
 }
 // deno-coverage-ignore-stop

package/build/type/engine/template-literal/decode.d.mts

@@ -1,6 +1,6 @@
 import { TUnreachable } from '../../../system/unreachable/index.mjs';
-import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
 import { type TSchema } from '../../types/schema.mjs';
+import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
 import { type TString } from '../../types/string.mjs';
 import { type TTemplateLiteral } from '../../types/template-literal.mjs';
 import { type TUnion } from '../../types/union.mjs';

package/build/type/engine/template-literal/decode.mjs

@@ -1,8 +1,7 @@
 // deno-fmt-ignore-file
-import { Unreachable } from '../../../system/unreachable/index.mjs';
 import { Guard } from '../../../guard/index.mjs';
+import { Unreachable } from '../../../system/unreachable/index.mjs';
 import { Literal, IsLiteral } from '../../types/literal.mjs';
-import { IsSchema } from '../../types/schema.mjs';
 import { String } from '../../types/string.mjs';
 import { IsTemplateLiteral } from '../../types/template-literal.mjs';
 import { Union, IsUnion } from '../../types/union.mjs';
@@ -10,17 +9,13 @@ import { ParsePatternIntoTypes } from '../patterns/pattern.mjs';
 import { IsTemplateLiteralFinite } from './is-finite.mjs';
 import { TemplateLiteralCreate } from './create.mjs';
 function FromLiteralPush(variants, value, result = []) {
-    const [left, ...right] = variants;
-    return (Guard.IsString(left) ? FromLiteralPush(right, value, [...result, `${left}${value}`]) : result);
+    return Guard.TakeLeft(variants, (left, right) => FromLiteralPush(right, value, [...result, `${left}${value}`]), () => result);
 }
 function FromLiteral(variants, value) {
     return (Guard.IsEqual(variants.length, 0) ? [`${value}`] : FromLiteralPush(variants, value));
 }
 function FromUnion(variants, types, result = []) {
-    const [left, ...right] = types;
-    return (IsSchema(left)
-        ? FromUnion(variants, right, [...result, ...FromType(variants, left)])
-        : result);
+    return Guard.TakeLeft(types, (left, right) => FromUnion(variants, right, [...result, ...FromType(variants, left)]), () => result);
 }
 // ------------------------------------------------------------------
 // deno-coverage-ignore-start - symmetric unreachable | internal
@@ -38,8 +33,7 @@ function FromType(variants, type) {
     return result;
 }
 function DecodeFromSpan(variants, types) {
-    const [left, ...right] = types;
-    return (IsSchema(left) ? DecodeFromSpan(FromType(variants, left), right) : variants);
+    return Guard.TakeLeft(types, (left, right) => DecodeFromSpan(FromType(variants, left), right), () => variants);
 }
 function VariantsToLiterals(variants) {
     return variants.map(variant => Literal(variant));

package/build/type/engine/template-literal/encode.mjs

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { IsSchema } from '../../types/schema.mjs';
+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';
@@ -50,10 +50,7 @@ function EncodeEnum(types, right, pattern) {
     return EncodeUnion(variants, right, pattern);
 }
 function EncodeUnion(types, right, pattern, result = []) {
-    const [head, ...tail] = types;
-    return (IsSchema(head)
-        ? EncodeUnion(tail, right, pattern, [...result, EncodeType(head, [], '')])
-        : EncodeTypes(right, `${pattern}(${JoinString(result)})`));
+    return Guard.TakeLeft(types, (head, tail) => EncodeUnion(tail, right, pattern, [...result, EncodeType(head, [], '')]), () => EncodeTypes(right, `${pattern}(${JoinString(result)})`));
 }
 function EncodeType(type, right, pattern) {
     return (IsEnum(type) ? EncodeEnum(type.enum, right, pattern) :
@@ -69,10 +66,7 @@ function EncodeType(type, right, pattern) {
                                             NeverPattern);
 }
 function EncodeTypes(types, pattern) {
-    const [left, ...right] = types;
-    return (IsSchema(left)
-        ? EncodeType(left, right, pattern)
-        : pattern);
+    return Guard.TakeLeft(types, (left, right) => EncodeType(left, right, pattern), () => pattern);
 }
 function EncodePattern(types) {
     const encoded = EncodeTypes(types, '');

package/build/type/engine/template-literal/is-finite.mjs

@@ -1,18 +1,14 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
-import { IsSchema } from '../../types/schema.mjs';
 import { IsLiteral } from '../../types/literal.mjs';
 import { IsUnion } from '../../types/union.mjs';
 function FromLiteral(_value) {
     return true;
 }
 function FromTypesReduce(types) {
-    const [left, ...right] = types;
-    return (IsSchema(left)
-        ? FromType(left)
-            ? FromTypesReduce(right)
-            : false
-        : true);
+    return Guard.TakeLeft(types, (left, right) => FromType(left)
+        ? FromTypesReduce(right)
+        : false, () => true);
 }
 function FromTypes(types) {
     const result = Guard.IsEqual(types.length, 0) ? false : FromTypesReduce(types);

package/build/type/extends/extends-right.mjs

@@ -1,4 +1,5 @@
 // deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
 import { Memory } from '../../system/memory/index.mjs';
 import { IsAny } from '../types/any.mjs';
 import { IsEnum } from '../types/enum.mjs';
@@ -22,14 +23,14 @@ function ExtendsRightEnum(inferred, left, right) {
     return ExtendsLeft(inferred, left, union);
 }
 function ExtendsRightIntersect(inferred, left, right) {
-    return Result.TakeLeft(right, (head, tail) => Result.Match(ExtendsLeft(inferred, left, head), inferred => ExtendsRightIntersect(inferred, left, tail), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred));
+    return Guard.TakeLeft(right, (head, tail) => Result.Match(ExtendsLeft(inferred, left, head), inferred => ExtendsRightIntersect(inferred, left, tail), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred));
 }
 function ExtendsRightTemplateLiteral(inferred, left, right) {
     const decoded = TemplateLiteralDecode(right);
     return ExtendsLeft(inferred, left, decoded);
 }
 function ExtendsRightUnion(inferred, left, right) {
-    return Result.TakeLeft(right, (head, tail) => Result.Match(ExtendsLeft(inferred, left, head), inferred => Result.ExtendsTrue(inferred), () => ExtendsRightUnion(inferred, left, tail)), () => Result.ExtendsFalse());
+    return Guard.TakeLeft(right, (head, tail) => Result.Match(ExtendsLeft(inferred, left, head), inferred => Result.ExtendsTrue(inferred), () => ExtendsRightUnion(inferred, left, tail)), () => Result.ExtendsFalse());
 }
 export function ExtendsRight(inferred, left, right) {
     return (IsAny(right) ? ExtendsRightAny(inferred, left) :

package/build/type/extends/inference.mjs

@@ -46,7 +46,7 @@ export function TryInferable(type) {
         undefined);
 }
 function TryInferResults(rest, right, result = []) {
-    return Result.TakeLeft(rest, (head, tail) => Result.Match(ExtendsLeft({}, head, right), () => TryInferResults(tail, right, [...result, head]), () => undefined), () => result);
+    return Guard.TakeLeft(rest, (head, tail) => Result.Match(ExtendsLeft({}, head, right), () => TryInferResults(tail, right, [...result, head]), () => undefined), () => result);
 }
 export function InferTupleResult(inferred, name, left, right) {
     const results = TryInferResults(left, right);

package/build/type/extends/parameters.mjs

@@ -1,4 +1,5 @@
 // deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
 import { IsInfer } from '../types/infer.mjs';
 import { IsOptional } from '../types/_optional.mjs';
 import { ExtendsLeft } from './extends-left.mjs';
@@ -15,12 +16,12 @@ function ParameterCompare(inferred, left, leftRest, right, rightRest) {
     );
 }
 function ParameterRight(inferred, left, leftRest, rightRest) {
-    return Result.TakeLeft(rightRest, (head, tail) => ParameterCompare(inferred, left, leftRest, head, tail), () => IsOptional(left) // 'right-did-not-have-enough-elements'
+    return Guard.TakeLeft(rightRest, (head, tail) => ParameterCompare(inferred, left, leftRest, head, tail), () => IsOptional(left) // 'right-did-not-have-enough-elements'
         ? Result.ExtendsTrue(inferred) // 'ok: left was optional'
         : Result.ExtendsFalse()); // 'fail: left was required'
 }
 function ParametersLeft(inferred, left, rightRest) {
-    return Result.TakeLeft(left, (head, tail) => ParameterRight(inferred, head, tail, rightRest), () => Result.ExtendsTrue(inferred)); // 'ok: no-more-elements-in-left'
+    return Guard.TakeLeft(left, (head, tail) => ParameterRight(inferred, head, tail, rightRest), () => Result.ExtendsTrue(inferred)); // 'ok: no-more-elements-in-left'
 }
 export function ExtendsParameters(inferred, left, right) {
     return ParametersLeft(inferred, left, right);

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

@@ -22,6 +22,3 @@ export declare function IsExtendsTrueLike(value: unknown): value is TExtendsTrue
 export type MatchTrueLike = (inferred: TProperties) => unknown;
 export type MatchFalse = () => unknown;
 export declare function Match(result: TResult, true_: MatchTrueLike, false_: MatchFalse): unknown;
-export type TakeLeftTrue<T> = (left: T, right: T[]) => unknown;
-export type TakeLeftFalse = () => unknown;
-export declare function TakeLeft<T>(array: T[], true_: TakeLeftTrue<T>, false_: TakeLeftFalse): unknown;

package/build/type/extends/result.mjs

@@ -34,6 +34,3 @@ export function IsExtendsTrueLike(value) {
 export function Match(result, true_, false_) {
     return IsExtendsTrueLike(result) ? true_(result.inferred) : false_();
 }
-export function TakeLeft(array, true_, false_) {
-    return Guard.IsEqual(array.length, 0) ? false_() : true_(array[0], array.slice(1));
-}

package/build/type/extends/tuple.mjs

@@ -31,10 +31,10 @@ function ElementsLeft(inferred, reversed, leftRest, right, rightRest) {
     // Rest Inferrable Right Means we delegate to TInferTupleResult to Generate a Result
     IsInferable(inferable)
         ? InferTupleResult(inferred, inferable['name'], ApplyReverse(leftRest, reversed), inferable['type'])
-        : Result.TakeLeft(leftRest, (head, tail) => ElementsCompare(inferred, reversed, head, tail, right, rightRest), () => Result.ExtendsFalse()));
+        : Guard.TakeLeft(leftRest, (head, tail) => ElementsCompare(inferred, reversed, head, tail, right, rightRest), () => Result.ExtendsFalse()));
 }
 function ElementsRight(inferred, reversed, leftRest, rightRest) {
-    return Result.TakeLeft(rightRest, (head, tail) => ElementsLeft(inferred, reversed, leftRest, head, tail), () => Guard.IsEqual(leftRest.length, 0)
+    return Guard.TakeLeft(rightRest, (head, tail) => ElementsLeft(inferred, reversed, leftRest, head, tail), () => Guard.IsEqual(leftRest.length, 0)
         ? Result.ExtendsTrue(inferred) // 'Ok: right-empty-and-left-empty'
         : Result.ExtendsFalse()); // 'Fail: right-empty-and-left-not-empty'
 }
@@ -50,7 +50,7 @@ function ExtendsTupleToArray(inferred, left, right) {
     const inferrable = TryInferable(right);
     return (IsInferable(inferrable)
         ? InferUnionResult(inferred, inferrable['name'], left, inferrable['type'])
-        : Result.TakeLeft(left, (head, tail) => Result.Match(ExtendsLeft(inferred, head, right), inferred => ExtendsTupleToArray(inferred, tail, right), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred)));
+        : Guard.TakeLeft(left, (head, tail) => Result.Match(ExtendsLeft(inferred, head, right), inferred => ExtendsTupleToArray(inferred, tail, right), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred)));
 }
 export function ExtendsTuple(inferred, left, right) {
     const instantiatedLeft = InstantiateElements(inferred, { callstack: [] }, left);

package/build/type/extends/union.mjs

@@ -1,4 +1,5 @@
 // deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
 import { IsUnion } from '../types/union.mjs';
 import { ExtendsLeft } from './extends-left.mjs';
 import * as Result from './result.mjs';
@@ -7,10 +8,10 @@ import * as Result from './result.mjs';
 // ----------------------------------------------------------------------------
 import { IsInferable, TryInferable, InferUnionResult } from './inference.mjs';
 function ExtendsUnionSome(inferred, type, unionTypes) {
-    return Result.TakeLeft(unionTypes, (head, tail) => Result.Match(ExtendsLeft(inferred, type, head), inferred => Result.ExtendsTrue(inferred), () => ExtendsUnionSome(inferred, type, tail)), () => Result.ExtendsFalse());
+    return Guard.TakeLeft(unionTypes, (head, tail) => Result.Match(ExtendsLeft(inferred, type, head), inferred => Result.ExtendsTrue(inferred), () => ExtendsUnionSome(inferred, type, tail)), () => Result.ExtendsFalse());
 }
 function ExtendsUnionLeft(inferred, left, right) {
-    return Result.TakeLeft(left, (head, tail) => Result.Match(ExtendsUnionSome(inferred, head, right), inferred => ExtendsUnionLeft(inferred, tail, right), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred));
+    return Guard.TakeLeft(left, (head, tail) => Result.Match(ExtendsUnionSome(inferred, head, right), inferred => ExtendsUnionLeft(inferred, tail, right), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred));
 }
 export function ExtendsUnion(inferred, left, right) {
     const inferrable = TryInferable(right);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.1.31",
+  "version": "1.1.32",
   "keywords": [
     "typescript",
     "jsonschema"
@@ -16,37 +16,37 @@
   "types": "./build/index.d.mts",
   "module": "./build/index.mjs",
   "exports": {
-    "./value": {
-      "import": "./build/value/index.mjs",
-      "default": "./build/value/index.mjs"
-    },
     "./guard": {
       "import": "./build/guard/index.mjs",
       "default": "./build/guard/index.mjs"
     },
-    "./schema": {
-      "import": "./build/schema/index.mjs",
-      "default": "./build/schema/index.mjs"
+    "./error": {
+      "import": "./build/error/index.mjs",
+      "default": "./build/error/index.mjs"
+    },
+    "./compile": {
+      "import": "./build/compile/index.mjs",
+      "default": "./build/compile/index.mjs"
     },
     "./system": {
       "import": "./build/system/index.mjs",
       "default": "./build/system/index.mjs"
     },
+    "./format": {
+      "import": "./build/format/index.mjs",
+      "default": "./build/format/index.mjs"
+    },
     "./type": {
       "import": "./build/type/index.mjs",
       "default": "./build/type/index.mjs"
     },
-    "./compile": {
-      "import": "./build/compile/index.mjs",
-      "default": "./build/compile/index.mjs"
-    },
-    "./error": {
-      "import": "./build/error/index.mjs",
-      "default": "./build/error/index.mjs"
+    "./schema": {
+      "import": "./build/schema/index.mjs",
+      "default": "./build/schema/index.mjs"
     },
-    "./format": {
-      "import": "./build/format/index.mjs",
-      "default": "./build/format/index.mjs"
+    "./value": {
+      "import": "./build/value/index.mjs",
+      "default": "./build/value/index.mjs"
     },
     ".": {
       "import": "./build/index.mjs",
@@ -55,29 +55,29 @@
   },
   "typesVersions": {
     "*": {
-      "value": [
-        "./build/value/index.d.mts"
-      ],
       "guard": [
         "./build/guard/index.d.mts"
       ],
-      "schema": [
-        "./build/schema/index.d.mts"
+      "error": [
+        "./build/error/index.d.mts"
+      ],
+      "compile": [
+        "./build/compile/index.d.mts"
       ],
       "system": [
         "./build/system/index.d.mts"
       ],
+      "format": [
+        "./build/format/index.d.mts"
+      ],
       "type": [
         "./build/type/index.d.mts"
       ],
-      "compile": [
-        "./build/compile/index.d.mts"
-      ],
-      "error": [
-        "./build/error/index.d.mts"
+      "schema": [
+        "./build/schema/index.d.mts"
       ],
-      "format": [
-        "./build/format/index.d.mts"
+      "value": [
+        "./build/value/index.d.mts"
       ],
       ".": [
         "./build/index.d.mts"