typebox 1.1.31 → 1.1.33

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/engine/this/expand-this.mjs

@@ -1,11 +1,11 @@
 // deno-fmt-ignore-file
-import { IsArray, Array } from '../../types/array.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/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/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';

package/build/type/extends/literal.mjs

@@ -1,6 +1,6 @@
 // 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';

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

@@ -1,4 +1,4 @@
-import { TProperties } from '../types/properties.mjs';
+import { type TProperties } from '../types/properties.mjs';
 export type TResult = TExtendsUnion | TExtendsTrue | TExtendsFalse;
 export interface TExtendsUnion<Inferred extends TProperties = TProperties> {
     '~kind': 'ExtendsUnion';
@@ -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/build/type/script/token/internal/guard.d.mts

@@ -1 +1 @@
-export { IsArray, IsEqual, IsString } from '../../../../guard/guard.mjs';
+export { IsArray, IsEqual, IsString, TakeLeft } from '../../../../guard/guard.mjs';

package/build/type/script/token/internal/guard.mjs

@@ -1,5 +1,5 @@
 // deno-coverage-ignore-start - parsebox tested
-export { IsArray, IsEqual, IsString } from '../../../../guard/guard.mjs';
+export { IsArray, IsEqual, IsString, TakeLeft } from '../../../../guard/guard.mjs';
 // ------------------------------------------------------------------
 // Internal Guards to ensure Token is portable.
 // ------------------------------------------------------------------

package/build/type/script/token/internal/take.mjs

@@ -12,15 +12,11 @@ export function Take(variants, input) {
     // ----------------------------------------------------------------
     // Symmetric
     // ----------------------------------------------------------------
-    // const [left, ...right] = variants
-    // return (
-    //   IsString(left)
-    //     ? (() => {
-    //       const result = TakeVariant(left, input)
-    //       return IsEqual(result.length, 2) ? result : Take(right, input)
-    //     })()
-    //     : []
-    // ) as never
+    // return Guard.TakeLeft(variants, (valueLeft, valueRight) => 
+    //   Match(TakeVariant(valueLeft, input), (take, rest) => 
+    //     [take, rest],
+    //     () => Take(valueRight, input)),
+    //   () => []) as never
     // ----------------------------------------------------------------
     // Inline
     // ----------------------------------------------------------------

package/build/type/script/token/until.mjs

@@ -1,18 +1,15 @@
 // deno-coverage-ignore-start - parsebox tested
 // deno-fmt-ignore-file
 import { Match } from './internal/match.mjs';
-import { IsEqual, IsString } from './internal/guard.mjs';
+import { IsEqual, TakeLeft } from './internal/guard.mjs';
 function TakeOne(input) {
     const result = IsEqual(input, '') ? [] : [input.slice(0, 1), input.slice(1)];
     return result;
 }
 function IsInputMatchSentinal(end, input) {
-    const [left, ...right] = end;
-    return (IsString(left)
-        ? input.startsWith(left)
-            ? true
-            : IsInputMatchSentinal(right, input)
-        : false);
+    return TakeLeft(end, (left, right) => input.startsWith(left)
+        ? true
+        : IsInputMatchSentinal(right, input), () => false);
 }
 /** Match Input until but not including End. No match if End not found. */
 export function Until(end, input, result = '') {

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

@@ -10,7 +10,8 @@ export interface TArray<Type extends TSchema = TSchema> extends TSchema {
     items: Type;
 }
 /** Creates an Array type. */
-export declare function Array<Type extends TSchema>(items: Type, options?: TArrayOptions): TArray<Type>;
+export declare function _Array_<Type extends TSchema>(items: Type, options?: TArrayOptions): TArray<Type>;
+export { _Array_ as Array };
 /** Returns true if the given value is a TArray. */
 export declare function IsArray(value: unknown): value is TArray;
 /** Extracts options from a TArray. */

package/build/type/types/array.mjs

@@ -5,9 +5,10 @@ import { IsKind } from './schema.mjs';
 // Factory
 // ------------------------------------------------------------------
 /** Creates an Array type. */
-export function Array(items, options) {
+export function _Array_(items, options) {
     return Memory.Create({ '~kind': 'Array' }, { type: 'array', items }, options);
 }
+export { _Array_ as Array }; // Prevent Collision With Global Scope
 // ------------------------------------------------------------------
 // Guard
 // ------------------------------------------------------------------

package/build/type/types/function.mjs

@@ -8,7 +8,7 @@ import { IsKind } from './schema.mjs';
 export function _Function_(parameters, returnType, options = {}) {
     return Memory.Create({ ['~kind']: 'Function' }, { type: 'function', parameters, returnType }, options);
 }
-export { _Function_ as Function };
+export { _Function_ as Function }; // Prevent Collision With Global Scope
 // ------------------------------------------------------------------
 // Guard
 // ------------------------------------------------------------------

package/build/type/types/object.mjs

@@ -11,7 +11,7 @@ export function _Object_(properties, options = {}) {
     const required = requiredKeys.length > 0 ? { required: requiredKeys } : {};
     return Memory.Create({ '~kind': 'Object' }, { type: 'object', ...required, properties }, options);
 }
-export { _Object_ as Object }; // Required for CommonJS ES Interop
+export { _Object_ as Object }; // Prevent Collision With Global Scope
 // ------------------------------------------------------------------
 // Guard
 // ------------------------------------------------------------------

package/build/value/clean/from-cyclic.d.mts

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

package/build/value/convert/from-literal.d.mts

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

package/build/value/convert/try/try-bigint.d.mts

@@ -1,2 +1,2 @@
-import { TResult } from './try-result.mjs';
+import { type TResult } from './try-result.mjs';
 export declare function TryBigInt(value: unknown): TResult<bigint>;

package/build/value/convert/try/try-boolean.d.mts

@@ -1,2 +1,2 @@
-import { TResult } from './try-result.mjs';
+import { type TResult } from './try-result.mjs';
 export declare function TryBoolean(value: unknown): TResult<boolean>;

package/build/value/convert/try/try-null.d.mts

@@ -1,2 +1,2 @@
-import { TResult } from './try-result.mjs';
+import { type TResult } from './try-result.mjs';
 export declare function TryNull(value: unknown): TResult<null>;

package/build/value/convert/try/try-number.d.mts

@@ -1,2 +1,2 @@
-import { TResult } from './try-result.mjs';
+import { type TResult } from './try-result.mjs';
 export declare function TryNumber(value: unknown): TResult<number>;

package/build/value/convert/try/try-string.d.mts

@@ -1,2 +1,2 @@
-import { TResult } from './try-result.mjs';
+import { type TResult } from './try-result.mjs';
 export declare function TryString(value: unknown): TResult;

package/build/value/convert/try/try-undefined.d.mts

@@ -1,2 +1,2 @@
-import { TResult } from './try-result.mjs';
+import { type TResult } from './try-result.mjs';
 export declare function TryUndefined(value: unknown): TResult<undefined>;

package/build/value/default/from-intersect.d.mts

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

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.33",
   "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"