@openclaw/diffs 2026.8.1-beta.2 → 2026.8.1

package/node_modules/typebox/build/guard/guard.mjs

@@ -129,16 +129,16 @@ export function GraphemeCount(value) {
 }
 /** Returns true if the string has at most the given number of graphemes */
 export function IsMaxLength(value, length) {
-    return String.IsMaxLengthFast(value, length);
+    return String.IsMaxLength(value, length);
 }
 /** Returns true if the string has at least the given number of graphemes */
 export function IsMinLength(value, length) {
-    return String.IsMinLengthFast(value, length);
+    return String.IsMinLength(value, length);
 }
 // --------------------------------------------------------------------------
 // Array
 // --------------------------------------------------------------------------
-/** Returns true if all elements from offset satisfy the callback, short-circuiting on the first failure */
+/** Returns true if every element from offset satisfies the callback, short-circuiting on the first failure */
 export function Every(value, offset, callback) {
     for (let index = offset; index < value.length; index++) {
         if (!callback(value[index], index))
@@ -146,7 +146,7 @@ export function Every(value, offset, callback) {
     }
     return true;
 }
-/** Returns true if all elements from offset satisfy the callback, visiting every element regardless of failure */
+/** Returns true if every element from offset satisfies the callback, using exhaustive enumeration */
 export function EveryAll(value, offset, callback) {
     let result = true;
     for (let index = offset; index < value.length; index++) {
@@ -155,6 +155,27 @@ export function EveryAll(value, offset, callback) {
     }
     return result;
 }
+/** Returns true if some element satisfies the callback, short-circuiting on the first success */
+export function Some(value, callback) {
+    for (let index = 0; index < value.length; index++) {
+        if (callback(value[index], index))
+            return true;
+    }
+    return false;
+}
+/** Returns true if some element satisfies the callback, using exhaustive enumeration */
+export function SomeAll(value, callback) {
+    let result = false;
+    for (let index = 0; index < value.length; index++) {
+        if (callback(value[index], index))
+            result = true;
+    }
+    return result;
+}
+/** Returns the count of elements that satisfy the callback */
+export function Counted(value, callback) {
+    return value.reduce((result, value, index) => callback(value, index) ? ++result : result, 0);
+}
 /** Shifts the left-most element from an array and dispatches to the true arm, or the false arm if empty */
 export function ShiftLeft(array, true_, false_) {
     return (IsEqual(array.length, 0) ? false_() : true_(array[0], array.slice(1)));

package/node_modules/typebox/build/guard/string.d.mts

@@ -1,6 +1,6 @@
 /** Returns the number of grapheme clusters in a string */
 export declare function GraphemeCount(value: string): number;
 /** Fast check for minimum grapheme length, falls back to full check if needed */
-export declare function IsMinLengthFast(value: string, minLength: number): boolean;
+export declare function IsMinLength(value: string, minLength: number): boolean;
 /** Fast check for maximum grapheme length, falls back to full check if needed */
-export declare function IsMaxLengthFast(value: string, maxLength: number): boolean;
+export declare function IsMaxLength(value: string, maxLength: number): boolean;

package/node_modules/typebox/build/guard/string.mjs

@@ -67,7 +67,7 @@ function NextGraphemeClusterIndex(value, clusterStart) {
     // Consume combining marks & variation selectors
     clusterEnd = ConsumeModifiers(value, clusterEnd);
     // Handle multi-ZWJ sequences
-    while (clusterEnd < value.length - 1 && value[clusterEnd] === '\u200D') {
+    while (clusterEnd < value.length - 1 && IsZeroWidthJoiner(value.codePointAt(clusterEnd))) {
         const nextCP = value.codePointAt(clusterEnd + 1);
         clusterEnd += 1 + CodePointLength(nextCP);
         clusterEnd = ConsumeModifiers(value, clusterEnd);
@@ -106,7 +106,7 @@ export function GraphemeCount(value) {
 // IsMinLength
 // --------------------------------------------------------------------------
 /** Checks if a string has at least a minimum number of grapheme clusters */
-function IsMinLength(value, minLength) {
+function IsMinLengthSegmented(value, minLength) {
     // ----------------------------------------------------------------
     // Inaccessible via public interface (review)
     //
@@ -129,7 +129,7 @@ function IsMinLength(value, minLength) {
 // IsMaxLength
 // --------------------------------------------------------------------------
 /** Checks if a string has at most a maximum number of grapheme clusters */
-function IsMaxLength(value, maxLength) {
+function IsMaxLengthSegmented(value, maxLength) {
     let count = 0;
     let index = 0;
     while (index < value.length) {
@@ -144,13 +144,13 @@ function IsMaxLength(value, maxLength) {
 // IsMinLengthFast
 // --------------------------------------------------------------------------
 /** Fast check for minimum grapheme length, falls back to full check if needed */
-export function IsMinLengthFast(value, minLength) {
+export function IsMinLength(value, minLength) {
     if (minLength === 0)
         return true; // 0-length
     let index = 0;
     while (index < value.length) {
         if (IsGraphemeCodePoint(value.charCodeAt(index))) {
-            return IsMinLength(value, minLength);
+            return IsMinLengthSegmented(value, minLength);
         }
         index++;
         if (index >= minLength)
@@ -162,11 +162,11 @@ export function IsMinLengthFast(value, minLength) {
 // IsMaxLengthFast
 // --------------------------------------------------------------------------
 /** Fast check for maximum grapheme length, falls back to full check if needed */
-export function IsMaxLengthFast(value, maxLength) {
+export function IsMaxLength(value, maxLength) {
     let index = 0;
     while (index < value.length) {
         if (IsGraphemeCodePoint(value.charCodeAt(index))) {
-            return IsMaxLength(value, maxLength);
+            return IsMaxLengthSegmented(value, maxLength);
         }
         index++;
         if (index > maxLength)

package/node_modules/typebox/build/schema/engine/_context.mjs

@@ -7,10 +7,10 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 function HasUnevaluatedFromObject(value) {
     return (Schema.IsUnevaluatedItems(value)
         || Schema.IsUnevaluatedProperties(value)
-        || G.Keys(value).some(key => HasUnevaluatedFromUnknown(value[key])));
+        || G.Some(G.Keys(value), key => HasUnevaluatedFromUnknown(value[key])));
 }
 function HasUnevaluatedFromArray(value) {
-    return value.some(value => HasUnevaluatedFromUnknown(value));
+    return G.Some(value, value => HasUnevaluatedFromUnknown(value));
 }
 function HasUnevaluatedFromUnknown(value) {
     return (G.IsArray(value) ? HasUnevaluatedFromArray(value) :
@@ -18,7 +18,7 @@ function HasUnevaluatedFromUnknown(value) {
             false);
 }
 export function HasUnevaluated(context, schema) {
-    return HasUnevaluatedFromUnknown(schema) || G.Keys(context).some(key => HasUnevaluatedFromUnknown(context[key]));
+    return HasUnevaluatedFromUnknown(schema) || G.Some(G.Keys(context), key => HasUnevaluatedFromUnknown(context[key]));
 }
 // ------------------------------------------------------------------
 // BuildContext

package/node_modules/typebox/build/schema/engine/_functions.mjs

@@ -1,5 +1,4 @@
 // deno-fmt-ignore-file
-import { Hashing } from '../../system/hashing/index.mjs';
 import { EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchema } from './schema.mjs';
 const index = [0];
@@ -9,7 +8,7 @@ const funcs = new Map();
 // CreateName
 // ------------------------------------------------------------------
 function NextName() {
-    return Hashing.Hash(index[0]++);
+    return `${index[0]++}`;
 }
 function CreateName(schema, href) {
     if (!names.has(schema))

package/node_modules/typebox/build/schema/engine/_regexp.d.mts

@@ -0,0 +1,2 @@
+/** Standard RegExp with Unicode */
+export declare function UnicodeRegExp(pattern: string): RegExp;

package/node_modules/typebox/build/schema/engine/_regexp.mjs

@@ -0,0 +1,4 @@
+/** Standard RegExp with Unicode */
+export function UnicodeRegExp(pattern) {
+    return new RegExp(pattern, 'u');
+}

package/node_modules/typebox/build/schema/engine/_stack.mjs

@@ -4,7 +4,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _Stack_instances, _Stack_PushResourceAnchors, _Stack_PopResourceAnchors, _Stack_FromContext, _Stack_FromRef;
+var _Stack_instances, _Stack_PushResourceAnchors, _Stack_PopResourceAnchors;
 import * as Schema from '../types/index.mjs';
 import { Guard as G } from '../../guard/index.mjs';
 import { Resolve } from '../resolve/index.mjs';
@@ -22,7 +22,7 @@ export class Stack {
     // Base
     // ----------------------------------------------------------------
     BaseURL() {
-        return this.ids.reduce((result, schema) => new URL(schema.$id, result), new URL('http://unknown'));
+        return this.ids.reduce((result, schema) => new URL(schema.$id, result), Resolve.DefaultBase);
     }
     Base() {
         return this.ids[this.ids.length - 1] ?? this.schema;
@@ -58,23 +58,29 @@ export class Stack {
         if (Schema.IsDynamicAnchor(schema))
             this.dynamicAnchors.pop();
     }
+    // ----------------------------------------------------------------
+    // Ref
+    // ----------------------------------------------------------------
     Ref(ref) {
-        return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_FromContext).call(this, ref) ?? __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_FromRef).call(this, ref);
+        const root = this.schema;
+        return !ref.$ref.startsWith('#')
+            ? Resolve.Ref(this.context, root, ref.$ref)
+            : Resolve.Ref(this.context, this.Base(), ref.$ref);
     }
     // ----------------------------------------------------------------
     // RecursiveRef
     // ----------------------------------------------------------------
     RecursiveRef(recursiveRef) {
         return Schema.IsRecursiveAnchorTrue(this.Base())
-            ? Resolve.Ref(this.recursiveAnchors[0], recursiveRef.$recursiveRef)
-            : Resolve.Ref(this.Base(), recursiveRef.$recursiveRef);
+            ? Resolve.Ref(this.context, this.recursiveAnchors[0], recursiveRef.$recursiveRef)
+            : Resolve.Ref(this.context, this.Base(), recursiveRef.$recursiveRef);
     }
     // ----------------------------------------------------------------
     // DynamicRef
     // ----------------------------------------------------------------
     DynamicRef(dynamicRef) {
         const root = this.schema;
-        return Resolve.DynamicRef(root, this.Base(), dynamicRef, this.dynamicAnchors);
+        return Resolve.DynamicRef(this.context, root, this.Base(), dynamicRef, this.dynamicAnchors);
     }
 }
 _Stack_instances = new WeakSet(), _Stack_PushResourceAnchors = function _Stack_PushResourceAnchors(schema, isRoot = true) {
@@ -97,11 +103,4 @@ _Stack_instances = new WeakSet(), _Stack_PushResourceAnchors = function _Stack_P
         this.dynamicAnchors.pop();
     for (const key of G.Keys(current))
         __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PopResourceAnchors).call(this, current[key], false);
-}, _Stack_FromContext = function _Stack_FromContext(ref) {
-    return G.HasPropertyKey(this.context, ref.$ref) ? this.context[ref.$ref] : undefined;
-}, _Stack_FromRef = function _Stack_FromRef(ref) {
-    const root = this.schema;
-    return !ref.$ref.startsWith('#')
-        ? Resolve.Ref(root, ref.$ref)
-        : Resolve.Ref(this.Base(), ref.$ref);
 };

package/node_modules/typebox/build/schema/engine/additionalItems.mjs

@@ -12,15 +12,25 @@ function IsValid(schema) {
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildAdditionalItems(stack, context, schema, value) {
-    if (!IsValid(schema))
-        return E.Constant(true);
+function BuildAdditionalItemsStandard(stack, context, schema, value) {
     const [item, index] = [Unique(), Unique()];
     const isSchema = BuildSchemaPushStack(stack, context, schema.additionalItems, item);
     const isLength = E.IsLessThan(index, E.Constant(schema.items.length));
     const addIndex = context.AddIndex(index);
-    const guarded = context.UseUnevaluated() ? E.Or(isLength, E.And(isSchema, addIndex)) : E.Or(isLength, isSchema);
-    return E.Call(E.Member(value, 'every'), [E.ArrowFunction([item, index], guarded)]);
+    return E.Every(value, E.Constant(0), [item, index], E.Or(isLength, E.And(isSchema, addIndex)));
+}
+function BuildAdditionalItemsFast(stack, context, schema, value) {
+    const [item, index] = [Unique(), Unique()];
+    const isSchema = BuildSchemaPushStack(stack, context, schema.additionalItems, item);
+    const isLength = E.IsLessThan(index, E.Constant(schema.items.length));
+    return E.Every(value, E.Constant(0), [item, index], E.Or(isLength, isSchema));
+}
+export function BuildAdditionalItems(stack, context, schema, value) {
+    if (!IsValid(schema))
+        return E.Constant(true);
+    return context.UseUnevaluated()
+        ? BuildAdditionalItemsStandard(stack, context, schema, value)
+        : BuildAdditionalItemsFast(stack, context, schema, value);
 }
 // ------------------------------------------------------------------
 // Check
@@ -28,7 +38,7 @@ export function BuildAdditionalItems(stack, context, schema, value) {
 export function CheckAdditionalItems(stack, context, schema, value) {
     if (!IsValid(schema))
         return true;
-    const isAdditionalItems = value.every((item, index) => {
+    const isAdditionalItems = G.Every(value, 0, (item, index) => {
         return G.IsLessThan(index, schema.items.length)
             || (CheckSchemaPushStack(stack, context, schema.additionalItems, item) && context.AddIndex(index));
     });
@@ -40,7 +50,7 @@ export function CheckAdditionalItems(stack, context, schema, value) {
 export function ErrorAdditionalItems(stack, context, schemaPath, instancePath, schema, value) {
     if (!IsValid(schema))
         return true;
-    const isAdditionalItems = value.every((item, index) => {
+    const isAdditionalItems = G.Every(value, 0, (item, index) => {
         const nextSchemaPath = `${schemaPath}/additionalItems`;
         const nextInstancePath = `${instancePath}/${index}`;
         return G.IsLessThan(index, schema.items.length) ||

package/node_modules/typebox/build/schema/engine/additionalProperties.mjs

@@ -3,6 +3,7 @@ import * as S from '../types/index.mjs';
 import * as V from './_externals.mjs';
 import { Unique } from './_unique.mjs';
 import { AccumulatedErrorContext } from './_context.mjs';
+import { UnicodeRegExp } from './_regexp.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -58,7 +59,7 @@ export function BuildAdditionalPropertiesFast(_context, schema, value) {
 // ------------------------------------------------------------------
 export function BuildAdditionalPropertiesStandard(stack, context, schema, value) {
     const [key, _index] = [Unique(), Unique()];
-    const regexp = V.CreateVariable(new RegExp(GetPropertiesPattern(schema)));
+    const regexp = V.CreateVariable(UnicodeRegExp(GetPropertiesPattern(schema)));
     const isSchema = BuildSchemaPushStack(stack, context, schema.additionalProperties, `${value}[${key}]`);
     const isKey = E.Call(E.Member(regexp, 'test'), [key]);
     const addKey = context.AddKey(key);
@@ -78,7 +79,7 @@ export function BuildAdditionalProperties(stack, context, schema, value) {
 // Check
 // ------------------------------------------------------------------
 export function CheckAdditionalProperties(stack, context, schema, value) {
-    const regexp = new RegExp(GetPropertiesPattern(schema));
+    const regexp = UnicodeRegExp(GetPropertiesPattern(schema));
     const isAdditionalProperties = G.Every(G.Keys(value), 0, (key, _index) => {
         return regexp.test(key) ||
             (CheckSchemaPushStack(stack, context, schema.additionalProperties, value[key]) && context.AddKey(key));
@@ -89,7 +90,7 @@ export function CheckAdditionalProperties(stack, context, schema, value) {
 // Error
 // ------------------------------------------------------------------
 export function ErrorAdditionalProperties(stack, context, schemaPath, instancePath, schema, value) {
-    const regexp = new RegExp(GetPropertiesPattern(schema));
+    const regexp = UnicodeRegExp(GetPropertiesPattern(schema));
     const additionalProperties = [];
     const isAdditionalProperties = G.EveryAll(G.Keys(value), 0, (key, _index) => {
         const nextSchemaPath = `${schemaPath}/additionalProperties`;

package/node_modules/typebox/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/node_modules/typebox/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/node_modules/typebox/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/node_modules/typebox/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/node_modules/typebox/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/node_modules/typebox/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/node_modules/typebox/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/node_modules/typebox/build/schema/engine/pattern.mjs

@@ -1,18 +1,19 @@
 // deno-fmt-ignore-file
 import * as Externals from './_externals.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+import { UnicodeRegExp } from './_regexp.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
 export function BuildPattern(_stack, _context, schema, value) {
-    const regexp = Externals.CreateVariable(G.IsString(schema.pattern) ? new RegExp(schema.pattern, 'u') : schema.pattern);
+    const regexp = Externals.CreateVariable(G.IsString(schema.pattern) ? UnicodeRegExp(schema.pattern) : schema.pattern);
     return E.Call(E.Member(regexp, 'test'), [value]);
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
 export function CheckPattern(_stack, _context, schema, value) {
-    const regexp = G.IsString(schema.pattern) ? new RegExp(schema.pattern, 'u') : schema.pattern;
+    const regexp = G.IsString(schema.pattern) ? UnicodeRegExp(schema.pattern) : schema.pattern;
     return regexp.test(value);
 }
 // ------------------------------------------------------------------

package/node_modules/typebox/build/schema/engine/patternProperties.mjs

@@ -1,6 +1,7 @@
 // deno-fmt-ignore-file
 import * as Externals from './_externals.mjs';
 import { Unique } from './_unique.mjs';
+import { UnicodeRegExp } from './_regexp.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -9,7 +10,7 @@ import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from
 export function BuildPatternProperties(stack, context, schema, value) {
     return E.ReduceAnd(G.Entries(schema.patternProperties).map(([pattern, schema]) => {
         const [key, prop] = [Unique(), Unique()];
-        const regexp = Externals.CreateVariable(new RegExp(pattern, 'u'));
+        const regexp = Externals.CreateVariable(UnicodeRegExp(pattern));
         const notKey = E.Not(E.Call(E.Member(regexp, 'test'), [key]));
         const isSchema = BuildSchemaPushStack(stack, context, schema, prop);
         const addKey = context.AddKey(key);
@@ -22,7 +23,7 @@ export function BuildPatternProperties(stack, context, schema, value) {
 // ------------------------------------------------------------------
 export function CheckPatternProperties(stack, context, schema, value) {
     return G.Every(G.Entries(schema.patternProperties), 0, ([pattern, schema]) => {
-        const regexp = new RegExp(pattern, 'u');
+        const regexp = UnicodeRegExp(pattern);
         return G.Every(G.Entries(value), 0, ([key, prop]) => {
             return !regexp.test(key) || CheckSchemaPushStack(stack, context, schema, prop) && context.AddKey(key);
         });
@@ -34,7 +35,7 @@ export function CheckPatternProperties(stack, context, schema, value) {
 export function ErrorPatternProperties(stack, context, schemaPath, instancePath, schema, value) {
     return G.EveryAll(G.Entries(schema.patternProperties), 0, ([pattern, schema]) => {
         const nextSchemaPath = `${schemaPath}/patternProperties/${pattern}`;
-        const regexp = new RegExp(pattern, 'u');
+        const regexp = UnicodeRegExp(pattern);
         return G.EveryAll(G.Entries(value), 0, ([key, value]) => {
             const nextInstancePath = `${instancePath}/${key}`;
             const notKey = !regexp.test(key);

package/node_modules/typebox/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,15 +17,9 @@ 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) ?? false;
     return context.UseUnevaluated()