typebox 1.0.25 → 1.0.26

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

@@ -15,13 +15,13 @@ function BuildItemsSized(context, schema, value) {
     }));
 }
 function CheckItemsSized(context, schema, value) {
-    return G.Every(schema.items, (schema, index) => {
+    return G.Every(schema.items, 0, (schema, index) => {
         return G.IsGreaterEqualThan(index, value.length)
             || (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)
@@ -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

@@ -17,7 +17,7 @@ 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.IsEqual(value.length, 0) || G.Every(schema.prefixItems, 0, (schema, index) => {
         return G.IsGreaterEqualThan(index, value.length)
             || (CheckSchema(context, schema, value[index]) && context.AddIndex(index));
     });
@@ -26,7 +26,7 @@ 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)

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.26",
   "keywords": [
     "typescript",
     "jsonschema"