typebox 1.0.26 → 1.0.28

package/build/error/errors.d.mts

@@ -1,4 +1,4 @@
-export type TValidationError = TAdditionalPropertiesError | TAnyOfError | TBooleanError | TConstError | TContainsError | TDependenciesError | TDependentRequiredError | TEnumError | TExclusiveMaximumError | TExclusiveMinimumError | TFormatError | TIfError | TMaximumError | TMaxItemsError | TMaxLengthError | TMaxPropertiesError | TMinimumError | TMinItemsError | TMinLengthError | TMinPropertiesError | TMultipleOfError | TNotError | TOneOfError | TPatternError | TPropertyNamesError | TRefineError | TRequiredError | TStandardSchemaV1Error | TTypeError | TUnevaluatedItemsError | TUnevaluatedPropertiesError | TUniqueItemsError;
+export type TValidationError = TAdditionalPropertiesError | TAnyOfError | TBaseError | TBooleanError | TConstError | TContainsError | TDependenciesError | TDependentRequiredError | TEnumError | TExclusiveMaximumError | TExclusiveMinimumError | TFormatError | TIfError | TMaximumError | TMaxItemsError | TMaxLengthError | TMaxPropertiesError | TMinimumError | TMinItemsError | TMinLengthError | TMinPropertiesError | TMultipleOfError | TNotError | TOneOfError | TPatternError | TPropertyNamesError | TRefineError | TRequiredError | TTypeError | TUnevaluatedItemsError | TUnevaluatedPropertiesError | TUniqueItemsError;
 export declare function IsValidationError(value: unknown): value is TValidationError;
 export type TLocalizedValidationError = TValidationError & {
     message: string;
@@ -21,6 +21,12 @@ export interface TAnyOfError extends TValidationErrorBase {
     keyword: 'anyOf';
     params: {};
 }
+export interface TBaseError extends TValidationErrorBase {
+    keyword: '~base';
+    params: {
+        errors: object[];
+    };
+}
 export interface TBooleanError extends TValidationErrorBase {
     keyword: 'boolean';
     params: {};
@@ -182,16 +188,6 @@ export interface TRequiredError extends TValidationErrorBase {
         requiredProperties: string[];
     };
 }
-export interface TStandardSchemaV1Error extends TValidationErrorBase {
-    keyword: '~standard';
-    params: {
-        vendor: string;
-        issues: {
-            message: string;
-            path?: string[];
-        }[];
-    };
-}
 export interface TTypeError extends TValidationErrorBase {
     keyword: 'type';
     params: {

package/build/schema/engine/_base.d.mts

@@ -0,0 +1,5 @@
+import * as S from '../types/index.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildBase(context: BuildContext, schema: S.XBase, value: string): string;
+export declare function CheckBase(context: CheckContext, schema: S.XBase, value: unknown): boolean;
+export declare function ErrorBase(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XBase, value: unknown): boolean;

package/build/schema/engine/_base.mjs

@@ -0,0 +1,26 @@
+// deno-fmt-ignore-file
+import * as V from './_externals.mjs';
+import { EmitGuard as E } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildBase(context, schema, value) {
+    return E.Call(E.Member(E.Member(V.CreateExternalVariable(schema), '~base'), 'check'), [value]);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckBase(context, schema, value) {
+    return schema['~base'].check(value);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorBase(context, schemaPath, instancePath, schema, value) {
+    return schema['~base'].check(value) || context.AddError({
+        keyword: '~base',
+        schemaPath,
+        instancePath,
+        params: { errors: schema['~base'].errors(value) },
+    });
+}

package/build/schema/engine/index.d.mts

@@ -2,8 +2,8 @@ export * from './_context.mjs';
 export * from './_functions.mjs';
 export * from './_reducer.mjs';
 export * from './_externals.mjs';
+export * from './_base.mjs';
 export * from './_refine.mjs';
-export * from './_standard.mjs';
 export * from './additionalProperties.mjs';
 export * from './additionalItems.mjs';
 export * from './allOf.mjs';

package/build/schema/engine/index.mjs

@@ -8,8 +8,8 @@ export * from './_externals.mjs';
 // ------------------------------------------------------------------
 // Schematics
 // ------------------------------------------------------------------
+export * from './_base.mjs';
 export * from './_refine.mjs';
-export * from './_standard.mjs';
 export * from './additionalProperties.mjs';
 export * from './additionalItems.mjs';
 export * from './allOf.mjs';

package/build/schema/engine/items.mjs

@@ -7,7 +7,7 @@ import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
 function BuildItemsSized(context, schema, value) {
     return E.ReduceAnd(schema.items.map((schema, index) => {
-        const isLength = E.IsGreaterEqualThan(E.Constant(index), E.Member(value, 'length'));
+        const isLength = E.IsLessEqualThan(E.Member(value, 'length'), E.Constant(index));
         const isSchema = BuildSchema(context, schema, `${value}[${index}]`);
         const addIndex = context.AddIndex(E.Constant(index));
         const guarded = context.UseUnevaluated() ? E.And(isSchema, addIndex) : isSchema;
@@ -16,7 +16,7 @@ function BuildItemsSized(context, schema, value) {
 }
 function CheckItemsSized(context, schema, value) {
     return G.Every(schema.items, 0, (schema, index) => {
-        return G.IsGreaterEqualThan(index, value.length)
+        return G.IsLessEqualThan(value.length, index)
             || (CheckSchema(context, schema, value[index]) && context.AddIndex(index));
     });
 }
@@ -24,7 +24,7 @@ function ErrorItemsSized(context, schemaPath, instancePath, schema, value) {
     return G.EveryAll(schema.items, 0, (schema, index) => {
         const nextSchemaPath = `${schemaPath}/items/${index}`;
         const nextInstancePath = `${instancePath}/${index}`;
-        return G.IsGreaterEqualThan(index, value.length)
+        return G.IsLessEqualThan(value.length, index)
             || (ErrorSchema(context, nextSchemaPath, nextInstancePath, schema, value[index]) && context.AddIndex(index));
     });
 }

package/build/schema/engine/prefixItems.mjs

@@ -6,7 +6,7 @@ import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
 export function BuildPrefixItems(context, schema, value) {
     return E.ReduceAnd(schema.prefixItems.map((schema, index) => {
-        const isLength = E.IsGreaterEqualThan(E.Constant(index), E.Member(value, 'length'));
+        const isLength = E.IsLessEqualThan(E.Member(value, 'length'), E.Constant(index));
         const isSchema = BuildSchema(context, schema, `${value}[${index}]`);
         const addIndex = context.AddIndex(E.Constant(index));
         const guarded = context.UseUnevaluated() ? E.And(isSchema, addIndex) : isSchema;
@@ -18,7 +18,7 @@ export function BuildPrefixItems(context, schema, value) {
 // ------------------------------------------------------------------
 export function CheckPrefixItems(context, schema, value) {
     return G.IsEqual(value.length, 0) || G.Every(schema.prefixItems, 0, (schema, index) => {
-        return G.IsGreaterEqualThan(index, value.length)
+        return G.IsLessEqualThan(value.length, index)
             || (CheckSchema(context, schema, value[index]) && context.AddIndex(index));
     });
 }
@@ -29,7 +29,7 @@ export function ErrorPrefixItems(context, schemaPath, instancePath, schema, valu
     return G.IsEqual(value.length, 0) || G.EveryAll(schema.prefixItems, 0, (schema, index) => {
         const nextSchemaPath = `${schemaPath}/prefixItems/${index}`;
         const nextInstancePath = `${instancePath}/${index}`;
-        return G.IsGreaterEqualThan(index, value.length)
+        return G.IsLessEqualThan(value.length, index)
             || (ErrorSchema(context, nextSchemaPath, nextInstancePath, schema, value[index]) && context.AddIndex(index));
     });
 }

package/build/schema/engine/schema.mjs

@@ -1,8 +1,8 @@
 // deno-fmt-ignore-file
 import * as S from '../types/index.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
-import { BuildStandardSchemaV1, CheckStandardSchemaV1, ErrorStandardSchemaV1 } from './_standard.mjs';
 import { BuildRefine, CheckRefine, ErrorRefine } from './_refine.mjs';
+import { BuildBase, CheckBase, ErrorBase } from './_base.mjs';
 import { BuildAdditionalItems, CheckAdditionalItems, ErrorAdditionalItems } from './additionalItems.mjs';
 import { BuildAdditionalProperties, CheckAdditionalProperties, ErrorAdditionalProperties } from './additionalProperties.mjs';
 import { BuildAllOf, CheckAllOf, ErrorAllOf } from './allOf.mjs';
@@ -204,12 +204,12 @@ export function BuildSchema(context, schema, value) {
     }
     if (S.IsRef(schema))
         conditions.push(BuildRef(context, schema, value));
+    if (S.IsBase(schema))
+        conditions.push(BuildBase(context, schema, value));
     if (S.IsConst(schema))
         conditions.push(BuildConst(context, schema, value));
     if (S.IsEnum(schema))
         conditions.push(BuildEnum(context, schema, value));
-    if (S.IsStandardSchemaV1(schema))
-        conditions.push(BuildStandardSchemaV1(context, schema, value));
     if (S.IsIf(schema))
         conditions.push(BuildIf(context, schema, value));
     if (S.IsNot(schema))
@@ -262,9 +262,9 @@ export function CheckSchema(context, schema, value) {
             (!S.IsMinimum(schema) || CheckMinimum(context, schema, value)) &&
             (!S.IsMultipleOf(schema) || CheckMultipleOf(context, schema, value)))) &&
         (!S.IsRef(schema) || CheckRef(context, schema, value)) &&
+        (!S.IsBase(schema) || CheckBase(context, schema, value)) &&
         (!S.IsConst(schema) || CheckConst(context, schema, value)) &&
         (!S.IsEnum(schema) || CheckEnum(context, schema, value)) &&
-        (!S.IsStandardSchemaV1(schema) || CheckStandardSchemaV1(context, schema, value)) &&
         (!S.IsIf(schema) || CheckIf(context, schema, value)) &&
         (!S.IsNot(schema) || CheckNot(context, schema, value)) &&
         (!S.IsAllOf(schema) || CheckAllOf(context, schema, value)) &&
@@ -308,9 +308,9 @@ export function ErrorSchema(context, schemaPath, instancePath, schema, value) {
             +(!S.IsMinimum(schema) || ErrorMinimum(context, schemaPath, instancePath, schema, value)) &
             +(!S.IsMultipleOf(schema) || ErrorMultipleOf(context, schemaPath, instancePath, schema, value)))) &
         +(!S.IsRef(schema) || ErrorRef(context, schemaPath, instancePath, schema, value)) &
+        +(!S.IsBase(schema) || ErrorBase(context, schemaPath, instancePath, schema, value)) &
         +(!S.IsConst(schema) || ErrorConst(context, schemaPath, instancePath, schema, value)) &
         +(!S.IsEnum(schema) || ErrorEnum(context, schemaPath, instancePath, schema, value)) &
-        +(!S.IsStandardSchemaV1(schema) || ErrorStandardSchemaV1(context, schemaPath, instancePath, schema, value)) &
         +(!S.IsIf(schema) || ErrorIf(context, schemaPath, instancePath, schema, value)) &
         +(!S.IsNot(schema) || ErrorNot(context, schemaPath, instancePath, schema, value)) &
         +(!S.IsAllOf(schema) || ErrorAllOf(context, schemaPath, instancePath, schema, value)) &

package/build/schema/types/_base.d.mts

@@ -0,0 +1,10 @@
+import type { XSchema } from './schema.mjs';
+export interface XBaseValidator<Value extends unknown = unknown> {
+    check(value: unknown): value is Value;
+    errors(value: unknown): object[];
+}
+export interface XBase<Value extends unknown = unknown> {
+    '~base': XBaseValidator<Value>;
+}
+export declare function IsBaseValidator(value: unknown): value is XBaseValidator;
+export declare function IsBase(value: XSchema): value is XBase;

package/build/schema/types/_base.mjs

@@ -0,0 +1,16 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+export function IsBaseValidator(value) {
+    return Guard.IsObject(value)
+        && Guard.HasPropertyKey(value, 'check')
+        && Guard.HasPropertyKey(value, 'errors')
+        && Guard.IsFunction(value.check)
+        && Guard.IsFunction(value.errors);
+}
+export function IsBase(value) {
+    return Guard.HasPropertyKey(value, '~base')
+        && IsBaseValidator(value['~base']);
+}

package/build/schema/types/index.d.mts

@@ -1,5 +1,5 @@
 export * from './_refine.mjs';
-export * from './_standard.mjs';
+export * from './_base.mjs';
 export * from './additionalProperties.mjs';
 export * from './additionalItems.mjs';
 export * from './allOf.mjs';

package/build/schema/types/index.mjs

@@ -2,7 +2,7 @@
 // Extensions
 // ------------------------------------------------------------------
 export * from './_refine.mjs';
-export * from './_standard.mjs';
+export * from './_base.mjs';
 // ------------------------------------------------------------------
 // Standard
 // ------------------------------------------------------------------

package/build/schema/types/static.d.mts

@@ -1,5 +1,5 @@
-import type { XSchemaLike } from '../types/schema.mjs';
-import type { XStandardSchemaV1, XStandardValidatorV1 } from './_standard.mjs';
+import type { XBase } from './_base.mjs';
+import type { XSchemaLike } from './schema.mjs';
 import type { XAdditionalProperties } from './additionalProperties.mjs';
 import type { XAnyOf } from './anyOf.mjs';
 import type { XAllOf } from './allOf.mjs';
@@ -11,11 +11,7 @@ import type { XPatternProperties } from './patternProperties.mjs';
 import type { XPrefixItems } from './prefixItems.mjs';
 import type { XProperties } from './properties.mjs';
 import type { XRequired } from './required.mjs';
-export type XStaticStandardSchemaV1<Validator extends XStandardValidatorV1, ValidateResult extends unknown = ReturnType<Validator['validate']>, RemoveAsync extends unknown = Exclude<ValidateResult, Promise<any>>, RemoveIssue extends unknown = Exclude<RemoveAsync, {
-    issues: any;
-}>, Result extends unknown = RemoveIssue extends {
-    value: infer Value;
-} ? Value : unknown> = Result;
+export type XStaticBase<Value extends unknown> = Value;
 type XStaticAdditionalProperties<Schema extends XSchemaLike, Result extends Record<PropertyKey, unknown> = (Schema extends true ? {
     [key: string]: unknown;
 } : Schema extends false ? {} : {
@@ -104,14 +100,14 @@ type XStaticEvaluate<Schema extends unknown, Result extends unknown = Schema ext
     [Key in keyof Schema]: Schema[Key];
 } : Schema> = Result;
 type XStaticJsonSchema<Schema extends unknown, Keywords extends unknown[] = XStaticKeywords<Schema>, Intersect extends unknown = XStaticKeywordIntersect<Keywords>, Result extends unknown = XStaticEvaluate<Intersect>> = Result;
-/** Statically infers a JSON Schema or Standard Schema */
-export type XStaticType<Schema extends XSchemaLike, Result extends unknown = (Schema extends XStandardSchemaV1<infer Validator extends XStandardValidatorV1> ? XStaticStandardSchemaV1<Validator> : XStaticJsonSchema<Schema>)> = Result;
+/** Statically infers a JSON Schema or Validator */
+export type XStaticType<Schema extends XSchemaLike, Result extends unknown = (Schema extends XBase<infer Value> ? Value : XStaticJsonSchema<Schema>)> = Result;
 type XStaticMutableTuple<Schemas extends readonly unknown[]> = (Schemas extends [infer Left, ...infer Right extends unknown[]] ? [XStaticMutable<Left>, ...XStaticMutableTuple<Right>] : []);
 type XStaticMutableArray<Schema extends unknown, Result extends unknown[] = XStaticMutable<Schema>[]> = Result;
 type XStaticMutableObject<Schema extends object, Result extends Record<PropertyKey, unknown> = {
     -readonly [K in keyof Schema]: XStaticMutable<Schema[K]>;
 }> = Result;
-type XStaticMutable<Schema> = (Schema extends XStandardSchemaV1 ? Schema : Schema extends readonly [...infer Schemas extends unknown[]] ? XStaticMutableTuple<Schemas> : Schema extends readonly (infer Schema)[] ? XStaticMutableArray<Schema> : Schema extends object ? XStaticMutableObject<Schema> : Schema);
-/** Statically infers a JSON Schema or Standard Schema */
+type XStaticMutable<Schema> = (Schema extends XBase ? Schema : Schema extends readonly [...infer Schemas extends unknown[]] ? XStaticMutableTuple<Schemas> : Schema extends readonly (infer Schema)[] ? XStaticMutableArray<Schema> : Schema extends object ? XStaticMutableObject<Schema> : Schema);
+/** Statically infers a JSON Schema */
 export type XStatic<Schema extends XSchemaLike, Mutable extends XSchemaLike = XStaticMutable<Schema>, Result extends unknown = XStaticType<Mutable>> = Result;
 export {};

package/build/system/locale/ar_001.mjs

@@ -34,7 +34,7 @@ export function ar_001(error) {
         case 'unevaluatedProperties': return 'يجب ألا يحتوي على خصائص غير مقيمة';
         case 'uniqueItems': return `يجب ألا يحتوي على عناصر مكررة`;
         case '~refine': return error.params.message;
-        case '~standard': return `يجب أن يتطابق مع مخطط ${error.params.vendor}`;
+        case '~base': return `يجب أن يتطابق مع مخطط ${'Base'}`;
         default: return 'حدث خطأ غير معروف في التحقق من الصحة';
     }
 }

package/build/system/locale/bn_BD.mjs

@@ -34,7 +34,7 @@ export function bn_BD(error) {
         case 'unevaluatedProperties': return 'অবমূল্যায়িত বৈশিষ্ট্য থাকতে পারবে না';
         case 'uniqueItems': return `অনুলিপি আইটেম থাকতে পারবে না`;
         case '~refine': return error.params.message;
-        case '~standard': return `${error.params.vendor} স্কিমার সাথে মিলতে হবে`;
+        case '~base': return `${'Base'} স্কিমার সাথে মিলতে হবে`;
         default: return 'একটি অজানা বৈধকরণ ত্রুটি ঘটেছে';
     }
 }

package/build/system/locale/cs_CZ.mjs

@@ -34,7 +34,7 @@ export function cs_CZ(error) {
         case 'unevaluatedProperties': return 'nesmí mít nevyhodnocené vlastnosti';
         case 'uniqueItems': return `nesmí mít duplicitní položky`;
         case '~refine': return error.params.message;
-        case '~standard': return `musí odpovídat schématu ${error.params.vendor}`;
+        case '~base': return `musí odpovídat schématu ${'Base'}`;
         default: return 'došlo k neznámé chybě ověření';
     }
 }

package/build/system/locale/de_DE.mjs

@@ -34,7 +34,7 @@ export function de_DE(error) {
         case 'unevaluatedProperties': return 'darf keine unbewerteten Eigenschaften haben';
         case 'uniqueItems': return `darf keine doppelten Elemente haben`;
         case '~refine': return error.params.message;
-        case '~standard': return `muss mit dem ${error.params.vendor}-Schema übereinstimmen`;
+        case '~base': return `muss mit dem ${'Base'}-Schema übereinstimmen`;
         default: return 'ein unbekannter Validierungsfehler ist aufgetreten';
     }
 }

package/build/system/locale/el_GR.mjs

@@ -34,7 +34,7 @@ export function el_GR(error) {
         case 'unevaluatedProperties': return 'δεν πρέπει να έχει μη αξιολογημένες ιδιότητες';
         case 'uniqueItems': return `δεν πρέπει να έχει διπλά στοιχεία`;
         case '~refine': return error.params.message;
-        case '~standard': return `πρέπει να ταιριάζει με το σχήμα ${error.params.vendor}`;
+        case '~base': return `πρέπει να ταιριάζει με το σχήμα ${'Base'}`;
         default: return 'προέκυψε ένα άγνωστο σφάλμα επικύρωσης';
     }
 }

package/build/system/locale/en_US.mjs

@@ -33,7 +33,7 @@ export function en_US(error) {
         case 'unevaluatedProperties': return 'must not have unevaluated properties';
         case 'uniqueItems': return `must not have duplicate items`;
         case '~refine': return error.params.message;
-        case '~standard': return `must match against ${error.params.vendor} schema`;
+        case '~base': return `must match against ${'Base'} schema`;
         // deno-coverage-ignore - unreachable
         default: return 'an unknown validation error occurred';
     }

package/build/system/locale/es_419.mjs

@@ -34,7 +34,7 @@ export function es_419(error) {
         case 'unevaluatedProperties': return 'no debe tener propiedades no evaluadas';
         case 'uniqueItems': return `no debe tener elementos duplicados`;
         case '~refine': return error.params.message;
-        case '~standard': return `debe coincidir con el esquema de ${error.params.vendor}`;
+        case '~base': return `debe coincidir con el esquema de ${'Base'}`;
         default: return 'ocurrió un error de validación desconocido';
     }
 }

package/build/system/locale/es_AR.mjs

@@ -34,7 +34,7 @@ export function es_AR(error) {
         case 'unevaluatedProperties': return 'no debe tener propiedades no evaluadas';
         case 'uniqueItems': return `no debe tener elementos duplicados`;
         case '~refine': return error.params.message;
-        case '~standard': return `debe coincidir con el esquema de ${error.params.vendor}`;
+        case '~base': return `debe coincidir con el esquema de ${'Base'}`;
         default: return 'ocurrió un error de validación desconocido';
     }
 }

package/build/system/locale/es_ES.mjs

@@ -34,7 +34,7 @@ export function es_ES(error) {
         case 'unevaluatedProperties': return 'no debe tener propiedades no evaluadas';
         case 'uniqueItems': return `no debe tener elementos duplicados`;
         case '~refine': return error.params.message;
-        case '~standard': return `debe coincidir con el esquema de ${error.params.vendor}`;
+        case '~base': return `debe coincidir con el esquema de ${'Base'}`;
         default: return 'ha ocurrido un error de validación desconocido';
     }
 }

package/build/system/locale/es_MX.mjs

@@ -34,7 +34,7 @@ export function es_MX(error) {
         case 'unevaluatedProperties': return 'no debe tener propiedades no evaluadas';
         case 'uniqueItems': return `no debe tener elementos duplicados`;
         case '~refine': return error.params.message;
-        case '~standard': return `debe coincidir con el esquema de ${error.params.vendor}`;
+        case '~base': return `debe coincidir con el esquema de ${'Base'}`;
         default: return 'ocurrió un error de validación desconocido';
     }
 }

package/build/system/locale/fa_IR.mjs

@@ -34,7 +34,7 @@ export function fa_IR(error) {
         case 'unevaluatedProperties': return 'نباید ویژگی‌های ارزیابی نشده داشته باشد';
         case 'uniqueItems': return `نباید آیتم‌های تکراری داشته باشد`;
         case '~refine': return error.params.message;
-        case '~standard': return `باید با طرح‌واره ${error.params.vendor} مطابقت داشته باشد`;
+        case '~base': return `باید با طرح‌واره ${'Base'} مطابقت داشته باشد`;
         default: return 'یک خطای اعتبارسنجی ناشناخته رخ داده است';
     }
 }

package/build/system/locale/fil_PH.mjs

@@ -34,7 +34,7 @@ export function fil_PH(error) {
         case 'unevaluatedProperties': return 'hindi dapat magkaroon ng mga hindi pa nasusuring katangian';
         case 'uniqueItems': return `hindi dapat magkaroon ng mga duplicate na item`;
         case '~refine': return error.params.message;
-        case '~standard': return `dapat tumugma laban sa ${error.params.vendor} schema`;
+        case '~base': return `dapat tumugma laban sa ${'Base'} schema`;
         default: return 'nagkaroon ng hindi kilalang error sa pagpapatunay';
     }
 }

package/build/system/locale/fr_CA.mjs

@@ -34,7 +34,7 @@ export function fr_CA(error) {
         case 'unevaluatedProperties': return 'ne doit pas avoir de propriétés non évaluées';
         case 'uniqueItems': return `ne doit pas avoir d'éléments en double`;
         case '~refine': return error.params.message;
-        case '~standard': return `doit correspondre au schéma ${error.params.vendor}`;
+        case '~base': return `doit correspondre au schéma ${'Base'}`;
         default: return 'une erreur de validation inconnue est survenue';
     }
 }

package/build/system/locale/fr_FR.mjs

@@ -34,7 +34,7 @@ export function fr_FR(error) {
         case 'unevaluatedProperties': return 'ne doit pas avoir de propriétés non évaluées';
         case 'uniqueItems': return `ne doit pas avoir d'éléments en double`;
         case '~refine': return error.params.message;
-        case '~standard': return `doit correspondre au schéma ${error.params.vendor}`;
+        case '~base': return `doit correspondre au schéma ${'Base'}`;
         default: return 'une erreur de validation inconnue est survenue';
     }
 }

package/build/system/locale/ha_NG.mjs

@@ -34,7 +34,7 @@ export function ha_NG(error) {
         case 'unevaluatedProperties': return 'kada ya kasance yana da kaddarorin da ba a kimanta su ba';
         case 'uniqueItems': return `kada ya kasance yana da abubuwan da suka yi kama`;
         case '~refine': return error.params.message;
-        case '~standard': return `dole ne ya dace da tsarin ${error.params.vendor}`;
+        case '~base': return `dole ne ya dace da tsarin ${'Base'}`;
         default: return 'an sami kuskuren tabbatarwa da ba a sani ba';
     }
 }

package/build/system/locale/hi_IN.mjs

@@ -34,7 +34,7 @@ export function hi_IN(error) {
         case 'unevaluatedProperties': return 'में अप्रयुक्त गुण नहीं होने चाहिए';
         case 'uniqueItems': return `में डुप्लिकेट आइटम नहीं होने चाहिए`;
         case '~refine': return error.params.message;
-        case '~standard': return `${error.params.vendor} स्कीमा के विरुद्ध मेल खाना चाहिए`;
+        case '~base': return `${'Base'} स्कीमा के विरुद्ध मेल खाना चाहिए`;
         default: return 'एक अज्ञात सत्यापन त्रुटि हुई';
     }
 }

package/build/system/locale/hu_HU.mjs

@@ -34,7 +34,7 @@ export function hu_HU(error) {
         case 'unevaluatedProperties': return 'nem lehetnek nem értékelt tulajdonságai';
         case 'uniqueItems': return `nem lehetnek ismétlődő elemei`;
         case '~refine': return error.params.message;
-        case '~standard': return `meg kell egyeznie a(z) ${error.params.vendor} sémával`;
+        case '~base': return `meg kell egyeznie a(z) ${'Base'} sémával`;
         default: return 'ismeretlen validációs hiba történt';
     }
 }

package/build/system/locale/id_ID.mjs

@@ -34,7 +34,7 @@ export function id_ID(error) {
         case 'unevaluatedProperties': return 'tidak boleh memiliki properti yang belum dievaluasi';
         case 'uniqueItems': return `tidak boleh memiliki item duplikat`;
         case '~refine': return error.params.message;
-        case '~standard': return `harus cocok dengan skema ${error.params.vendor}`;
+        case '~base': return `harus cocok dengan skema ${'Base'}`;
         default: return 'terjadi kesalahan validasi yang tidak diketahui';
     }
 }

package/build/system/locale/it_IT.mjs

@@ -34,7 +34,7 @@ export function it_IT(error) {
         case 'unevaluatedProperties': return 'non deve avere proprietà non valutate';
         case 'uniqueItems': return `non deve avere elementi duplicati`;
         case '~refine': return error.params.message;
-        case '~standard': return `deve corrispondere allo schema ${error.params.vendor}`;
+        case '~base': return `deve corrispondere allo schema ${'Base'}`;
         default: return 'si è verificato un errore di validazione sconosciuto';
     }
 }

package/build/system/locale/ja_JP.mjs

@@ -34,7 +34,7 @@ export function ja_JP(error) {
         case 'unevaluatedProperties': return '未評価のプロパティを持つことはできません';
         case 'uniqueItems': return `重複するアイテムを持つことはできません`;
         case '~refine': return error.params.message;
-        case '~standard': return `${error.params.vendor} スキーマと一致する必要があります`;
+        case '~base': return `${'Base'} スキーマと一致する必要があります`;
         default: return '不明なバリデーションエラーが発生しました';
     }
 }

package/build/system/locale/ko_KR.mjs

@@ -34,7 +34,7 @@ export function ko_KR(error) {
         case 'unevaluatedProperties': return '평가되지 않은 속성을 가질 수 없습니다';
         case 'uniqueItems': return `중복 항목을 가질 수 없습니다`;
         case '~refine': return error.params.message;
-        case '~standard': return `${error.params.vendor} 스키마와 일치해야 합니다`;
+        case '~base': return `${'Base'} 스키마와 일치해야 합니다`;
         default: return '알 수 없는 유효성 검사 오류가 발생했습니다';
     }
 }

package/build/system/locale/ms_MY.mjs

@@ -34,7 +34,7 @@ export function ms_MY(error) {
         case 'unevaluatedProperties': return 'tidak boleh mempunyai sifat yang tidak dinilai';
         case 'uniqueItems': return `tidak boleh mempunyai item pendua`;
         case '~refine': return error.params.message;
-        case '~standard': return `mesti sepadan dengan skema ${error.params.vendor}`;
+        case '~base': return `mesti sepadan dengan skema ${'Base'}`;
         default: return 'ralat pengesahan yang tidak diketahui berlaku';
     }
 }

package/build/system/locale/nl_NL.mjs

@@ -34,7 +34,7 @@ export function nl_NL(error) {
         case 'unevaluatedProperties': return 'mag geen onbeoordeelde eigenschappen hebben';
         case 'uniqueItems': return `mag geen dubbele items hebben`;
         case '~refine': return error.params.message;
-        case '~standard': return `moet overeenkomen met ${error.params.vendor} schema`;
+        case '~base': return `moet overeenkomen met ${'Base'} schema`;
         default: return 'er is een onbekende validatiefout opgetreden';
     }
 }

package/build/system/locale/pl_PL.mjs

@@ -34,7 +34,7 @@ export function pl_PL(error) {
         case 'unevaluatedProperties': return 'nie może mieć nieewaluowanych właściwości';
         case 'uniqueItems': return `nie może zawierać zduplikowanych elementów`;
         case '~refine': return error.params.message;
-        case '~standard': return `musi pasować do schematu ${error.params.vendor}`;
+        case '~base': return `musi pasować do schematu ${'Base'}`;
         default: return 'wystąpił nieznany błąd walidacji';
     }
 }

package/build/system/locale/pt_BR.mjs

@@ -34,7 +34,7 @@ export function pt_BR(error) {
         case 'unevaluatedProperties': return 'não deve ter propriedades não avaliadas';
         case 'uniqueItems': return `não deve ter itens duplicados`;
         case '~refine': return error.params.message;
-        case '~standard': return `deve corresponder ao esquema ${error.params.vendor}`;
+        case '~base': return `deve corresponder ao esquema ${'Base'}`;
         default: return 'ocorreu um erro de validação desconhecido';
     }
 }

package/build/system/locale/pt_PT.mjs

@@ -34,7 +34,7 @@ export function pt_PT(error) {
         case 'unevaluatedProperties': return 'não deve ter propriedades não avaliadas';
         case 'uniqueItems': return `não deve ter itens duplicados`;
         case '~refine': return error.params.message;
-        case '~standard': return `deve corresponder ao esquema ${error.params.vendor}`;
+        case '~base': return `deve corresponder ao esquema ${'Base'}`;
         default: return 'ocorreu um erro de validação desconhecido';
     }
 }

package/build/system/locale/ro_RO.mjs

@@ -34,7 +34,7 @@ export function ro_RO(error) {
         case 'unevaluatedProperties': return 'nu trebuie să aibă proprietăți neevaluate';
         case 'uniqueItems': return `nu trebuie să aibă elemente duplicate`;
         case '~refine': return error.params.message;
-        case '~standard': return `trebuie să se potrivească cu schema ${error.params.vendor}`;
+        case '~base': return `trebuie să se potrivească cu schema ${'Base'}`;
         default: return 'a apărut o eroare de validare necunoscută';
     }
 }

package/build/system/locale/ru_RU.mjs

@@ -34,7 +34,7 @@ export function ru_RU(error) {
         case 'unevaluatedProperties': return 'не должно быть нерассмотренных свойств';
         case 'uniqueItems': return `не должно быть повторяющихся элементов`;
         case '~refine': return error.params.message;
-        case '~standard': return `должен соответствовать схеме ${error.params.vendor}`;
+        case '~base': return `должен соответствовать схеме ${'Base'}`;
         default: return 'произошла неизвестная ошибка валидации';
     }
 }

package/build/system/locale/sv_SE.mjs

@@ -34,7 +34,7 @@ export function sv_SE(error) {
         case 'unevaluatedProperties': return 'får inte ha oidentifierade egenskaper';
         case 'uniqueItems': return `får inte ha dubbletter`;
         case '~refine': return error.params.message;
-        case '~standard': return `måste matcha mot ${error.params.vendor} schema`;
+        case '~base': return `måste matcha mot ${'Base'} schema`;
         default: return 'ett okänt valideringsfel uppstod';
     }
 }

package/build/system/locale/sw_TZ.mjs

@@ -34,7 +34,7 @@ export function sw_TZ(error) {
         case 'unevaluatedProperties': return 'haipaswi kuwa na sifa zisizotathminiwa';
         case 'uniqueItems': return `haipaswi kuwa na vitu vilivyofanana`;
         case '~refine': return error.params.message;
-        case '~standard': return `lazima ilingane na schema ya ${error.params.vendor}`;
+        case '~base': return `lazima ilingane na schema ya ${'Base'}`;
         default: return 'hitilafu isiyojulikana ya uthibitishaji imetokea';
     }
 }

package/build/system/locale/th_TH.mjs

@@ -34,7 +34,7 @@ export function th_TH(error) {
         case 'unevaluatedProperties': return 'ต้องไม่มีคุณสมบัติที่ยังไม่ได้ประเมิน';
         case 'uniqueItems': return `ต้องไม่มีรายการที่ซ้ำกัน`;
         case '~refine': return error.params.message;
-        case '~standard': return `ต้องตรงกับ Schema ของ ${error.params.vendor}`;
+        case '~base': return `ต้องตรงกับ Schema ของ ${'Base'}`;
         default: return 'เกิดข้อผิดพลาดในการตรวจสอบที่ไม่รู้จัก';
     }
 }

package/build/system/locale/tr_TR.mjs

@@ -34,7 +34,7 @@ export function tr_TR(error) {
         case 'unevaluatedProperties': return 'değerlendirilmemiş özelliklere sahip olmamalıdır';
         case 'uniqueItems': return `yinelenen öğelere sahip olmamalıdır`;
         case '~refine': return error.params.message;
-        case '~standard': return `${error.params.vendor} şemasına göre eşleşmelidir`;
+        case '~base': return `${'Base'} şemasına göre eşleşmelidir`;
         default: return 'bilinmeyen bir doğrulama hatası oluştu';
     }
 }

package/build/system/locale/uk_UA.mjs

@@ -34,7 +34,7 @@ export function uk_UA(error) {
         case 'unevaluatedProperties': return 'не повинно мати неперевірених властивостей';
         case 'uniqueItems': return `не повинно мати повторюваних елементів`;
         case '~refine': return error.params.message;
-        case '~standard': return `має відповідати схемі ${error.params.vendor}`;
+        case '~base': return `має відповідати схемі ${'Base'}`;
         default: return 'виникла невідома помилка валідації';
     }
 }

package/build/system/locale/ur_PK.mjs

@@ -34,7 +34,7 @@ export function ur_PK(error) {
         case 'unevaluatedProperties': return 'غیر تشخیص شدہ خصوصیات نہیں ہونی چاہئیں';
         case 'uniqueItems': return `ڈپلیکیٹ آئٹمز نہیں ہونے چاہئیں`;
         case '~refine': return error.params.message;
-        case '~standard': return `${error.params.vendor} اسکیما سے مماثل ہونا چاہیے`;
+        case '~base': return `${'Base'} اسکیما سے مماثل ہونا چاہیے`;
         default: return 'تصدیق میں ایک نامعلوم خرابی پیش آئی';
     }
 }

package/build/system/locale/vi_VN.mjs

@@ -34,7 +34,7 @@ export function vi_VN(error) {
         case 'unevaluatedProperties': return 'không được có các thuộc tính chưa được đánh giá';
         case 'uniqueItems': return `không được có các mục trùng lặp`;
         case '~refine': return error.params.message;
-        case '~standard': return `phải khớp với schema ${error.params.vendor}`;
+        case '~base': return `phải khớp với schema ${'Base'}`;
         default: return 'đã xảy ra lỗi xác thực không xác định';
     }
 }

package/build/system/locale/yo_NG.mjs

@@ -34,7 +34,7 @@ export function yo_NG(error) {
         case 'unevaluatedProperties': return 'ko gbọdọ ni awọn ohun-ini ti ko ṣe iṣiro';
         case 'uniqueItems': return `ko gbọdọ ni awọn ohun elo ẹda`;
         case '~refine': return error.params.message;
-        case '~standard': return `gbọdọ baramu àlàyé ${error.params.vendor}`;
+        case '~base': return `gbọdọ baramu àlàyé ${'Base'}`;
         default: return 'aṣiṣe ijẹrisi aimọ waye';
     }
 }

package/build/system/locale/zh_Hans.mjs

@@ -34,7 +34,7 @@ export function zh_Hans(error) {
         case 'unevaluatedProperties': return '不得有未评估的属性';
         case 'uniqueItems': return `不得有重复项`;
         case '~refine': return error.params.message;
-        case '~standard': return `必须匹配 ${error.params.vendor} 模式`;
+        case '~base': return `必须匹配 ${'Base'} 模式`;
         default: return '发生未知验证错误';
     }
 }

package/build/system/locale/zh_Hant.mjs

@@ -34,7 +34,7 @@ export function zh_Hant(error) {
         case 'unevaluatedProperties': return '不得有未評估的屬性';
         case 'uniqueItems': return `不得有重複項目`;
         case '~refine': return error.params.message;
-        case '~standard': return `必須匹配 ${error.params.vendor} 模式`;
+        case '~base': return `必須匹配 ${'Base'} 模式`;
         default: return '發生未知驗證錯誤';
     }
 }

package/build/system/memory/clone.mjs

@@ -2,12 +2,12 @@
 import { Guard } from '../../guard/index.mjs';
 import { Metrics } from './metrics.mjs';
 // ------------------------------------------------------------------
-// StandardSchema
+// Base
 // ------------------------------------------------------------------
-function IsStandardSchema(value) {
-    return Guard.IsObject(value) && Guard.HasPropertyKey(value, '~standard');
+function IsBase(value) {
+    return Guard.IsObject(value) && Guard.HasPropertyKey(value, '~base');
 }
-function FromStandardSchema(value) {
+function FromBase(value) {
     return value; // non-clonable
 }
 // ------------------------------------------------------------------
@@ -47,7 +47,7 @@ function FromUnknown(value) {
 // ------------------------------------------------------------------
 function FromValue(value) {
     return (value instanceof RegExp ? FromRegExp(value) :
-        IsStandardSchema(value) ? FromStandardSchema(value) :
+        IsBase(value) ? FromBase(value) :
             Guard.IsArray(value) ? FromArray(value) :
                 Guard.IsObject(value) ? FromObject(value) :
                     FromUnknown(value));

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

@@ -1,4 +1,5 @@
 import { type TSchema } from './schema.mjs';
+import { type XBase, type XBaseValidator } from '../../schema/types/index.mjs';
 export declare class BaseNotImplemented extends Error {
     readonly cause: {
         type: Base;
@@ -7,9 +8,9 @@ export declare class BaseNotImplemented extends Error {
     constructor(type: Base, method: string);
 }
 /** Base class for creating extension types. */
-export declare class Base<Value extends unknown = unknown> implements TSchema {
+export declare class Base<Value extends unknown = unknown> implements TSchema, XBase<Value> {
     readonly '~kind': 'Base';
-    readonly '~standard': StandardSchemaV1.Props<Value>;
+    readonly '~base': BaseValidator<Value>;
     constructor();
     /** Checks a value or returns false if invalid */
     Check(value: unknown): value is Value;
@@ -26,37 +27,9 @@ export declare class Base<Value extends unknown = unknown> implements TSchema {
 }
 /** Returns true if the given value is a Base type. */
 export declare function IsBase(value: unknown): value is Base;
-interface StandardSchemaV1<Input = unknown, Output = Input> {
-    readonly '~standard': StandardSchemaV1.Props<Input, Output>;
-}
-declare namespace StandardSchemaV1 {
-    export interface Props<Input = unknown, Output = Input> {
-        readonly version: 1;
-        readonly vendor: string;
-        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
-        readonly types?: Types<Input, Output> | undefined;
-    }
-    export type Result<Output> = SuccessResult<Output> | FailureResult;
-    export interface SuccessResult<Output> {
-        readonly value: Output;
-        readonly issues?: undefined;
-    }
-    export interface FailureResult {
-        readonly issues: ReadonlyArray<Issue>;
-    }
-    export interface Issue {
-        readonly message: string;
-        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
-    }
-    export interface PathSegment {
-        readonly key: PropertyKey;
-    }
-    export interface Types<Input = unknown, Output = Input> {
-        readonly input: Input;
-        readonly output: Output;
-    }
-    export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
-    export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
-    export {};
+declare class BaseValidator<Value extends unknown = unknown> implements XBaseValidator<Value> {
+    readonly check: (value: unknown) => value is Value;
+    readonly errors: (value: unknown) => object[];
+    constructor(check: (value: unknown) => value is Value, errors: (value: unknown) => object[]);
 }
 export {};

package/build/type/types/base.mjs

@@ -20,16 +20,14 @@ export class BaseNotImplemented extends Error {
 /** Base class for creating extension types. */
 export class Base {
     constructor() {
-        const validator = new BaseValidator(
-        // @ts-ignore TS 5.0.4 - unable to derive guard type
-        (value) => this.Check(value), (value) => this.Errors(value));
+        const validator = new BaseValidator((value) => this.Check(value), (value) => this.Errors(value));
         const configuration = {
             writable: false,
             configurable: false,
             enumerable: false
         };
         Object.defineProperty(this, '~kind', { ...configuration, value: 'Base' });
-        Object.defineProperty(this, '~standard', { ...configuration, value: validator });
+        Object.defineProperty(this, '~base', { ...configuration, value: validator });
     }
     /** Checks a value or returns false if invalid */
     Check(value) {
@@ -70,18 +68,5 @@ class BaseValidator {
     constructor(check, errors) {
         this.check = check;
         this.errors = errors;
-        this.vendor = 'typebox';
-        this.version = 1;
-        this.validate = (value) => {
-            return this.check(value)
-                ? this.Success(value)
-                : this.Failure(this.errors(value));
-        };
-    }
-    Success(value) {
-        return { value };
-    }
-    Failure(issues) {
-        return { issues };
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "A Runtime Type System for JavaScript",
-  "version": "1.0.26",
+  "version": "1.0.28",
   "keywords": [
     "typescript",
     "jsonschema"

package/readme.md

@@ -19,16 +19,14 @@
 ## Install
 
 ```bash
-$ npm install typebox --save                        # 1.0.0
-
-$ npm install @sinclair/typebox --save              # 0.34.x
+$ npm install typebox
 ```
 
 
 ## Usage
 
 ```typescript
-import Type, { type Static } from 'typebox'
+import Type from 'typebox'
 
 const T = Type.Object({                             // const T = {
   x: Type.Number(),                                 //   type: 'object',
@@ -40,7 +38,7 @@ const T = Type.Object({                             // const T = {
                                                     //   }
                                                     // }
 
-type T = Static<typeof T>                           // type T = {
+type T = Type.Static<typeof T>                      // type T = {
                                                     //   x: number,
                                                     //   y: number,
                                                     //   z: number
@@ -68,7 +66,7 @@ License: MIT
 
 ## Upgrade
 
-Refer to the following URL for information on upgrading from 0.34.x to 1.0.
+If upgrading from `@sinclair/typebox` refer to the 1.0 migration guide at the following URL.
 
 [Migration Guide](https://github.com/sinclairzx81/typebox/blob/main/changelog/1.0.0-migration.md)
 
@@ -76,7 +74,7 @@ Refer to the following URL for information on upgrading from 0.34.x to 1.0.
 
 ## Type
 
-[Documentation](https://sinclairzx81.github.io/typebox/#/docs/type/overview) | [Example](https://www.typescriptlang.org/play/?#code/JYWwDg9gTgLgBAFQJ5gKYBo4G84xauAZRgEMZgBjOAXzgDMoIQ4ByPNAIwgA8WAoPhQgA7AM7wEcALyJ8AOgDyHAFaoKMABQ44O3Xv0HDAeiNwhYidOx8d3AFyy0cgHIBXEB1RQNASkyGAwICTXXZUBxYIFTUYFnQbOCQHZCc3Dy9ffyDsoJCdKFQAR1dgAoATBwBtFl5MFiQ41gAvFgBdeJ0m5Pk0z28fHMHAvLgwRjRYYFRRByw+agGhpeW9EdtZ3HwI4Xc+lhoOlaPltcSNsO3dr33qQ+P77NOu7E20S-SoG4SHn+NTHWo31+wJ0IUBfDCiCsxDIlAAPGEIHREAA+EGg0yQyQyObo9EjexwHYfO54n4jJJEq5QUlk+4jZ7EvpAunHMFAA)
+[Documentation](https://sinclairzx81.github.io/typebox/#/docs/type/overview) | [Example](https://www.typescriptlang.org/play/#code/JYWwDg9gTgLgBAFQJ5gKZwGZQiOByGFVAIwgA88AoSgYwgDsBneBOAXkSIDoB5YgK1Q0YACgDecSVOkzZcuAHoFcOkxbs4YypLIAuTmi4A5AK4hiqKCICUAGnkPHspVMJp9eCAKEw8t7XBI+siGpuaWNvZO0Q4uklCoAI4mwAkAJvoA2ngU9nhIfvgAXngAuv6SRcHcYRZW1jGNcnFwYNhosMCojPpaAL4NTUPDisrSeppwbqge9GZ1eHB9FSOrjS2SQZPTs-OWi8sBa8exY1JV20S74VAHRycP0i1994+PLi+U04gaIahcAGUYABDGDAGgAHmmEAwiAAfCcXN9WBwtG90aMpBM5jcVhiHi0tji6nj8ccWhdiZZXmSRh8gA)
 
 TypeBox includes many functions to create Json Schema types. Each function returns a small Json Schema fragment that corresponds to a TypeScript type. TypeBox uses function composition to combine schema fragments into more complex types. It provides a set of functions that are used to model Json Schema schematics as well as a set of functions that model constructs native to JavaScript and TypeScript.
 
@@ -85,7 +83,7 @@ TypeBox includes many functions to create Json Schema types. Each function retur
 The following creates a Json Schema type and infers with Static.
 
 ```typescript
-import Type, { type Static } from 'typebox'
+import Type from 'typebox'
 
 const T = Type.Object({                             // const T = {
   x: Type.Number(),                                 //   type: 'object',
@@ -97,7 +95,7 @@ const T = Type.Object({                             // const T = {
                                                     //   }
                                                     // }
 
-type T = Static<typeof T>                           // type T = {
+type T = Type.Static<typeof T>                      // type T = {
                                                     //   x: number,
                                                     //   y: number,
                                                     //   z: number
@@ -110,16 +108,16 @@ type T = Static<typeof T>                           // type T = {
 
 ## Script
 
-[Documentation](https://sinclairzx81.github.io/typebox/#/docs/script/overview) | [Example](https://www.typescriptlang.org/play/?moduleResolution=99&target=99&jsx=0&module=199#code/JYWwDg9gTgLgBAFQJ5gKYBo4G84xauAZRgEMZgBjOAXzgDMoIQ4ByPNAIwgA8WAoPhQgA7AM7wEcALyJ8AOkIUowMDAAUAAxx84cbgC44wgK4gOqKJh1wkhk2YtXdALzunzUOH2oaAlLoDAoOCQ0LCggHoIuCExCWlsa3DklNTAqID2VEMWCA4AK1QKGBZ0JLSKyvTo3ShUAEdjYDqAE0MAbRZeTBYkUtZnFgBdMqqxqozdMEY0WGBUUUMscvHVsMmAg2xcfBz7DxYaUbWT0I3dW22svfcLQ+pj06eA87hXK93WfbuaFeeTjbUP7-VYZIGCETiIgJZBoBRKFTqHCSB5wLTWdoAaTgwGEcAA1qgkBA6IghoYEFihnAAD5GYwAGwZ3j8IIB0ViUMICWWbKeG2urDyhWKpWBfMqGzqjWaqDacE63VYfR6gxG4olaQ20wgs3ICyWGs1KVeW20xtBNSCJGESAA8nQOkaLesrcEcIKWN8oPcnC6Jm6gh7Pl7GQz7s7-cFXrpqZGo9Ugg94wndK9LubU6kY3AbfbHQqU6mc7pg2gbg4fUcvFns4HAmXsl8wxHayb63A423kq9k93wq93pn+yEc3mHU6R2cO6WduXm5XfTWp9GZx956Gma2V5EO12d4nAn2Dy8rUCT6ffnwstCZMQyJQADxZElEAB8IIyN+5Ml5F7gGxbN6tL0kyjwnhslzAXSJhgUWCYbO80Ggcy-4AdE1BAA)
+[Documentation](https://sinclairzx81.github.io/typebox/#/docs/script/overview) | [Example](https://www.typescriptlang.org/play/?moduleResolution=99&target=99&jsx=0&module=199#code/JYWwDg9gTgLgBAFQJ5gKZwGZQiOByGFVAIwgA88AoSgYwgDsBneBOAXkSIDoBlGqYGBgAKAAYBvOJThwyALjj0AriGKooAGikykC5avVbpcAF56VaqFIC+ogJQzHT5y9dv3zgPSe4dJi3Y4cWMPULDwp29HQjQFPAhiACtUGhg8DRCIrOzInxkoVABHJWACgBMFAG08Ci08JHT8EzwAXQycjpyomTBsNFhgVEYFYM6x8O7HeSC4GNQ4-Us8OGt28fW3SZ0R2aIFi3Vl1cyN07gt0x25-YMoI5Oz9cnrB8exqJfaBmY4HkDkNC8fiCESSVirOASYyVADScGA9DgAGtUEgIBhEC0FAhYS04AAfRRKAA2xMotgcb3GUT8Pz+HFGVI2k2u+ASyVS6VeTOykwKxVKqAqcGqtXwDTqzTa3J5EUmvQg-Rgg2GQRlsrCF2mknVGo8FxkAEN6EgAPIYKq6vWbPKuSSsvCLQ4rIzWjoGxz2vb4ZSk+5urq2px4q0B3LOY5hrIXXQzUNR85BxzGs0WkXxqMemRe2I+g53F3aBOapNOHPzPN+lYZsMekPFksRtYN9wXMxxlv60twFPmy2d1vd7O7XOO-NHV0D1xZmYO33E-1Tlx1otL8NOSNr9fVrfhz5zX7-bg8GCG5U0AA8c3RvwAfE8fAf6Wrd45JtMnVZCfPm7vJrHPwJIlSV-LdJnbQDvxJMlXxkD4gA)
 
-TypeBox is a type system designed to use Json Schema as an AST for runtime type representation. The Script function provides a full syntactic frontend to the type system and enables Json Schema to be constructed using native TypeScript syntax. TypeBox provides full static and runtime type safety for string-encoded types.
+TypeBox can translate TypeScript syntax into Json Schema. The Script function is a fully type-safe, syntactic frontend to the TypeBox type builder API, allowing Json Schema to be constructed and mapped using TypeScript type expressions encoded as strings.
 
 ### Example
 
 The following uses Script to construct and map Json Schema.
 
 ```typescript
-import Type, { type Static } from 'typebox'
+import Type from 'typebox'
 
 const T = Type.Script(`{ 
   x: number, 
@@ -162,7 +160,7 @@ const S = Type.Script({ T }, `{
                                                     //   }
                                                     // }
 
-type S = Static<typeof S>                           // type S = {
+type S = Type.Static<typeof S>                      // type S = {
                                                     //   x: number | null,
                                                     //   y: number | null,
                                                     //   z: number | null
@@ -175,7 +173,7 @@ type S = Static<typeof S>                           // type S = {
 
 [Documentation](https://sinclairzx81.github.io/typebox/#/docs/value/overview) | [Example](https://www.typescriptlang.org/play/?#code/JYWwDg9gTgLgBAFQJ5gKZwGZQiOByGFVAIwgA88AoUSWOANQEMAbAV3Sx30LVLIHoAbi3ZVKAYwgA7AM7wEcALyIiAOgDyxAFapxMABQBvSnDhkAXCrSqAcqxDFUUfQEoANCbhJLya3YdOrh6mAF4+av6Ozi6UAL4xlPz8cADCABa6ANaUEtJycACCSgwiqKrpWfoIbnCGpvUNjU1NSXCSsvAFlqQQzKiMUsUwUOyeFnAAjDXNM7Nzs57ecABMwXBhcADMcQmtAAqMUDKoOe35AELFTGxlB0eoVTV18y+mrWfw55bGpuNTrwDAfVWr9LFJ7FE1ktVkDYS8QV4wRCnGsNps4RjZgiNuCAlAdpjCVjkrFiqpyUA)
 
-The TypeBox Value module provides functions to Check and Parse JavaScript values. It also includes functions such as Clone, Repair, Encode, Decode, Diff and Patch which perform various structural operations on JavaScript values. This module provides unified support for both Json Schema and Standard Schema.
+The TypeBox Value module provides functions to Check and Parse JavaScript values. It also includes functions such as Clone, Repair, Encode, Decode, Diff and Patch which perform various structural operations on JavaScript values.
 
 The Value module is available via optional import.
 
@@ -218,7 +216,7 @@ const B = Value.Parse(T, {                          // const B: {
 
 [Documentation](https://sinclairzx81.github.io/typebox/#/docs/compile/overview) | [Example](https://www.typescriptlang.org/play/?#code/JYWwDg9gTgLgBAbzgYQuYAbApnAvnAMyjTgHIYBPMLAIwgA8B6AYzTEy1IChRJY4AKlRxES5YXXrcurAHYBneMjgBeFGw4AKIdQB0AeRoArLMxiakcK9Zu3bjRnDmKUALjgA1AIYZgAEy8YaAAeBFwAGkFDEzNQrit6dx0sXQA5AFcQGiwoTQBKSLsi4pKrB2tEwQysnPD4uAok4TTM7NyC0s6u8qtGqtba+oAvJr1qtvyuqZKeuBH+mqguXDy86fWNm3LcAD4dri5y5AALUwBrA+d4AEFVFF0T84tNjfKruGv3OghsL1k7mBQdJYeqVACMhReUNs9T6ACY6lZ5gBmZZ5A7lAAKXig8hBMggCngACE7shdNjcVhntDuo53sT3AhQe4IbT2WVHAl3LIBlBEQ13AiOezZn1eYsBSiRaKuXMeXy0TKZds7rp1UA)
 
-The TypeBox Compile module provides functions to convert types into high-performance validators. The compiler is tuned for fast compilation as well as fast validation. This module provides unified support to compile both Json Schema and Standard Schema, however performance optimizations are only possible with Json Schema.
+The TypeBox Compile module provides functions to convert types into high-performance validators. The compiler is tuned for fast compilation as well as fast validation.
 
 The Compile module is available via optional import.
 

package/build/schema/engine/_standard.d.mts

@@ -1,5 +0,0 @@
-import * as S from '../types/index.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildStandardSchemaV1(context: BuildContext, schema: S.XStandardSchemaV1, value: string): string;
-export declare function CheckStandardSchemaV1(context: CheckContext, schema: S.XStandardSchemaV1, value: unknown): boolean;
-export declare function ErrorStandardSchemaV1(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XStandardSchemaV1, value: unknown): boolean;

package/build/schema/engine/_standard.mjs

@@ -1,27 +0,0 @@
-// deno-fmt-ignore-file
-import * as V from './_externals.mjs';
-import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-export function BuildStandardSchemaV1(context, schema, value) {
-    return E.Not(E.HasPropertyKey(E.Call(E.Member(E.Member(V.CreateExternalVariable(schema), '~standard'), 'validate'), [value]), E.Constant('issues')));
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckStandardSchemaV1(context, schema, value) {
-    return !G.HasPropertyKey(schema['~standard'].validate(value), 'issues');
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export function ErrorStandardSchemaV1(context, schemaPath, instancePath, schema, value) {
-    const result = schema['~standard'].validate(value);
-    return !G.HasPropertyKey(result, 'issues') || context.AddError({
-        keyword: '~standard',
-        schemaPath,
-        instancePath,
-        params: { vendor: schema[`~standard`].vendor, issues: result.issues },
-    });
-}

package/build/schema/types/_standard.d.mts

@@ -1,14 +0,0 @@
-import type { XSchema } from './schema.mjs';
-export interface XStandardValidatorV1 {
-    version: 1;
-    vendor: string;
-    validate: (...args: unknown[]) => object;
-}
-export interface XStandardSchemaV1<Validator extends XStandardValidatorV1 = XStandardValidatorV1> {
-    '~standard': Validator;
-}
-/**
- * Returns true if the schema contains an '~standard` keyword
- * @specification 'StandardSchema'
- */
-export declare function IsStandardSchemaV1(value: XSchema): value is XStandardSchemaV1;

package/build/schema/types/_standard.mjs

@@ -1,19 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/**
- * Returns true if the schema contains an '~standard` keyword
- * @specification 'StandardSchema'
- */
-export function IsStandardSchemaV1(value) {
-    return Guard.HasPropertyKey(value, '~standard')
-        && Guard.IsObject(value["~standard"])
-        && Guard.HasPropertyKey(value['~standard'], 'version')
-        && Guard.HasPropertyKey(value['~standard'], 'vendor')
-        && Guard.HasPropertyKey(value['~standard'], 'validate')
-        && Guard.IsEqual(value['~standard'].version, 1)
-        && Guard.IsString(value['~standard'].vendor)
-        && Guard.IsFunction(value['~standard'].validate);
-}