@openclaw/feishu 2026.7.1-beta.2 → 2026.7.1-beta.5

package/node_modules/typebox/build/value/codec/from_union.mjs

@@ -4,12 +4,11 @@ import { Callback } from './callback.mjs';
 import { FromType } from './from_type.mjs';
 import { Clone } from '../clone/index.mjs';
 import { Check } from '../check/index.mjs';
-import { UnionPrioritySort } from '../shared/union_priority_sort.mjs';
 // ------------------------------------------------------------------
 // Decode
 // ------------------------------------------------------------------
 function Decode(direction, context, type, value) {
-    for (const schema of UnionPrioritySort(type.anyOf, 1)) {
+    for (const schema of type.anyOf) {
         if (!Check(context, schema, value))
             continue;
         const variant = FromType(direction, context, schema, value);
@@ -22,7 +21,7 @@ function Decode(direction, context, type, value) {
 // ------------------------------------------------------------------
 function Encode(direction, context, type, value) {
     const exterior = Callback(direction, context, type, value);
-    for (const schema of UnionPrioritySort(type.anyOf, -1)) {
+    for (const schema of type.anyOf) {
         const variant = FromType(direction, context, schema, Clone(exterior));
         if (!Check(context, schema, variant))
             continue;

package/node_modules/typebox/build/value/convert/from_enum.mjs

@@ -1,7 +1,6 @@
 // deno-fmt-ignore-file
-import { EnumToUnion } from '../../type/engine/enum/index.mjs';
-import { FromUnion } from './from_union.mjs';
+import { Evaluate } from '../../type/index.mjs';
+import { FromType } from './from_type.mjs';
 export function FromEnum(context, type, value) {
-    const union = EnumToUnion(type);
-    return FromUnion(context, union, value);
+    return FromType(context, Evaluate(type), value);
 }

package/node_modules/typebox/build/value/convert/from_template_literal.d.mts

@@ -1,2 +1,2 @@
-import type { TTemplateLiteral, TProperties } from '../../type/index.mjs';
+import { type TTemplateLiteral, type TProperties } from '../../type/index.mjs';
 export declare function FromTemplateLiteral(context: TProperties, type: TTemplateLiteral, value: unknown): unknown;

package/node_modules/typebox/build/value/convert/from_template_literal.mjs

@@ -1,7 +1,6 @@
 // deno-fmt-ignore-file
-import { TemplateLiteralDecode } from '../../type/engine/template_literal/index.mjs';
+import { Evaluate } from '../../type/index.mjs';
 import { FromType } from './from_type.mjs';
 export function FromTemplateLiteral(context, type, value) {
-    const decoded = TemplateLiteralDecode(type.pattern);
-    return FromType(context, decoded, value);
+    return FromType(context, Evaluate(type), value);
 }

package/node_modules/typebox/build/value/convert/from_type.mjs

@@ -1,7 +1,6 @@
 // deno-fmt-ignore-file
 import * as Type from '../../type/index.mjs';
 import { FromArray } from './from_array.mjs';
-import { FromBase } from './from_base.mjs';
 import { FromBigInt } from './from_bigint.mjs';
 import { FromBoolean } from './from_boolean.mjs';
 import { FromCyclic } from './from_cyclic.mjs';
@@ -22,24 +21,23 @@ import { FromUnion } from './from_union.mjs';
 import { FromVoid } from './from_void.mjs';
 export function FromType(context, type, value) {
     return (Type.IsArray(type) ? FromArray(context, type, value) :
-        Type.IsBase(type) ? FromBase(context, type, value) :
-            Type.IsBigInt(type) ? FromBigInt(context, type, value) :
-                Type.IsBoolean(type) ? FromBoolean(context, type, value) :
-                    Type.IsCyclic(type) ? FromCyclic(context, type, value) :
-                        Type.IsEnum(type) ? FromEnum(context, type, value) :
-                            Type.IsInteger(type) ? FromInteger(context, type, value) :
-                                Type.IsIntersect(type) ? FromIntersect(context, type, value) :
-                                    Type.IsLiteral(type) ? FromLiteral(context, type, value) :
-                                        Type.IsNull(type) ? FromNull(context, type, value) :
-                                            Type.IsNumber(type) ? FromNumber(context, type, value) :
-                                                Type.IsObject(type) ? FromObject(context, type, value) :
-                                                    Type.IsRecord(type) ? FromRecord(context, type, value) :
-                                                        Type.IsRef(type) ? FromRef(context, type, value) :
-                                                            Type.IsString(type) ? FromString(context, type, value) :
-                                                                Type.IsTemplateLiteral(type) ? FromTemplateLiteral(context, type, value) :
-                                                                    Type.IsTuple(type) ? FromTuple(context, type, value) :
-                                                                        Type.IsUndefined(type) ? FromUndefined(context, type, value) :
-                                                                            Type.IsUnion(type) ? FromUnion(context, type, value) :
-                                                                                Type.IsVoid(type) ? FromVoid(context, type, value) :
-                                                                                    value);
+        Type.IsBigInt(type) ? FromBigInt(context, type, value) :
+            Type.IsBoolean(type) ? FromBoolean(context, type, value) :
+                Type.IsCyclic(type) ? FromCyclic(context, type, value) :
+                    Type.IsEnum(type) ? FromEnum(context, type, value) :
+                        Type.IsInteger(type) ? FromInteger(context, type, value) :
+                            Type.IsIntersect(type) ? FromIntersect(context, type, value) :
+                                Type.IsLiteral(type) ? FromLiteral(context, type, value) :
+                                    Type.IsNull(type) ? FromNull(context, type, value) :
+                                        Type.IsNumber(type) ? FromNumber(context, type, value) :
+                                            Type.IsObject(type) ? FromObject(context, type, value) :
+                                                Type.IsRecord(type) ? FromRecord(context, type, value) :
+                                                    Type.IsRef(type) ? FromRef(context, type, value) :
+                                                        Type.IsString(type) ? FromString(context, type, value) :
+                                                            Type.IsTemplateLiteral(type) ? FromTemplateLiteral(context, type, value) :
+                                                                Type.IsTuple(type) ? FromTuple(context, type, value) :
+                                                                    Type.IsUndefined(type) ? FromUndefined(context, type, value) :
+                                                                        Type.IsUnion(type) ? FromUnion(context, type, value) :
+                                                                            Type.IsVoid(type) ? FromVoid(context, type, value) :
+                                                                                value);
 }

package/node_modules/typebox/build/value/create/from_enum.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
-import { EnumToUnion } from '../../type/engine/enum/index.mjs';
+import { Evaluate } from '../../type/index.mjs';
 import { FromType } from './from_type.mjs';
 export function FromEnum(context, type) {
-    return FromType(context, EnumToUnion(type));
+    return FromType(context, Evaluate(type));
 }

package/node_modules/typebox/build/value/create/from_type.mjs

@@ -3,8 +3,6 @@ import * as T from '../../type/index.mjs';
 import * as S from '../../schema/types/index.mjs';
 import { FromDefault } from './from_default.mjs';
 import { FromArray } from './from_array.mjs';
-import { FromAsyncIterator } from './from_async_iterator.mjs';
-import { FromBase } from './from_base.mjs';
 import { FromBigInt } from './from_bigint.mjs';
 import { FromBoolean } from './from_boolean.mjs';
 import { FromConstructor } from './from_constructor.mjs';
@@ -13,13 +11,11 @@ import { FromEnum } from './from_enum.mjs';
 import { FromFunction } from './from_function.mjs';
 import { FromInteger } from './from_integer.mjs';
 import { FromIntersect } from './from_intersect.mjs';
-import { FromIterator } from './from_iterator.mjs';
 import { FromLiteral } from './from_literal.mjs';
 import { FromNever } from './from_never.mjs';
 import { FromNull } from './from_null.mjs';
 import { FromNumber } from './from_number.mjs';
 import { FromObject } from './from_object.mjs';
-import { FromPromise } from './from_promise.mjs';
 import { FromRecord } from './from_record.mjs';
 import { FromRef } from './from_ref.mjs';
 import { FromString } from './from_string.mjs';
@@ -39,31 +35,27 @@ export function FromType(context, type) {
         // Types
         // -----------------------------------------------------
         T.IsArray(type) ? FromArray(context, type) :
-            T.IsAsyncIterator(type) ? FromAsyncIterator(context, type) :
-                T.IsBase(type) ? FromBase(context, type) :
-                    T.IsBigInt(type) ? FromBigInt(context, type) :
-                        T.IsBoolean(type) ? FromBoolean(context, type) :
-                            T.IsConstructor(type) ? FromConstructor(context, type) :
-                                T.IsCyclic(type) ? FromCyclic(context, type) :
-                                    T.IsEnum(type) ? FromEnum(context, type) :
-                                        T.IsFunction(type) ? FromFunction(context, type) :
-                                            T.IsInteger(type) ? FromInteger(context, type) :
-                                                T.IsIntersect(type) ? FromIntersect(context, type) :
-                                                    T.IsIterator(type) ? FromIterator(context, type) :
-                                                        T.IsLiteral(type) ? FromLiteral(context, type) :
-                                                            T.IsNever(type) ? FromNever(context, type) :
-                                                                T.IsNull(type) ? FromNull(context, type) :
-                                                                    T.IsNumber(type) ? FromNumber(context, type) :
-                                                                        T.IsObject(type) ? FromObject(context, type) :
-                                                                            T.IsPromise(type) ? FromPromise(context, type) :
-                                                                                T.IsRecord(type) ? FromRecord(context, type) :
-                                                                                    T.IsRef(type) ? FromRef(context, type) :
-                                                                                        T.IsString(type) ? FromString(context, type) :
-                                                                                            T.IsSymbol(type) ? FromSymbol(context, type) :
-                                                                                                T.IsTemplateLiteral(type) ? FromTemplateLiteral(context, type) :
-                                                                                                    T.IsTuple(type) ? FromTuple(context, type) :
-                                                                                                        T.IsUndefined(type) ? FromUndefined(context, type) :
-                                                                                                            T.IsUnion(type) ? FromUnion(context, type) :
-                                                                                                                T.IsVoid(type) ? FromVoid(context, type) :
-                                                                                                                    undefined);
+            T.IsBigInt(type) ? FromBigInt(context, type) :
+                T.IsBoolean(type) ? FromBoolean(context, type) :
+                    T.IsConstructor(type) ? FromConstructor(context, type) :
+                        T.IsCyclic(type) ? FromCyclic(context, type) :
+                            T.IsEnum(type) ? FromEnum(context, type) :
+                                T.IsFunction(type) ? FromFunction(context, type) :
+                                    T.IsInteger(type) ? FromInteger(context, type) :
+                                        T.IsIntersect(type) ? FromIntersect(context, type) :
+                                            T.IsLiteral(type) ? FromLiteral(context, type) :
+                                                T.IsNever(type) ? FromNever(context, type) :
+                                                    T.IsNull(type) ? FromNull(context, type) :
+                                                        T.IsNumber(type) ? FromNumber(context, type) :
+                                                            T.IsObject(type) ? FromObject(context, type) :
+                                                                T.IsRecord(type) ? FromRecord(context, type) :
+                                                                    T.IsRef(type) ? FromRef(context, type) :
+                                                                        T.IsString(type) ? FromString(context, type) :
+                                                                            T.IsSymbol(type) ? FromSymbol(context, type) :
+                                                                                T.IsTemplateLiteral(type) ? FromTemplateLiteral(context, type) :
+                                                                                    T.IsTuple(type) ? FromTuple(context, type) :
+                                                                                        T.IsUndefined(type) ? FromUndefined(context, type) :
+                                                                                            T.IsUnion(type) ? FromUnion(context, type) :
+                                                                                                T.IsVoid(type) ? FromVoid(context, type) :
+                                                                                                    undefined);
 }

package/node_modules/typebox/build/value/default/from_object.mjs

@@ -17,7 +17,7 @@ export function FromObject(context, type, value) {
         if (isUnassignableUndefined)
             continue;
         // Assign
-        value[key] = FromType(context, type.properties[key], value[key]);
+        value[key] = propertyValue;
     }
     // return if not additional properties
     if (!IsAdditionalProperties(type) || Guard.IsBoolean(type.additionalProperties))

package/node_modules/typebox/build/value/default/from_type.mjs

@@ -3,7 +3,6 @@
 import { IsDefault } from '../../schema/index.mjs';
 import * as T from '../../type/index.mjs';
 import { FromArray } from './from_array.mjs';
-import { FromBase } from './from_base.mjs';
 import { FromCyclic } from './from_cyclic.mjs';
 import { FromDefault } from './from_default.mjs';
 import { FromIntersect } from './from_intersect.mjs';
@@ -15,13 +14,12 @@ import { FromUnion } from './from_union.mjs';
 export function FromType(context, type, value) {
     const defaulted = IsDefault(type) ? FromDefault(type, value) : value;
     return (T.IsArray(type) ? FromArray(context, type, defaulted) :
-        T.IsBase(type) ? FromBase(context, type, defaulted) :
-            T.IsCyclic(type) ? FromCyclic(context, type, defaulted) :
-                T.IsIntersect(type) ? FromIntersect(context, type, defaulted) :
-                    T.IsObject(type) ? FromObject(context, type, defaulted) :
-                        T.IsRecord(type) ? FromRecord(context, type, defaulted) :
-                            T.IsRef(type) ? FromRef(context, type, defaulted) :
-                                T.IsTuple(type) ? FromTuple(context, type, defaulted) :
-                                    T.IsUnion(type) ? FromUnion(context, type, defaulted) :
-                                        defaulted);
+        T.IsCyclic(type) ? FromCyclic(context, type, defaulted) :
+            T.IsIntersect(type) ? FromIntersect(context, type, defaulted) :
+                T.IsObject(type) ? FromObject(context, type, defaulted) :
+                    T.IsRecord(type) ? FromRecord(context, type, defaulted) :
+                        T.IsRef(type) ? FromRef(context, type, defaulted) :
+                            T.IsTuple(type) ? FromTuple(context, type, defaulted) :
+                                T.IsUnion(type) ? FromUnion(context, type, defaulted) :
+                                    defaulted);
 }

package/node_modules/typebox/build/value/index.d.mts

@@ -9,7 +9,6 @@ export * from './errors/index.mjs';
 export * from './default/index.mjs';
 export * from './equal/index.mjs';
 export * from './hash/index.mjs';
-export * from './mutate/index.mjs';
 export * from './parse/index.mjs';
 export * from './delta/index.mjs';
 export * from './pipeline/index.mjs';

package/node_modules/typebox/build/value/index.mjs

@@ -12,7 +12,6 @@ export * from './errors/index.mjs';
 export * from './default/index.mjs';
 export * from './equal/index.mjs';
 export * from './hash/index.mjs';
-export * from './mutate/index.mjs';
 export * from './parse/index.mjs';
 export * from './delta/index.mjs';
 export * from './pipeline/index.mjs';

package/node_modules/typebox/build/value/repair/from_enum.mjs

@@ -1,7 +1,6 @@
 // deno-fmt-ignore-file
-import { EnumToUnion } from '../../type/engine/enum/index.mjs';
+import { Evaluate } from '../../type/index.mjs';
 import { FromType } from './from_type.mjs';
 export function FromEnum(context, type, value) {
-    const union = EnumToUnion(type);
-    return FromType(context, union, value);
+    return FromType(context, Evaluate(type), value);
 }

package/node_modules/typebox/build/value/repair/from_type.mjs

@@ -4,7 +4,6 @@ import * as T from '../../type/index.mjs';
 import { Check } from '../check/index.mjs';
 import { Create } from '../create/index.mjs';
 import { FromArray } from './from_array.mjs';
-import { FromBase } from './from_base.mjs';
 import { FromEnum } from './from_enum.mjs';
 import { FromIntersect } from './from_intersect.mjs';
 import { FromObject } from './from_object.mjs';
@@ -33,17 +32,25 @@ function AssertRepairableValue(context, type, value) {
 // AssertRepairableType
 // ------------------------------------------------------------------
 function AssertRepairableType(context, type, value) {
-    const unsupported = T.IsAsyncIterator(type)
-        || T.IsIterator(type)
-        || T.IsConstructor(type)
+    const unsupported = T.IsConstructor(type)
         || T.IsFunction(type)
-        || T.IsNever(type)
-        || T.IsPromise(type);
+        || T.IsNever(type);
     if (unsupported) {
         throw new RepairError(context, type, value, 'Type is not repairable');
     }
 }
 // ------------------------------------------------------------------
+// CreateWhenUndefined
+//
+// If the value is 'undefined' AND the type is not TUndefined, then 
+// we know the value must be created. We handle this case for undefined 
+// only as it enables 'default' annotation to be initialized via Create 
+// before we applying subsequent Repair logic.
+// ------------------------------------------------------------------
+function CreateWhenUndefined(context, type, value) {
+    return (Guard.IsUndefined(value) && !T.IsUndefined(type)) ? Create(context, type) : value;
+}
+// ------------------------------------------------------------------
 // FinalizeRepair
 //
 // When a type includes the ~refine modifier, a post-repair validation
@@ -64,23 +71,18 @@ function FinalizeRepair(context, type, repaired) {
 // FromType
 // ------------------------------------------------------------------
 export function FromType(context, type, value) {
-    // Base Repair
-    if (T.IsBase(type)) {
-        const repaired = FromBase(context, type, value);
-        return FinalizeRepair(context, type, repaired);
-    }
-    // Schema Repair
     AssertRepairableValue(context, type, value);
     AssertRepairableType(context, type, value);
-    const repaired = (T.IsArray(type) ? FromArray(context, type, value) :
-        T.IsEnum(type) ? FromEnum(context, type, value) :
-            T.IsIntersect(type) ? FromIntersect(context, type, value) :
-                T.IsObject(type) ? FromObject(context, type, value) :
-                    T.IsRecord(type) ? FromRecord(context, type, value) :
-                        T.IsRef(type) ? FromRef(context, type, value) :
-                            T.IsTemplateLiteral(type) ? FromTemplateLiteral(context, type, value) :
-                                T.IsTuple(type) ? FromTuple(context, type, value) :
-                                    T.IsUnion(type) ? FromUnion(context, type, value) :
-                                        FromUnknown(context, type, value));
+    const candidate = CreateWhenUndefined(context, type, value);
+    const repaired = (T.IsArray(type) ? FromArray(context, type, candidate) :
+        T.IsEnum(type) ? FromEnum(context, type, candidate) :
+            T.IsIntersect(type) ? FromIntersect(context, type, candidate) :
+                T.IsObject(type) ? FromObject(context, type, candidate) :
+                    T.IsRecord(type) ? FromRecord(context, type, candidate) :
+                        T.IsRef(type) ? FromRef(context, type, candidate) :
+                            T.IsTemplateLiteral(type) ? FromTemplateLiteral(context, type, candidate) :
+                                T.IsTuple(type) ? FromTuple(context, type, candidate) :
+                                    T.IsUnion(type) ? FromUnion(context, type, candidate) :
+                                        FromUnknown(context, type, candidate));
     return FinalizeRepair(context, type, repaired);
 }

package/node_modules/typebox/build/value/shared/union_priority_sort.d.mts

@@ -1,3 +1,7 @@
 import { type TSchema } from '../../type/index.mjs';
-/** Deterministically sorts schemas by structural relationship (narrow to broad) */
-export declare function UnionPrioritySort(types: TSchema[], order?: number): TSchema[];
+/**
+ * (Type-Preprocessor) Recursively reorders Union variants from narrowest to broadest, ensuring
+ * more specific types (e.g. Literal) are evaluated before broader types (e.g. String). Used
+ * prior to Clean, Decode, and Encode operations.
+ */
+export declare function UnionPrioritySort(type: TSchema): TSchema;

package/node_modules/typebox/build/value/shared/union_priority_sort.mjs

@@ -1,36 +1,72 @@
 // deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { Compare } from '../../type/index.mjs';
+import Guard from '../../guard/index.mjs';
+import { IsArray, Array as _Array_, ArrayOptions } from '../../type/index.mjs';
+import { IsUnion, Union } from '../../type/index.mjs';
+import { IsObject, Object as _Object_ } from '../../type/index.mjs';
+import { IsRecord, Record, RecordKey, RecordValue } from '../../type/index.mjs';
+import { IsTuple, Tuple } from '../../type/index.mjs';
+import { IsIntersect, Intersect } from '../../type/index.mjs';
+import { Priority } from '../../type/index.mjs';
 // ------------------------------------------------------------------
-// DeterministicCompare
+// Modifiers (Mutable)
 //
-// Provides a deterministic tie-break for schemas. This is used when
-// schemas are structurally disjoint or mutually inclusive. While
-// JSON serialization incurs a performance overhead, it serves as a
-// reliable mechanism to ensure stable ordering and preserves the
-// alphabetical alignment of named constants.
+// Prioritized types lose `~modifier` properties and additional constraints
+// (e.g. additionalProperties) during the mapping phase and need to be
+// reassigned afterward. This is a fast mutable assignment to handle that,
+// but we should consider a more general solution. (review)
 //
 // ------------------------------------------------------------------
-function DeterministicCompare(left, right) {
-    return JSON.stringify(left).localeCompare(JSON.stringify(right));
+function Modifiers(type, next) {
+    for (const key of Guard.Keys(type)) {
+        if (Guard.HasPropertyKey(next, key))
+            continue;
+        next[key] = type[key];
+    }
+    return next;
+}
+// ------------------------------------------------------------------
+// Properties
+// ------------------------------------------------------------------
+function FromProperties(properties) {
+    const result = {};
+    for (const key of Guard.Keys(properties))
+        result[key] = FromType(properties[key]);
+    return result;
+}
+// ------------------------------------------------------------------
+// PriorityTypes
+// ------------------------------------------------------------------
+function FromPriorityTypes(types) {
+    return FromTypes(Priority(types));
+}
+// ------------------------------------------------------------------
+// Types
+// ------------------------------------------------------------------
+function FromTypes(types) {
+    return types.map(type => FromType(type));
+}
+// ------------------------------------------------------------------
+// Type
+// ------------------------------------------------------------------
+function FromType(type) {
+    const next = (IsArray(type) ? _Array_(FromType(type.items), ArrayOptions(type)) :
+        IsIntersect(type) ? Intersect(FromTypes(type.allOf)) :
+            IsUnion(type) ? Union(FromPriorityTypes(type.anyOf)) :
+                IsObject(type) ? _Object_(FromProperties(type.properties)) :
+                    IsRecord(type) ? Record(RecordKey(type), FromType(RecordValue(type))) :
+                        IsTuple(type) ? Tuple(FromTypes(type.items)) :
+                            type);
+    return Modifiers(type, next);
 }
 // ------------------------------------------------------------------
 // UnionPrioritySort
-//
-// Performs a deterministic sort on Union members. By default, this
-// function ensures that narrow (more specific) types precede broader
-// types in the resulting array. The order can be reversed by setting
-// the order property to -1 which will reverse unions from broader
-// to more narrow.
-//
 // ------------------------------------------------------------------
-/** Deterministically sorts schemas by structural relationship (narrow to broad) */
-export function UnionPrioritySort(types, order = 1) {
-    return types.sort((left, right) => {
-        const result = Compare(left, right);
-        return (Guard.IsEqual(result, 'disjoint') ? DeterministicCompare(left, right) :
-            Guard.IsEqual(result, 'right-inside') ? 1 :
-                Guard.IsEqual(result, 'left-inside') ? -1 :
-                    DeterministicCompare(left, right)) * order;
-    });
+/**
+ * (Type-Preprocessor) Recursively reorders Union variants from narrowest to broadest, ensuring
+ * more specific types (e.g. Literal) are evaluated before broader types (e.g. String). Used
+ * prior to Clean, Decode, and Encode operations.
+ */
+export function UnionPrioritySort(type) {
+    const result = FromType(type);
+    return result;
 }

package/node_modules/typebox/build/value/value.d.mts

@@ -9,7 +9,6 @@ export { Default } from './default/index.mjs';
 export { Equal } from './equal/index.mjs';
 export { Errors } from './errors/index.mjs';
 export { Hash } from './hash/index.mjs';
-export { Mutate, type TMutable } from './mutate/index.mjs';
 export { Parse } from './parse/index.mjs';
 export { Diff, Patch } from './delta/index.mjs';
 export { Pointer } from './pointer/index.mjs';

package/node_modules/typebox/build/value/value.mjs

@@ -9,7 +9,6 @@ export { Default } from './default/index.mjs';
 export { Equal } from './equal/index.mjs';
 export { Errors } from './errors/index.mjs';
 export { Hash } from './hash/index.mjs';
-export { Mutate } from './mutate/index.mjs';
 export { Parse } from './parse/index.mjs';
 export { Diff, Patch } from './delta/index.mjs';
 export { Pointer } from './pointer/index.mjs';

package/node_modules/typebox/package.json

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