@depup/typebox 1.1.23-depup.0 → 1.3.8-depup.0

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

@@ -1,5 +1,5 @@
 import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildBooleanSchema(_stack: Stack, _context: BuildContext, schema: boolean, _value: string): string;
-export declare function CheckBooleanSchema(_stack: Stack, _context: CheckContext, schema: boolean, _value: unknown): boolean;
-export declare function ErrorBooleanSchema(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: boolean, value: unknown): boolean;
+export declare function BuildSchemaBoolean(_stack: Stack, _context: BuildContext, schema: boolean, _value: string): string;
+export declare function CheckSchemaBoolean(_stack: Stack, _context: CheckContext, schema: boolean, _value: unknown): boolean;
+export declare function ErrorSchemaBoolean(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: boolean, value: unknown): boolean;

package/build/schema/engine/boolean.mjs

@@ -3,20 +3,20 @@ import { EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildBooleanSchema(_stack, _context, schema, _value) {
+export function BuildSchemaBoolean(_stack, _context, schema, _value) {
     return schema ? E.Constant(true) : E.Constant(false);
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckBooleanSchema(_stack, _context, schema, _value) {
+export function CheckSchemaBoolean(_stack, _context, schema, _value) {
     return schema;
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorBooleanSchema(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckBooleanSchema(stack, context, schema, value) || context.AddError({
+export function ErrorSchemaBoolean(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckSchemaBoolean(stack, context, schema, value) || context.AddError({
         keyword: 'boolean',
         schemaPath,
         instancePath,

package/build/schema/engine/contains.mjs

@@ -12,13 +12,24 @@ function IsValid(schema) {
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
+function BuildContainsStandard(stack, context, schema, value) {
+    const [item, index] = [Unique(), Unique()];
+    const isLength = E.Not(E.IsEqual(E.Member(value, 'length'), E.Constant(0)));
+    const isSome = E.SomeAll(value, [item, index], E.And(BuildSchema(stack, context, schema.contains, item), context.AddIndex(index)));
+    return E.And(isLength, isSome);
+}
+function BuildContainsFast(stack, context, schema, value) {
+    const [item] = [Unique()];
+    const isLength = E.Not(E.IsEqual(E.Member(value, 'length'), E.Constant(0)));
+    const isSome = E.Some(value, [item, '_'], BuildSchema(stack, context, schema.contains, item));
+    return E.And(isLength, isSome);
+}
 export function BuildContains(stack, context, schema, value) {
     if (!IsValid(schema))
         return E.Constant(true);
-    const item = Unique();
-    const isLength = E.Not(E.IsEqual(E.Member(value, 'length'), E.Constant(0)));
-    const isSome = E.Call(E.Member(value, 'some'), [E.ArrowFunction([item], BuildSchema(stack, context, schema.contains, item))]);
-    return E.And(isLength, isSome);
+    return context.UseUnevaluated()
+        ? BuildContainsStandard(stack, context, schema, value)
+        : BuildContainsFast(stack, context, schema, value);
 }
 // ------------------------------------------------------------------
 // Check
@@ -26,8 +37,9 @@ export function BuildContains(stack, context, schema, value) {
 export function CheckContains(stack, context, schema, value) {
     if (!IsValid(schema))
         return true;
-    return !G.IsEqual(value.length, 0) &&
-        value.some((item) => CheckSchema(stack, context, schema.contains, item));
+    return !G.IsEqual(value.length, 0) && G.SomeAll(value, (item, index) => {
+        return CheckSchema(stack, context, schema.contains, item) && context.AddIndex(index);
+    });
 }
 // ------------------------------------------------------------------
 // Error

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

@@ -0,0 +1,6 @@
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildDynamicRef(stack: Stack, context: BuildContext, schema: Schema.XDynamicRef, value: string): string;
+export declare function CheckDynamicRef(stack: Stack, context: CheckContext, schema: Schema.XDynamicRef, value: unknown): boolean;
+export declare function ErrorDynamicRef(stack: Stack, context: ErrorContext, _schemaPath: string, instancePath: string, schema: Schema.XDynamicRef, value: unknown): boolean;

package/build/schema/engine/dynamicRef.mjs

@@ -0,0 +1,25 @@
+// deno-fmt-ignore-file
+import * as Functions from './_functions.mjs';
+import * as Schema from '../types/index.mjs';
+import { CheckSchema, ErrorSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildDynamicRef(stack, context, schema, value) {
+    const target = stack.DynamicRef(schema) ?? false;
+    return Functions.CreateFunction(stack, context, target, value);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckDynamicRef(stack, context, schema, value) {
+    const target = stack.DynamicRef(schema) ?? false;
+    return (Schema.IsSchema(target) && CheckSchema(stack, context, target, value));
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorDynamicRef(stack, context, _schemaPath, instancePath, schema, value) {
+    const target = stack.DynamicRef(schema) ?? false;
+    return (Schema.IsSchema(target) && ErrorSchema(stack, context, '#', instancePath, target, value));
+}

package/build/schema/engine/enum.mjs

@@ -16,7 +16,7 @@ export function BuildEnum(_stack, _context, schema, value) {
 // Check
 // ------------------------------------------------------------------
 export function CheckEnum(_stack, _context, schema, value) {
-    return schema.enum.some(option => G.IsValueLike(option)
+    return G.Some(schema.enum, option => G.IsValueLike(option)
         ? G.IsEqual(value, option)
         : G.IsDeepEqual(value, option));
 }

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

@@ -1,6 +1,5 @@
 export * from './_context.mjs';
 export * from './_externals.mjs';
-export * from './_guard.mjs';
 export * from './_functions.mjs';
 export * from './_reducer.mjs';
 export * from './_refine.mjs';

package/build/schema/engine/index.mjs

@@ -3,7 +3,6 @@
 // ------------------------------------------------------------------
 export * from './_context.mjs';
 export * from './_externals.mjs';
-export * from './_guard.mjs';
 export * from './_functions.mjs';
 export * from './_reducer.mjs';
 export * from './_refine.mjs';

package/build/schema/engine/items.mjs

@@ -5,15 +5,26 @@ import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from
 // ------------------------------------------------------------------
 // ItemsSized
 // ------------------------------------------------------------------
-function BuildItemsSized(stack, context, schema, value) {
+function BuildItemsSizedStandard(stack, context, schema, value) {
     return E.ReduceAnd(schema.items.map((schema, index) => {
         const isLength = E.IsLessEqualThan(E.Member(value, 'length'), E.Constant(index));
         const isSchema = BuildSchemaPushStack(stack, context, schema, `${value}[${index}]`);
         const addIndex = context.AddIndex(E.Constant(index));
-        const guarded = context.UseUnevaluated() ? E.And(isSchema, addIndex) : isSchema;
-        return E.Or(isLength, guarded);
+        return E.Or(isLength, E.And(isSchema, addIndex));
     }));
 }
+function BuildItemsSizedFast(stack, context, schema, value) {
+    return E.ReduceAnd(schema.items.map((schema, index) => {
+        const isLength = E.IsLessEqualThan(E.Member(value, 'length'), E.Constant(index));
+        const isSchema = BuildSchemaPushStack(stack, context, schema, `${value}[${index}]`);
+        return E.Or(isLength, isSchema);
+    }));
+}
+function BuildItemsSized(stack, context, schema, value) {
+    return context.UseUnevaluated()
+        ? BuildItemsSizedStandard(stack, context, schema, value)
+        : BuildItemsSizedFast(stack, context, schema, value);
+}
 function CheckItemsSized(stack, context, schema, value) {
     return G.Every(schema.items, 0, (schema, index) => {
         return G.IsLessEqualThan(value.length, index)
@@ -31,12 +42,21 @@ function ErrorItemsSized(stack, context, schemaPath, instancePath, schema, value
 // ------------------------------------------------------------------
 // ItemsUnsized
 // ------------------------------------------------------------------
-function BuildItemsUnsized(stack, context, schema, value) {
+function BuildItemsUnsizedStandard(stack, context, schema, value) {
     const offset = Schema.IsPrefixItems(schema) ? schema.prefixItems.length : 0;
     const isSchema = BuildSchemaPushStack(stack, context, schema.items, 'element');
     const addIndex = context.AddIndex('index');
-    const guarded = context.UseUnevaluated() ? E.And(isSchema, addIndex) : isSchema;
-    return E.Every(value, E.Constant(offset), ['element', 'index'], guarded);
+    return E.Every(value, E.Constant(offset), ['element', 'index'], E.And(isSchema, addIndex));
+}
+function BuildItemsUnsizedFast(stack, context, schema, value) {
+    const offset = Schema.IsPrefixItems(schema) ? schema.prefixItems.length : 0;
+    const isSchema = BuildSchemaPushStack(stack, context, schema.items, 'element');
+    return E.Every(value, E.Constant(offset), ['element', 'index'], isSchema);
+}
+function BuildItemsUnsized(stack, context, schema, value) {
+    return context.UseUnevaluated()
+        ? BuildItemsUnsizedStandard(stack, context, schema, value)
+        : BuildItemsUnsizedFast(stack, context, schema, value);
 }
 function CheckItemsUnsized(stack, context, schema, value) {
     const offset = Schema.IsPrefixItems(schema) ? schema.prefixItems.length : 0;

package/build/schema/engine/maxContains.mjs

@@ -15,8 +15,8 @@ function IsValid(schema) {
 export function BuildMaxContains(stack, context, schema, value) {
     if (!IsValid(schema))
         return E.Constant(true);
-    const [result, item] = [Unique(), Unique()];
-    const count = E.Call(E.Member(value, 'reduce'), [E.ArrowFunction([result, item], E.Ternary(BuildSchema(stack, context, schema.contains, item), E.PrefixIncrement(result), result)), E.Constant(0)]);
+    const [item] = [Unique()];
+    const count = E.Counted(value, [item, '_'], BuildSchema(stack, context, schema.contains, item));
     return E.IsLessEqualThan(count, E.Constant(schema.maxContains));
 }
 // ------------------------------------------------------------------
@@ -25,7 +25,7 @@ export function BuildMaxContains(stack, context, schema, value) {
 export function CheckMaxContains(stack, context, schema, value) {
     if (!IsValid(schema))
         return true;
-    const count = value.reduce((result, item) => CheckSchema(stack, context, schema.contains, item) ? ++result : result, 0);
+    const count = G.Counted(value, (item) => CheckSchema(stack, context, schema.contains, item));
     return G.IsLessEqualThan(count, schema.maxContains);
 }
 // ------------------------------------------------------------------

package/build/schema/engine/minContains.mjs

@@ -12,12 +12,22 @@ function IsValid(schema) {
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
+function BuildMinContainsStandard(stack, context, schema, value) {
+    const [item, index] = [Unique(), Unique()];
+    const count = E.Counted(value, [item, index], E.And(BuildSchema(stack, context, schema.contains, item), context.AddIndex(index)));
+    return E.IsGreaterEqualThan(count, E.Constant(schema.minContains));
+}
+function BuildMinContainsFast(stack, context, schema, value) {
+    const [item] = [Unique()];
+    const count = E.Counted(value, [item, '_'], BuildSchema(stack, context, schema.contains, item));
+    return E.IsGreaterEqualThan(count, E.Constant(schema.minContains));
+}
 export function BuildMinContains(stack, context, schema, value) {
     if (!IsValid(schema))
         return E.Constant(true);
-    const [result, item] = [Unique(), Unique()];
-    const count = E.Call(E.Member(value, 'reduce'), [E.ArrowFunction([result, item], E.Ternary(BuildSchema(stack, context, schema.contains, item), E.PrefixIncrement(result), result)), E.Constant(0)]);
-    return E.IsGreaterEqualThan(count, E.Constant(schema.minContains));
+    return context.UseUnevaluated()
+        ? BuildMinContainsStandard(stack, context, schema, value)
+        : BuildMinContainsFast(stack, context, schema, value);
 }
 // ------------------------------------------------------------------
 // Check
@@ -25,7 +35,7 @@ export function BuildMinContains(stack, context, schema, value) {
 export function CheckMinContains(stack, context, schema, value) {
     if (!IsValid(schema))
         return true;
-    const count = value.reduce((result, item) => CheckSchema(stack, context, schema.contains, item) ? ++result : result, 0);
+    const count = G.Counted(value, (item, index) => CheckSchema(stack, context, schema.contains, item) && context.AddIndex(index));
     return G.IsGreaterEqualThan(count, schema.minContains);
 }
 // ------------------------------------------------------------------

package/build/schema/engine/not.mjs

@@ -6,14 +6,16 @@ import { BuildSchema, CheckSchema } from './schema.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-function BuildNotUnevaluated(stack, context, schema, value) {
+function BuildNotStandard(stack, context, schema, value) {
     return Reducer(stack, context, [schema.not], value, E.Not(E.IsEqual(E.Member('results', 'length'), E.Constant(1))));
 }
 function BuildNotFast(stack, context, schema, value) {
     return E.Not(BuildSchema(stack, context, schema.not, value));
 }
 export function BuildNot(stack, context, schema, value) {
-    return context.UseUnevaluated() ? BuildNotUnevaluated(stack, context, schema, value) : BuildNotFast(stack, context, schema, value);
+    return context.UseUnevaluated()
+        ? BuildNotStandard(stack, context, schema, value)
+        : BuildNotFast(stack, context, schema, value);
 }
 // ------------------------------------------------------------------
 // Check

package/build/schema/engine/oneOf.mjs

@@ -3,22 +3,23 @@ import { CheckContext, AccumulatedErrorContext } from './_context.mjs';
 import { Reducer } from './_reducer.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+import { Unique } from './_unique.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-function BuildOneOfUnevaluated(stack, context, schema, value) {
+function BuildOneOfStandard(stack, context, schema, value) {
     return Reducer(stack, context, schema.oneOf, value, E.IsEqual(E.Member('results', 'length'), E.Constant(1)));
 }
 function BuildOneOfFast(stack, context, schema, value) {
+    const [result] = [Unique()];
     const results = E.ArrayLiteral(schema.oneOf.map((schema) => BuildSchema(stack, context, schema, value)));
-    const count = E.Call(E.Member(results, 'reduce'), [
-        E.ArrowFunction(['count', 'result'], E.Ternary(E.IsEqual('result', E.Constant(true)), E.PrefixIncrement('count'), 'count')),
-        E.Constant(0),
-    ]);
+    const count = E.Counted(results, [result, '_'], E.IsEqual(result, E.Constant(true)));
     return E.IsEqual(count, E.Constant(1));
 }
 export function BuildOneOf(stack, context, schema, value) {
-    return context.UseUnevaluated() ? BuildOneOfUnevaluated(stack, context, schema, value) : BuildOneOfFast(stack, context, schema, value);
+    return context.UseUnevaluated()
+        ? BuildOneOfStandard(stack, context, schema, value)
+        : BuildOneOfFast(stack, context, schema, value);
 }
 // ------------------------------------------------------------------
 // Check

package/build/schema/engine/recursiveRef.mjs

@@ -6,20 +6,20 @@ import { CheckSchema, ErrorSchema } from './schema.mjs';
 // Build
 // ------------------------------------------------------------------
 export function BuildRecursiveRef(stack, context, schema, value) {
-    const target = stack.RecursiveRef(schema.$recursiveRef) ?? false;
+    const target = stack.RecursiveRef(schema) ?? false;
     return Functions.CreateFunction(stack, context, target, value);
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
 export function CheckRecursiveRef(stack, context, schema, value) {
-    const target = stack.RecursiveRef(schema.$recursiveRef) ?? false;
+    const target = stack.RecursiveRef(schema) ?? false;
     return (Schema.IsSchema(target) && CheckSchema(stack, context, target, value));
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
 export function ErrorRecursiveRef(stack, context, _schemaPath, instancePath, schema, value) {
-    const target = stack.RecursiveRef(schema.$recursiveRef) ?? false;
+    const target = stack.RecursiveRef(schema) ?? false;
     return (Schema.IsSchema(target) && ErrorSchema(stack, context, '#', instancePath, target, value));
 }

package/build/schema/engine/ref.mjs

@@ -5,7 +5,7 @@ import { CheckContext, AccumulatedErrorContext } from './_context.mjs';
 import { EmitGuard as E } from '../../guard/index.mjs';
 import { CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
-// BuildRefStandard
+// BuildRef
 // ------------------------------------------------------------------
 function BuildRefStandard(stack, context, target, value) {
     const interior = E.ArrowFunction(['context', 'value'], Functions.CreateFunction(stack, context, target, 'value'));
@@ -17,17 +17,11 @@ function BuildRefStandard(stack, context, target, value) {
     ]));
     return E.Call(exterior, ['context', value]);
 }
-// ------------------------------------------------------------------
-// BuildRefStandard
-// ------------------------------------------------------------------
 function BuildRefFast(stack, context, target, value) {
     return Functions.CreateFunction(stack, context, target, value);
 }
-// ------------------------------------------------------------------
-// BuildRef
-// ------------------------------------------------------------------
 export function BuildRef(stack, context, schema, value) {
-    const target = stack.Ref(schema.$ref) ?? false;
+    const target = stack.Ref(schema) ?? false;
     return context.UseUnevaluated()
         ? BuildRefStandard(stack, context, target, value)
         : BuildRefFast(stack, context, target, value);
@@ -36,7 +30,7 @@ export function BuildRef(stack, context, schema, value) {
 // Check
 // ------------------------------------------------------------------
 export function CheckRef(stack, context, schema, value) {
-    const target = stack.Ref(schema.$ref) ?? false;
+    const target = stack.Ref(schema) ?? false;
     const nextContext = new CheckContext();
     const result = (Schema.IsSchema(target) && CheckSchema(stack, nextContext, target, value));
     if (result)
@@ -47,7 +41,7 @@ export function CheckRef(stack, context, schema, value) {
 // Error
 // ------------------------------------------------------------------
 export function ErrorRef(stack, context, _schemaPath, instancePath, schema, value) {
-    const target = stack.Ref(schema.$ref) ?? false;
+    const target = stack.Ref(schema) ?? false;
     const nextContext = new AccumulatedErrorContext();
     const result = (Schema.IsSchema(target) && ErrorSchema(stack, nextContext, '#', instancePath, target, value));
     if (result)

package/build/schema/engine/schema.mjs

@@ -1,18 +1,18 @@
 // deno-fmt-ignore-file
 import * as Schema from '../types/index.mjs';
 import { BuildRefine, CheckRefine, ErrorRefine } from './_refine.mjs';
-import { BuildGuard, CheckGuard, ErrorGuard } from './_guard.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 import { BuildAdditionalItems, CheckAdditionalItems, ErrorAdditionalItems } from './additionalItems.mjs';
 import { BuildAdditionalProperties, CheckAdditionalProperties, ErrorAdditionalProperties } from './additionalProperties.mjs';
 import { BuildAllOf, CheckAllOf, ErrorAllOf } from './allOf.mjs';
 import { BuildAnyOf, CheckAnyOf, ErrorAnyOf } from './anyOf.mjs';
-import { BuildBooleanSchema, CheckBooleanSchema, ErrorBooleanSchema } from './boolean.mjs';
+import { BuildSchemaBoolean, CheckSchemaBoolean, ErrorSchemaBoolean } from './boolean.mjs';
 import { BuildConst, CheckConst, ErrorConst } from './const.mjs';
 import { BuildContains, CheckContains, ErrorContains } from './contains.mjs';
 import { BuildDependencies, CheckDependencies, ErrorDependencies } from './dependencies.mjs';
 import { BuildDependentRequired, CheckDependentRequired, ErrorDependentRequired } from './dependentRequired.mjs';
 import { BuildDependentSchemas, CheckDependentSchemas, ErrorDependentSchemas } from './dependentSchemas.mjs';
+import { BuildDynamicRef, CheckDynamicRef, ErrorDynamicRef } from './dynamicRef.mjs';
 import { BuildEnum, CheckEnum, ErrorEnum } from './enum.mjs';
 import { BuildExclusiveMaximum, CheckExclusiveMaximum, ErrorExclusiveMaximum } from './exclusiveMaximum.mjs';
 import { BuildExclusiveMinimum, CheckExclusiveMinimum, ErrorExclusiveMinimum } from './exclusiveMinimum.mjs';
@@ -49,7 +49,7 @@ import { BuildUniqueItems, CheckUniqueItems, ErrorUniqueItems } from './uniqueIt
 // ----------------------------------------------------------------
 function HasTypeName(schema, typename) {
     return Schema.IsType(schema) &&
-        (G.IsArray(schema.type) && schema.type.includes(typename) ||
+        (G.IsArray(schema.type) && G.IsGreaterThan(schema.type.length, 0) && G.Every(schema.type, 0, type => G.IsEqual(type, typename)) ||
             G.IsEqual(schema.type, typename));
 }
 // ----------------------------------------------------------------
@@ -125,8 +125,8 @@ export function BuildSchemaPushStack(stack, context, schema, value) {
 export function BuildSchema(stack, context, schema, value) {
     stack.Push(schema);
     const conditions = [];
-    if (Schema.IsBooleanSchema(schema))
-        return BuildBooleanSchema(stack, context, schema, value);
+    if (Schema.IsSchemaBoolean(schema))
+        return BuildSchemaBoolean(stack, context, schema, value);
     if (Schema.IsType(schema))
         conditions.push(BuildType(stack, context, schema, value));
     if (HasObjectKeywords(schema)) {
@@ -209,12 +209,12 @@ export function BuildSchema(stack, context, schema, value) {
         const guarded = E.Or(E.Not(E.Or(E.IsNumber(value), E.IsBigInt(value))), reduced);
         conditions.push(HasNumberType(schema) ? reduced : guarded);
     }
-    if (Schema.IsRecursiveRef(schema))
-        conditions.push(BuildRecursiveRef(stack, context, schema, value));
     if (Schema.IsRef(schema))
         conditions.push(BuildRef(stack, context, schema, value));
-    if (Schema.IsGuard(schema))
-        conditions.push(BuildGuard(stack, context, schema, value));
+    if (Schema.IsRecursiveRef(schema))
+        conditions.push(BuildRecursiveRef(stack, context, schema, value));
+    if (Schema.IsDynamicRef(schema))
+        conditions.push(BuildDynamicRef(stack, context, schema, value));
     if (Schema.IsConst(schema))
         conditions.push(BuildConst(stack, context, schema, value));
     if (Schema.IsEnum(schema))
@@ -247,7 +247,7 @@ export function CheckSchemaPushStack(stack, context, schema, value) {
 }
 export function CheckSchema(stack, context, schema, value) {
     stack.Push(schema);
-    const result = Schema.IsBooleanSchema(schema) ? CheckBooleanSchema(stack, context, schema, value) : ((!Schema.IsType(schema) || CheckType(stack, context, schema, value)) &&
+    const result = Schema.IsSchemaBoolean(schema) ? CheckSchemaBoolean(stack, context, schema, value) : ((!Schema.IsType(schema) || CheckType(stack, context, schema, value)) &&
         (!(G.IsObject(value) && !G.IsArray(value)) || ((!Schema.IsRequired(schema) || CheckRequired(stack, context, schema, value)) &&
             (!Schema.IsAdditionalProperties(schema) || CheckAdditionalProperties(stack, context, schema, value)) &&
             (!Schema.IsDependencies(schema) || CheckDependencies(stack, context, schema, value)) &&
@@ -276,9 +276,9 @@ export function CheckSchema(stack, context, schema, value) {
             (!Schema.IsMaximum(schema) || CheckMaximum(stack, context, schema, value)) &&
             (!Schema.IsMinimum(schema) || CheckMinimum(stack, context, schema, value)) &&
             (!Schema.IsMultipleOf(schema) || CheckMultipleOf(stack, context, schema, value)))) &&
-        (!Schema.IsRecursiveRef(schema) || CheckRecursiveRef(stack, context, schema, value)) &&
         (!Schema.IsRef(schema) || CheckRef(stack, context, schema, value)) &&
-        (!Schema.IsGuard(schema) || CheckGuard(stack, context, schema, value)) &&
+        (!Schema.IsRecursiveRef(schema) || CheckRecursiveRef(stack, context, schema, value)) &&
+        (!Schema.IsDynamicRef(schema) || CheckDynamicRef(stack, context, schema, value)) &&
         (!Schema.IsConst(schema) || CheckConst(stack, context, schema, value)) &&
         (!Schema.IsEnum(schema) || CheckEnum(stack, context, schema, value)) &&
         (!Schema.IsIf(schema) || CheckIf(stack, context, schema, value)) &&
@@ -300,7 +300,7 @@ export function ErrorSchemaPushStack(stack, context, schemaPath, instancePath, s
 }
 export function ErrorSchema(stack, context, schemaPath, instancePath, schema, value) {
     stack.Push(schema);
-    const result = (Schema.IsBooleanSchema(schema)) ? ErrorBooleanSchema(stack, context, schemaPath, instancePath, schema, value) : (!!(+(!Schema.IsType(schema) || ErrorType(stack, context, schemaPath, instancePath, schema, value)) &
+    const result = (Schema.IsSchemaBoolean(schema)) ? ErrorSchemaBoolean(stack, context, schemaPath, instancePath, schema, value) : (!!(+(!Schema.IsType(schema) || ErrorType(stack, context, schemaPath, instancePath, schema, value)) &
         +(!(G.IsObject(value) && !G.IsArray(value)) || !!(+(!Schema.IsRequired(schema) || ErrorRequired(stack, context, schemaPath, instancePath, schema, value)) &
             +(!Schema.IsAdditionalProperties(schema) || ErrorAdditionalProperties(stack, context, schemaPath, instancePath, schema, value)) &
             +(!Schema.IsDependencies(schema) || ErrorDependencies(stack, context, schemaPath, instancePath, schema, value)) &
@@ -329,9 +329,9 @@ export function ErrorSchema(stack, context, schemaPath, instancePath, schema, va
             +(!Schema.IsMaximum(schema) || ErrorMaximum(stack, context, schemaPath, instancePath, schema, value)) &
             +(!Schema.IsMinimum(schema) || ErrorMinimum(stack, context, schemaPath, instancePath, schema, value)) &
             +(!Schema.IsMultipleOf(schema) || ErrorMultipleOf(stack, context, schemaPath, instancePath, schema, value)))) &
-        +(!Schema.IsRecursiveRef(schema) || ErrorRecursiveRef(stack, context, schemaPath, instancePath, schema, value)) &
         +(!Schema.IsRef(schema) || ErrorRef(stack, context, schemaPath, instancePath, schema, value)) &
-        +(!Schema.IsGuard(schema) || ErrorGuard(stack, context, schemaPath, instancePath, schema, value)) &
+        +(!Schema.IsRecursiveRef(schema) || ErrorRecursiveRef(stack, context, schemaPath, instancePath, schema, value)) &
+        +(!Schema.IsDynamicRef(schema) || ErrorDynamicRef(stack, context, schemaPath, instancePath, schema, value)) &
         +(!Schema.IsConst(schema) || ErrorConst(stack, context, schemaPath, instancePath, schema, value)) &
         +(!Schema.IsEnum(schema) || ErrorEnum(stack, context, schemaPath, instancePath, schema, value)) &
         +(!Schema.IsIf(schema) || ErrorIf(stack, context, schemaPath, instancePath, schema, value)) &

package/build/schema/engine/type.mjs

@@ -14,15 +14,13 @@ function BuildTypeName(_stack, _context, type, value) {
                         G.IsEqual(type, 'null') ? E.IsNull(value) :
                             G.IsEqual(type, 'string') ? E.IsString(value) :
                                 // xschema
-                                G.IsEqual(type, 'asyncIterator') ? E.IsAsyncIterator(value) :
-                                    G.IsEqual(type, 'bigint') ? E.IsBigInt(value) :
-                                        G.IsEqual(type, 'constructor') ? E.IsConstructor(value) :
-                                            G.IsEqual(type, 'function') ? E.IsFunction(value) :
-                                                G.IsEqual(type, 'iterator') ? E.IsIterator(value) :
-                                                    G.IsEqual(type, 'symbol') ? E.IsSymbol(value) :
-                                                        G.IsEqual(type, 'undefined') ? E.IsUndefined(value) :
-                                                            G.IsEqual(type, 'void') ? E.IsUndefined(value) :
-                                                                E.Constant(true));
+                                G.IsEqual(type, 'bigint') ? E.IsBigInt(value) :
+                                    G.IsEqual(type, 'constructor') ? E.IsConstructor(value) :
+                                        G.IsEqual(type, 'function') ? E.IsFunction(value) :
+                                            G.IsEqual(type, 'symbol') ? E.IsSymbol(value) :
+                                                G.IsEqual(type, 'undefined') ? E.IsUndefined(value) :
+                                                    G.IsEqual(type, 'void') ? E.IsUndefined(value) :
+                                                        E.Constant(true));
 }
 function CheckTypeName(_stack, _context, type, _schema, value) {
     return (
@@ -35,15 +33,13 @@ function CheckTypeName(_stack, _context, type, _schema, value) {
                         G.IsEqual(type, 'null') ? G.IsNull(value) :
                             G.IsEqual(type, 'string') ? G.IsString(value) :
                                 // xschema
-                                G.IsEqual(type, 'asyncIterator') ? G.IsAsyncIterator(value) :
-                                    G.IsEqual(type, 'bigint') ? G.IsBigInt(value) :
-                                        G.IsEqual(type, 'constructor') ? G.IsConstructor(value) :
-                                            G.IsEqual(type, 'function') ? G.IsFunction(value) :
-                                                G.IsEqual(type, 'iterator') ? G.IsIterator(value) :
-                                                    G.IsEqual(type, 'symbol') ? G.IsSymbol(value) :
-                                                        G.IsEqual(type, 'undefined') ? G.IsUndefined(value) :
-                                                            G.IsEqual(type, 'void') ? G.IsUndefined(value) :
-                                                                true);
+                                G.IsEqual(type, 'bigint') ? G.IsBigInt(value) :
+                                    G.IsEqual(type, 'constructor') ? G.IsConstructor(value) :
+                                        G.IsEqual(type, 'function') ? G.IsFunction(value) :
+                                            G.IsEqual(type, 'symbol') ? G.IsSymbol(value) :
+                                                G.IsEqual(type, 'undefined') ? G.IsUndefined(value) :
+                                                    G.IsEqual(type, 'void') ? G.IsUndefined(value) :
+                                                        true);
 }
 // ------------------------------------------------------------------
 // TypeNames
@@ -52,7 +48,7 @@ function BuildTypeNames(stack, context, typenames, value) {
     return E.ReduceOr(typenames.map(type => BuildTypeName(stack, context, type, value)));
 }
 function CheckTypeNames(stack, context, types, schema, value) {
-    return types.some(type => CheckTypeName(stack, context, type, schema, value));
+    return G.Some(types, type => CheckTypeName(stack, context, type, schema, value));
 }
 // ------------------------------------------------------------------
 // Type

package/build/schema/parse.d.mts

@@ -1,6 +1,6 @@
 import { type TLocalizedValidationError } from '../error/index.mjs';
+import { type Static } from '../type/types/static.mjs';
 import * as Schema from './types/index.mjs';
-import * as Static from './static/index.mjs';
 export declare class ParseError {
     schema: Schema.XSchema;
     value: unknown;
@@ -8,6 +8,6 @@ export declare class ParseError {
     constructor(schema: Schema.XSchema, value: unknown, errors: TLocalizedValidationError[]);
 }
 /** Parses a value against the provided schema */
-export declare function Parse<const Schema extends Schema.XSchema>(schema: Schema, value: unknown): Static.XStatic<Schema>;
+export declare function Parse<const Schema extends Schema.XSchema>(schema: Schema, value: unknown): Static<Schema>;
 /** Parses a value against the provided schema */
-export declare function Parse<const Schema extends Schema.XSchema>(context: Record<PropertyKey, Schema.XSchema>, schema: Schema, value: unknown): Static.XStatic<Schema>;
+export declare function Parse<const Schema extends Schema.XSchema>(context: Record<PropertyKey, Schema.XSchema>, schema: Schema, value: unknown): Static<Schema>;

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

@@ -1,2 +1,2 @@
-export * from './pointer-get.mjs';
+export * from './pointer_get.mjs';
 export * as Pointer from './pointer.mjs';

package/build/schema/pointer/index.mjs

@@ -1,2 +1,2 @@
-export * from './pointer-get.mjs';
+export * from './pointer_get.mjs';
 export * as Pointer from './pointer.mjs';

package/build/schema/pointer/pointer.mjs

@@ -11,6 +11,14 @@ function AssertCanSet(value) {
     if (!Guard.IsObject(value))
         throw Error('Cannot set value');
 }
+function AssertIndex(index) {
+    if (Guard.IsUnsafePropertyKey(index))
+        throw Error('Pointer contains unsafe property key');
+}
+function AssertIndices(indices) {
+    for (const index of indices)
+        AssertIndex(index);
+}
 // ------------------------------------------------------------------
 // Indices
 // ------------------------------------------------------------------
@@ -27,7 +35,7 @@ function HasIndex(index, value) {
     return Guard.IsObject(value) && Guard.HasPropertyKey(value, index);
 }
 function GetIndex(index, value) {
-    return Guard.IsObject(value) ? value[index] : undefined;
+    return Guard.IsObject(value) && !Guard.IsUnsafePropertyKey(index) ? value[index] : undefined;
 }
 function GetIndices(indices, value) {
     return indices.reduce((value, index) => GetIndex(index, value), value);
@@ -70,6 +78,7 @@ export function Get(value, pointer) {
 export function Set(value, pointer, next) {
     const indices = Indices(pointer);
     AssertNotRoot(indices);
+    AssertIndices(indices);
     const [head, index] = TakeIndexRight(indices);
     const parent = GetIndices(head, value);
     AssertCanSet(parent);
@@ -83,6 +92,7 @@ export function Set(value, pointer, next) {
 export function Delete(value, pointer) {
     const indices = Indices(pointer);
     AssertNotRoot(indices);
+    AssertIndices(indices);
     const [head, index] = TakeIndexRight(indices);
     const parent = GetIndices(head, value);
     AssertCanSet(parent);

package/build/schema/resolve/ref.d.mts

@@ -1,2 +1,3 @@
 import * as Schema from '../types/index.mjs';
 export declare function Ref(schema: Schema.XSchemaObject, ref: string): Schema.XSchema | undefined;
+export declare function DynamicRef(root: Schema.XSchemaObject, base: Schema.XSchemaObject, dynamicRef: Schema.XDynamicRef, dynamicAnchors: Schema.XDynamicAnchor[]): Schema.XSchema | undefined;