typebox 1.0.25 → 1.0.27

package/build/guard/emit.d.mts

@@ -35,6 +35,7 @@ export declare function IsLessThan(left: string, right: string): string;
 export declare function IsLessEqualThan(left: string, right: string): string;
 export declare function IsGreaterEqualThan(left: string, right: string): string;
 export declare function StringGraphemeCount(value: string): string;
+export declare function Every(value: string, offset: string, params: [value: string, index: string], expression: string): string;
 export declare function Entries(value: string): string;
 export declare function Keys(value: string): string;
 export declare function HasPropertyKey(value: string, key: string): string;

package/build/guard/emit.mjs

@@ -108,6 +108,14 @@ export function StringGraphemeCount(value) {
     return `Guard.StringGraphemeCount(${value})`;
 }
 // --------------------------------------------------------------------------
+// Array
+// --------------------------------------------------------------------------
+export function Every(value, offset, params, expression) {
+    return G.IsEqual(offset, '0')
+        ? `${value}.every((${params[0]}, ${params[1]}) => ${expression})`
+        : `((value, callback) => { for(let index = ${offset}; index < value.length; index++) if (!callback(value[index], index)) return false; return true })(${value}, (${params[0]}, ${params[1]}) => ${expression})`;
+}
+// --------------------------------------------------------------------------
 // Objects
 // --------------------------------------------------------------------------
 export function Entries(value) {

package/build/guard/guard.d.mts

@@ -39,8 +39,8 @@ export declare function IsClassInstance(value: unknown): boolean;
 export declare function IsValueLike(value: unknown): value is bigint | boolean | null | number | string | undefined;
 /** Returns the number of Unicode Grapheme Clusters */
 export declare function StringGraphemeCount(value: string): number;
-export declare function Every<T>(value: T[], callback: (value: T, index: number) => boolean): boolean;
-export declare function EveryAll<T>(value: T[], callback: (value: T, index: number) => boolean): boolean;
+export declare function Every<T>(value: T[], offset: number, callback: (value: T, index: number) => boolean): boolean;
+export declare function EveryAll<T>(value: T[], offset: number, callback: (value: T, index: number) => boolean): boolean;
 /** Returns true if this value has this property key */
 export declare function HasPropertyKey<Key extends PropertyKey>(value: object, key: Key): value is {
     [_ in Key]: unknown;

package/build/guard/guard.mjs

@@ -136,12 +136,16 @@ export function StringGraphemeCount(value) {
 // --------------------------------------------------------------------------
 // Array
 // --------------------------------------------------------------------------
-export function Every(value, callback) {
-    return value.every(callback);
+export function Every(value, offset, callback) {
+    for (let index = offset; index < value.length; index++) {
+        if (!callback(value[index], index))
+            return false;
+    }
+    return true;
 }
-export function EveryAll(value, callback) {
+export function EveryAll(value, offset, callback) {
     let result = true;
-    for (let index = 0; index < value.length; index++) {
+    for (let index = offset; index < value.length; index++) {
         if (!callback(value[index], index))
             result = false;
     }

package/build/schema/engine/_refine.mjs

@@ -6,19 +6,19 @@ import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 export function BuildRefine(context, schema, value) {
     const refinements = V.CreateExternalVariable(schema['~refine'].map((refinement) => refinement));
-    return E.Call(E.Member(refinements, 'every'), [E.ArrowFunction(['refinement'], E.Call(E.Member('refinement', 'callback'), [value]))]);
+    return E.Every(refinements, E.Constant(0), ['refinement', '_'], E.Call(E.Member('refinement', 'callback'), [value]));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
 export function CheckRefine(context, schema, value) {
-    return G.Every(schema['~refine'], (refinement) => refinement.callback(value));
+    return G.Every(schema['~refine'], 0, (refinement, _) => refinement.callback(value));
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
 export function ErrorRefine(context, schemaPath, instancePath, schema, value) {
-    return G.EveryAll(schema['~refine'], (refinement, index) => {
+    return G.EveryAll(schema['~refine'], 0, (refinement, index) => {
         return refinement.callback(value) || context.AddError({
             keyword: '~refine',
             schemaPath,

package/build/schema/engine/additionalProperties.mjs

@@ -57,7 +57,7 @@ export function BuildAdditionalPropertiesStandard(context, schema, value) {
     const isKey = E.Call(E.Member(regexp, 'test'), ['key']);
     const addKey = context.AddKey('key');
     const guarded = context.UseUnevaluated() ? E.Or(isKey, E.And(isSchema, addKey)) : E.Or(isKey, isSchema);
-    return E.Call(E.Member(E.Keys(value), 'every'), [E.ArrowFunction(['key'], guarded)]);
+    return E.Every(E.Keys(value), E.Constant(0), ['key', '_'], guarded);
 }
 // ------------------------------------------------------------------
 // Build
@@ -72,7 +72,7 @@ export function BuildAdditionalProperties(context, schema, value) {
 // ------------------------------------------------------------------
 export function CheckAdditionalProperties(context, schema, value) {
     const regexp = new RegExp(GetPropertiesPattern(schema));
-    const isAdditionalProperties = G.Every(G.Keys(value), (key) => {
+    const isAdditionalProperties = G.Every(G.Keys(value), 0, (key) => {
         return regexp.test(key) ||
             (CheckSchema(context, schema.additionalProperties, value[key]) && context.AddKey(key));
     });
@@ -84,7 +84,7 @@ export function CheckAdditionalProperties(context, schema, value) {
 export function ErrorAdditionalProperties(context, schemaPath, instancePath, schema, value) {
     const regexp = new RegExp(GetPropertiesPattern(schema));
     const additionalProperties = [];
-    const isAdditionalProperties = G.EveryAll(G.Keys(value), (key) => {
+    const isAdditionalProperties = G.EveryAll(G.Keys(value), 0, (key) => {
         const nextSchemaPath = `${schemaPath}/additionalProperties`;
         const nextInstancePath = `${instancePath}/${key}`;
         const nextContext = new AccumulatedErrorContext(context.GetContext(), context.GetSchema());

package/build/schema/engine/dependencies.mjs

@@ -19,7 +19,7 @@ export function BuildDependencies(context, schema, value) {
 // ------------------------------------------------------------------
 export function CheckDependencies(context, schema, value) {
     const isLength = G.IsEqual(G.Keys(value).length, 0);
-    const isEvery = G.Every(G.Entries(schema.dependencies), ([key, schema]) => {
+    const isEvery = G.Every(G.Entries(schema.dependencies), 0, ([key, schema]) => {
         return !G.HasPropertyKey(value, key) || (G.IsArray(schema)
             ? schema.every((key) => G.HasPropertyKey(value, key))
             : CheckSchema(context, schema, value));
@@ -31,7 +31,7 @@ export function CheckDependencies(context, schema, value) {
 // ------------------------------------------------------------------
 export function ErrorDependencies(context, schemaPath, instancePath, schema, value) {
     const isLength = G.IsEqual(G.Keys(value).length, 0);
-    const isEvery = G.EveryAll(G.Entries(schema.dependencies), ([key, schema]) => {
+    const isEvery = G.EveryAll(G.Entries(schema.dependencies), 0, ([key, schema]) => {
         const nextSchemaPath = `${schemaPath}/dependencies/${key}`;
         return !G.HasPropertyKey(value, key) || (G.IsArray(schema)
             ? schema.every((dependency) => G.HasPropertyKey(value, dependency) || context.AddError({

package/build/schema/engine/dependentRequired.mjs

@@ -17,7 +17,7 @@ export function BuildDependentRequired(context, schema, value) {
 // ------------------------------------------------------------------
 export function CheckDependentRequired(context, schema, value) {
     const isLength = G.IsEqual(G.Keys(value).length, 0);
-    const isEvery = G.Every(G.Entries(schema.dependentRequired), ([key, keys]) => {
+    const isEvery = G.Every(G.Entries(schema.dependentRequired), 0, ([key, keys]) => {
         return !G.HasPropertyKey(value, key) ||
             keys.every((key) => G.HasPropertyKey(value, key));
     });
@@ -28,8 +28,8 @@ export function CheckDependentRequired(context, schema, value) {
 // ------------------------------------------------------------------
 export function ErrorDependentRequired(context, schemaPath, instancePath, schema, value) {
     const isLength = G.IsEqual(G.Keys(value).length, 0);
-    const isEveryEntry = G.EveryAll(G.Entries(schema.dependentRequired), ([key, keys]) => {
-        return !G.HasPropertyKey(value, key) || G.EveryAll(keys, (dependency) => G.HasPropertyKey(value, dependency) || context.AddError({
+    const isEveryEntry = G.EveryAll(G.Entries(schema.dependentRequired), 0, ([key, keys]) => {
+        return !G.HasPropertyKey(value, key) || G.EveryAll(keys, 0, (dependency) => G.HasPropertyKey(value, dependency) || context.AddError({
             keyword: 'dependentRequired',
             schemaPath,
             instancePath,

package/build/schema/engine/dependentSchemas.mjs

@@ -18,7 +18,7 @@ export function BuildDependentSchemas(context, schema, value) {
 // ------------------------------------------------------------------
 export function CheckDependentSchemas(context, schema, value) {
     const isLength = G.IsEqual(G.Keys(value).length, 0);
-    const isEvery = G.Every(G.Entries(schema.dependentSchemas), ([key, schema]) => {
+    const isEvery = G.Every(G.Entries(schema.dependentSchemas), 0, ([key, schema]) => {
         return !G.HasPropertyKey(value, key) ||
             CheckSchema(context, schema, value);
     });
@@ -29,7 +29,7 @@ export function CheckDependentSchemas(context, schema, value) {
 // ------------------------------------------------------------------
 export function ErrorDependentSchemas(context, schemaPath, instancePath, schema, value) {
     const isLength = G.IsEqual(G.Keys(value).length, 0);
-    const isEvery = G.EveryAll(G.Entries(schema.dependentSchemas), ([key, schema]) => {
+    const isEvery = G.EveryAll(G.Entries(schema.dependentSchemas), 0, ([key, schema]) => {
         const nextSchemaPath = `${schemaPath}/dependentSchemas/${key}`;
         return !G.HasPropertyKey(value, key) ||
             ErrorSchema(context, nextSchemaPath, instancePath, schema, value);

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;
@@ -15,16 +15,16 @@ function BuildItemsSized(context, schema, value) {
     }));
 }
 function CheckItemsSized(context, schema, value) {
-    return G.Every(schema.items, (schema, index) => {
-        return G.IsGreaterEqualThan(index, value.length)
+    return G.Every(schema.items, 0, (schema, index) => {
+        return G.IsLessEqualThan(value.length, index)
             || (CheckSchema(context, schema, value[index]) && context.AddIndex(index));
     });
 }
 function ErrorItemsSized(context, schemaPath, instancePath, schema, value) {
-    return G.EveryAll(schema.items, (schema, index) => {
+    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));
     });
 }
@@ -32,19 +32,22 @@ function ErrorItemsSized(context, schemaPath, instancePath, schema, value) {
 // ItemsUnsized
 // ------------------------------------------------------------------
 function BuildItemsUnsized(context, schema, value) {
+    const offset = S.IsPrefixItems(schema) ? schema.prefixItems.length : 0;
     const isSchema = BuildSchema(context, schema.items, 'element');
     const addIndex = context.AddIndex('index');
     const guarded = context.UseUnevaluated() ? E.And(isSchema, addIndex) : isSchema;
-    return E.Call(E.Member(value, 'every'), [E.ArrowFunction(['element', 'index'], guarded)]);
+    return E.Every(value, E.Constant(offset), ['element', 'index'], guarded);
 }
 function CheckItemsUnsized(context, schema, value) {
-    return G.Every(value, (element, index) => {
+    const offset = S.IsPrefixItems(schema) ? schema.prefixItems.length : 0;
+    return G.Every(value, offset, (element, index) => {
         return CheckSchema(context, schema.items, element)
             && context.AddIndex(index);
     });
 }
 function ErrorItemsUnsized(context, schemaPath, instancePath, schema, value) {
-    return G.EveryAll(value, (element, index) => {
+    const offset = S.IsPrefixItems(schema) ? schema.prefixItems.length : 0;
+    return G.EveryAll(value, offset, (element, index) => {
         const nextSchemaPath = `${schemaPath}/items`;
         const nextInstancePath = `${instancePath}/${index}`;
         return ErrorSchema(context, nextSchemaPath, nextInstancePath, schema.items, element)

package/build/schema/engine/patternProperties.mjs

@@ -12,16 +12,16 @@ export function BuildPatternProperties(context, schema, value) {
         const isSchema = BuildSchema(context, schema, 'value');
         const addKey = context.AddKey('key');
         const guarded = context.UseUnevaluated() ? E.Or(notKey, E.And(isSchema, addKey)) : E.Or(notKey, isSchema);
-        return E.Call(E.Member(E.Entries(value), 'every'), [E.ArrowFunction(['[key, value]'], guarded)]);
+        return E.Every(E.Entries(value), E.Constant(0), ['[key, value]', '_'], guarded);
     }));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
 export function CheckPatternProperties(context, schema, value) {
-    return G.Every(G.Entries(schema.patternProperties), ([pattern, schema]) => {
+    return G.Every(G.Entries(schema.patternProperties), 0, ([pattern, schema]) => {
         const regexp = new RegExp(pattern);
-        return G.Every(G.Entries(value), ([key, value]) => {
+        return G.Every(G.Entries(value), 0, ([key, value]) => {
             return !regexp.test(key) || CheckSchema(context, schema, value) && context.AddKey(key);
         });
     });
@@ -30,10 +30,10 @@ export function CheckPatternProperties(context, schema, value) {
 // Error
 // ------------------------------------------------------------------
 export function ErrorPatternProperties(context, schemaPath, instancePath, schema, value) {
-    return G.EveryAll(G.Entries(schema.patternProperties), ([pattern, schema]) => {
+    return G.EveryAll(G.Entries(schema.patternProperties), 0, ([pattern, schema]) => {
         const nextSchemaPath = `${schemaPath}/patternProperties/${pattern}`;
         const regexp = new RegExp(pattern);
-        return G.EveryAll(G.Entries(value), ([key, value]) => {
+        return G.EveryAll(G.Entries(value), 0, ([key, value]) => {
             const nextInstancePath = `${instancePath}/${key}`;
             const notKey = !regexp.test(key);
             return notKey || ErrorSchema(context, nextSchemaPath, nextInstancePath, schema, value) && context.AddKey(key);

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;
@@ -17,8 +17,8 @@ export function BuildPrefixItems(context, schema, value) {
 // Check
 // ------------------------------------------------------------------
 export function CheckPrefixItems(context, schema, value) {
-    return G.IsEqual(value.length, 0) || G.Every(schema.prefixItems, (schema, index) => {
-        return G.IsGreaterEqualThan(index, value.length)
+    return G.IsEqual(value.length, 0) || G.Every(schema.prefixItems, 0, (schema, index) => {
+        return G.IsLessEqualThan(value.length, index)
             || (CheckSchema(context, schema, value[index]) && context.AddIndex(index));
     });
 }
@@ -26,10 +26,10 @@ export function CheckPrefixItems(context, schema, value) {
 // Error
 // ------------------------------------------------------------------
 export function ErrorPrefixItems(context, schemaPath, instancePath, schema, value) {
-    return G.IsEqual(value.length, 0) || G.EveryAll(schema.prefixItems, (schema, index) => {
+    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/properties.mjs

@@ -49,7 +49,7 @@ export function BuildProperties(context, schema, value) {
 // ------------------------------------------------------------------
 export function CheckProperties(context, schema, value) {
     const required = S.IsRequired(schema) ? schema.required : [];
-    const isProperties = G.Every(G.Entries(schema.properties), ([key, schema]) => {
+    const isProperties = G.Every(G.Entries(schema.properties), 0, ([key, schema]) => {
         const isProperty = !G.HasPropertyKey(value, key) || (CheckSchema(context, schema, value[key]) && context.AddKey(key));
         return IsExactOptional(required, key)
             ? isProperty
@@ -62,7 +62,7 @@ export function CheckProperties(context, schema, value) {
 // ------------------------------------------------------------------
 export function ErrorProperties(context, schemaPath, instancePath, schema, value) {
     const required = S.IsRequired(schema) ? schema.required : [];
-    const isProperties = G.EveryAll(G.Entries(schema.properties), ([key, schema]) => {
+    const isProperties = G.EveryAll(G.Entries(schema.properties), 0, ([key, schema]) => {
         const nextSchemaPath = `${schemaPath}/properties/${key}`;
         const nextInstancePath = `${instancePath}/${key}`;
         // Defer error generation for IsExactOptional

package/build/schema/engine/propertyNames.mjs

@@ -12,14 +12,14 @@ export function BuildPropertyNames(context, schema, value) {
 // Check
 // ------------------------------------------------------------------
 export function CheckPropertyNames(context, schema, value) {
-    return G.Every(G.Keys(value), (key) => CheckSchema(context, schema.propertyNames, key));
+    return G.Every(G.Keys(value), 0, (key) => CheckSchema(context, schema.propertyNames, key));
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
 export function ErrorPropertyNames(context, schemaPath, instancePath, schema, value) {
     const propertyNames = [];
-    const isPropertyNames = G.EveryAll(G.Keys(value), (key) => {
+    const isPropertyNames = G.EveryAll(G.Keys(value), 0, (key) => {
         const nextInstancePath = `${instancePath}/${key}`;
         const nextSchemaPath = `${schemaPath}/propertyNames`;
         const nextContext = new AccumulatedErrorContext(context.GetContext(), context.GetSchema());

package/build/schema/engine/required.mjs

@@ -10,14 +10,14 @@ export function BuildRequired(context, schema, value) {
 // Check
 // ------------------------------------------------------------------
 export function CheckRequired(context, schema, value) {
-    return G.Every(schema.required, (key) => G.HasPropertyKey(value, key));
+    return G.Every(schema.required, 0, (key) => G.HasPropertyKey(value, key));
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
 export function ErrorRequired(context, schemaPath, instancePath, schema, value) {
     const requiredProperties = [];
-    const isRequired = G.EveryAll(schema.required, (key) => {
+    const isRequired = G.EveryAll(schema.required, 0, (key) => {
         const hasKey = G.HasPropertyKey(value, key);
         if (!hasKey)
             requiredProperties.push(key);

package/build/schema/engine/unevaluatedItems.mjs

@@ -10,7 +10,7 @@ export function BuildUnevaluatedItems(context, schema, value) {
     const hasIndex = E.Call(E.Member('indices', 'has'), ['index']);
     const isSchema = BuildSchema(context, schema.unevaluatedItems, 'value');
     const addIndex = E.Call(E.Member('context', 'AddIndex'), ['index']);
-    const isEvery = E.Call(E.Member(value, 'every'), [E.ArrowFunction(['value', 'index'], E.And(E.Or(hasIndex, isSchema), addIndex))]);
+    const isEvery = E.Every(value, E.Constant(0), ['value', 'index'], E.And(E.Or(hasIndex, isSchema), addIndex));
     return E.Call(E.ArrowFunction(['context'], E.Statements([
         E.ConstDeclaration('indices', indices),
         E.Return(isEvery)
@@ -21,7 +21,7 @@ export function BuildUnevaluatedItems(context, schema, value) {
 // ------------------------------------------------------------------
 export function CheckUnevaluatedItems(context, schema, value) {
     const indices = context.GetIndices();
-    return G.Every(value, (value, index) => {
+    return G.Every(value, 0, (value, index) => {
         return (indices.has(index) || CheckSchema(context, schema.unevaluatedItems, value))
             && context.AddIndex(index);
     });
@@ -32,7 +32,7 @@ export function CheckUnevaluatedItems(context, schema, value) {
 export function ErrorUnevaluatedItems(context, schemaPath, instancePath, schema, value) {
     const indices = context.GetIndices();
     const unevaluatedItems = [];
-    const isUnevaluatedItems = G.EveryAll(value, (value, index) => {
+    const isUnevaluatedItems = G.EveryAll(value, 0, (value, index) => {
         const nextContext = new AccumulatedErrorContext(context.GetContext(), context.GetSchema());
         const isEvaluatedItem = (indices.has(index) || ErrorSchema(nextContext, schemaPath, instancePath, schema.unevaluatedItems, value))
             && context.AddIndex(index);

package/build/schema/engine/unevaluatedProperties.mjs

@@ -10,7 +10,7 @@ export function BuildUnevaluatedProperties(context, schema, value) {
     const hasKey = E.Call(E.Member('keys', 'has'), ['key']);
     const addKey = E.Call(E.Member('context', 'AddKey'), ['key']);
     const isSchema = BuildSchema(context, schema.unevaluatedProperties, `value`);
-    const isEvery = E.Call(E.Member(E.Entries(value), 'every'), [E.ArrowFunction(['[key, value]'], E.Or(hasKey, E.And(isSchema, addKey)))]);
+    const isEvery = E.Every(E.Entries(value), E.Constant(0), ['[key, value]', '_'], E.Or(hasKey, E.And(isSchema, addKey)));
     return E.Call(E.ArrowFunction(['context'], E.Statements([
         E.ConstDeclaration('keys', keys),
         E.Return(isEvery)
@@ -21,7 +21,7 @@ export function BuildUnevaluatedProperties(context, schema, value) {
 // ------------------------------------------------------------------
 export function CheckUnevaluatedProperties(context, schema, value) {
     const keys = context.GetKeys();
-    return G.Every(G.Entries(value), ([key, value]) => {
+    return G.Every(G.Entries(value), 0, ([key, value]) => {
         return keys.has(key)
             || (CheckSchema(context, schema.unevaluatedProperties, value) && context.AddKey(key));
     });
@@ -32,7 +32,7 @@ export function CheckUnevaluatedProperties(context, schema, value) {
 export function ErrorUnevaluatedProperties(context, schemaPath, instancePath, schema, value) {
     const keys = context.GetKeys();
     const unevaluatedProperties = [];
-    const isUnevaluatedProperties = G.EveryAll(G.Entries(value), ([key, value]) => {
+    const isUnevaluatedProperties = G.EveryAll(G.Entries(value), 0, ([key, value]) => {
         const nextContext = new AccumulatedErrorContext(context.GetContext(), context.GetSchema());
         const isEvaluatedProperty = keys.has(key)
             || (ErrorSchema(nextContext, schemaPath, instancePath, schema.unevaluatedProperties, value) && context.AddKey(key));

package/build/schema/types/_refine.mjs

@@ -10,7 +10,7 @@ import { Guard } from '../../guard/index.mjs';
 export function IsRefine(value) {
     return Guard.HasPropertyKey(value, '~refine')
         && Guard.IsArray(value["~refine"])
-        && Guard.Every(value['~refine'], value => Guard.IsObject(value)
+        && Guard.Every(value['~refine'], 0, value => Guard.IsObject(value)
             && Guard.HasPropertyKey(value, 'callback')
             && Guard.HasPropertyKey(value, 'message')
             && Guard.IsFunction(value.callback)

package/build/type/types/base.mjs

@@ -20,7 +20,9 @@ export class BaseNotImplemented extends Error {
 /** Base class for creating extension types. */
 export class Base {
     constructor() {
-        const validator = new BaseValidator((value) => this.Check(value), (value) => this.Errors(value));
+        const validator = new BaseValidator(
+        // @ts-ignore TS 5.0.4 - unable to derive guard type
+        (value) => this.Check(value), (value) => this.Errors(value));
         const configuration = {
             writable: false,
             configurable: false,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "A Runtime Type System for JavaScript",
-  "version": "1.0.25",
+  "version": "1.0.27",
   "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.