@openclaw/firecrawl-plugin 2026.10.10 → 2026.11.5-beta.1

package/node_modules/typebox/build/system/memory/assign.d.mts

@@ -1,14 +1,8 @@
 type ObjectLike = Record<PropertyKey, any>;
-/**
- * Performs an Object assign using the Left and Right object types. We track this operation as it
- * creates a new GC handle per assignment.
- */
+/** Performs an Object assign using the Left and Right object types. */
 export type TAssign<Left extends ObjectLike, Right extends ObjectLike, Assigned extends ObjectLike = Omit<Left, keyof Right> & Right> = {
     [Key in keyof Assigned]: Assigned[Key];
 } & {};
-/**
- * Performs an Object assign using the Left and Right object types. We track this operation as it
- * creates a new GC handle per assignment.
- */
+/** Performs an Object assign using the Left and Right object types. */
 export declare function Assign<Left extends ObjectLike, Right extends ObjectLike>(left: Left, right: Right): TAssign<Left, Right>;
 export {};

package/node_modules/typebox/build/system/memory/assign.mjs

@@ -1,12 +1,19 @@
 // deno-lint-ignore-file ban-types no-explicit-any
 // deno-fmt-ignore-file
 import { Metrics } from './metrics.mjs';
-import { Freeze } from './freeze.mjs';
-/**
- * Performs an Object assign using the Left and Right object types. We track this operation as it
- * creates a new GC handle per assignment.
- */
+import { Finalize } from './finalize.mjs';
+import { Keys } from './keys.mjs';
+/** Performs an Object assign using the Left and Right object types. */
 export function Assign(left, right) {
     Metrics.assign += 1;
-    return Freeze({ ...left, ...right });
+    const result = {}, rightKeys = Keys(right), leftKeys = Keys(left);
+    for (const key of leftKeys) {
+        if (rightKeys.includes(key))
+            continue;
+        Object.defineProperty(result, key, Object.getOwnPropertyDescriptor(left, key));
+    }
+    for (const key of rightKeys) {
+        Object.defineProperty(result, key, Object.getOwnPropertyDescriptor(right, key));
+    }
+    return Finalize(result);
 }

package/node_modules/typebox/build/system/memory/clone.d.mts

@@ -1,5 +1,4 @@
-/**
- * Returns a Clone of the given value. This function is similar to structuredClone()
- * but also supports deep cloning instances of Map, Set and TypeArray.
- */
-export declare function Clone<Value extends unknown = unknown>(value: Value): Value;
+type ObjectLike = Record<PropertyKey, any>;
+/** Returns a shallow clone of the given object. */
+export declare function Clone<Value extends ObjectLike = ObjectLike>(value: Value): Value;
+export {};

package/node_modules/typebox/build/system/memory/clone.mjs

@@ -1,34 +1,19 @@
+// deno-lint-ignore-file no-explicit-any
 // deno-fmt-ignore-file
-import { Guard, GlobalsGuard } from '../../guard/index.mjs';
+import { Guard } from '../../guard/index.mjs';
 import { Metrics } from './metrics.mjs';
+import { Keys } from './keys.mjs';
 // ------------------------------------------------------------------
-// ClassInstance
-//
-// TypeBox does not clone arbitrary class instances. Class instances
-// cannot be safely cloned without potentially breaking private
-// members of the instance.
-//
-// ------------------------------------------------------------------
-function FromClassInstance(value) {
-    return value; // atomic
-}
-// ------------------------------------------------------------------
-// SchemaObject
-//
-// Schema objects have non-enumerable properties that MUST be preserved 
-// on Clone. The following is the optimal path these objects.
+// Clone
 // ------------------------------------------------------------------
-function IsSchemaObject(value) {
-    return (Guard.HasPropertyKey(value, '~kind') ||
-        Guard.HasPropertyKey(value, '~unsafe'));
-}
-function FromSchemaObject(value) {
+/** Returns a shallow clone of the given object. */
+export function Clone(value) {
+    Metrics.clone += 1;
     const result = {};
-    for (const key of Guard.Keys(value)) {
+    for (const key of Keys(value)) {
         if (Guard.IsUnsafePropertyKey(key))
             continue; // (ignore: prototype-pollution)
         const descriptor = Object.getOwnPropertyDescriptor(value, key); // safe-name!
-        descriptor.value = FromValue(descriptor.value);
         if (Guard.IsEqual(descriptor.enumerable, true)) {
             result[key] = descriptor.value;
         }
@@ -38,76 +23,3 @@ function FromSchemaObject(value) {
     }
     return result;
 }
-// ------------------------------------------------------------------
-// PlainObject
-// ------------------------------------------------------------------
-function FromPlainObject(value) {
-    const result = {};
-    for (const key of Guard.Keys(value)) {
-        if (Guard.IsUnsafePropertyKey(key))
-            continue; // (ignore: prototype-pollution)
-        result[key] = FromValue(value[key]);
-    }
-    for (const key of Guard.Symbols(value)) {
-        result[key] = FromValue(value[key]);
-    }
-    return result;
-}
-// ------------------------------------------------------------------
-// Object
-// ------------------------------------------------------------------
-function FromObject(value) {
-    return (Guard.IsClassInstance(value) ? FromClassInstance(value) :
-        IsSchemaObject(value) ? FromSchemaObject(value) :
-            FromPlainObject(value));
-}
-// ------------------------------------------------------------------
-// Array
-// ------------------------------------------------------------------
-function FromArray(value) {
-    return value.map((element) => FromValue(element));
-}
-// ------------------------------------------------------------------
-// TypeArray
-// ------------------------------------------------------------------
-function FromTypedArray(value) {
-    return value.slice();
-}
-// ------------------------------------------------------------------
-// RegExp
-// ------------------------------------------------------------------
-function FromRegExp(value) {
-    return new RegExp(value.source, value.flags);
-}
-// ------------------------------------------------------------------
-// Map
-// ------------------------------------------------------------------
-function FromMap(value) {
-    return new Map(FromValue([...value.entries()]));
-}
-// ------------------------------------------------------------------
-// Set
-// ------------------------------------------------------------------
-function FromSet(value) {
-    return new Set(FromValue([...value.values()]));
-}
-function FromValue(value) {
-    return (GlobalsGuard.IsTypeArray(value) ? FromTypedArray(value) :
-        GlobalsGuard.IsRegExp(value) ? FromRegExp(value) :
-            GlobalsGuard.IsMap(value) ? FromMap(value) :
-                GlobalsGuard.IsSet(value) ? FromSet(value) :
-                    Guard.IsArray(value) ? FromArray(value) :
-                        Guard.IsObject(value) ? FromObject(value) :
-                            value);
-}
-// ------------------------------------------------------------------
-// Clone
-// ------------------------------------------------------------------
-/**
- * Returns a Clone of the given value. This function is similar to structuredClone()
- * but also supports deep cloning instances of Map, Set and TypeArray.
- */
-export function Clone(value) {
-    Metrics.clone += 1;
-    return FromValue(value);
-}

package/node_modules/typebox/build/system/memory/create.d.mts

@@ -1,8 +1,4 @@
 type ObjectLike = Record<PropertyKey, any>;
-/**
- * Creates an object with hidden, enumerable, and optional property sets. This function
- * ensures types are instantiated according to configuration rules for enumerable and
- * non-enumerable properties.
- */
+/** Creates an object with hidden, enumerable, and optional property sets. */
 export declare function Create(hidden: ObjectLike, enumerable: ObjectLike, options?: ObjectLike): ObjectLike;
 export {};

package/node_modules/typebox/build/system/memory/create.mjs

@@ -1,8 +1,17 @@
 // deno-lint-ignore-file no-explicit-any
 import { Settings } from '../settings/index.mjs';
 import { Metrics } from './metrics.mjs';
-import { Freeze } from './freeze.mjs';
-function MergeHidden(left, right) {
+import { Finalize } from './finalize.mjs';
+// ------------------------------------------------------------------
+// WithEnumerable
+// ------------------------------------------------------------------
+function WithEnumerable(left, right) {
+    return { ...left, ...right };
+}
+// ------------------------------------------------------------------
+// WithHidden
+// ------------------------------------------------------------------
+function WithHidden(left, right) {
     for (const key of Object.keys(right)) {
         Object.defineProperty(left, key, {
             configurable: true,
@@ -13,17 +22,13 @@ function MergeHidden(left, right) {
     }
     return left;
 }
-function Merge(left, right) {
-    return { ...left, ...right };
-}
-/**
- * Creates an object with hidden, enumerable, and optional property sets. This function
- * ensures types are instantiated according to configuration rules for enumerable and
- * non-enumerable properties.
- */
+// ------------------------------------------------------------------
+// Create
+// ------------------------------------------------------------------
+/** Creates an object with hidden, enumerable, and optional property sets. */
 export function Create(hidden, enumerable, options = {}) {
     Metrics.create += 1;
-    const withOptions = Merge(enumerable, options);
-    const withHidden = Settings.Get().enumerableKind ? Merge(withOptions, hidden) : MergeHidden(withOptions, hidden);
-    return Freeze(withHidden);
+    const withEnumerable = WithEnumerable(enumerable, options);
+    const withHidden = Settings.Get().enumerableKind ? WithEnumerable(withEnumerable, hidden) : WithHidden(withEnumerable, hidden);
+    return Finalize(withHidden);
 }

package/node_modules/typebox/build/system/memory/deep.d.mts

@@ -0,0 +1,2 @@
+/** Returns a deep Clone of the given value. This function is similar to structuredClone() but also supports deep cloning instances of Map, Set and TypeArray. */
+export declare function Deep<Value extends unknown = unknown>(value: Value): Value;

package/node_modules/typebox/build/system/memory/deep.mjs

@@ -0,0 +1,108 @@
+// deno-fmt-ignore-file
+import { Guard, GlobalsGuard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// ClassInstance
+//
+// TypeBox does not clone arbitrary class instances. Class instances
+// cannot be safely cloned without potentially breaking private
+// members of the instance.
+//
+// ------------------------------------------------------------------
+function FromClassInstance(value) {
+    return value; // atomic
+}
+// ------------------------------------------------------------------
+// SchemaObject
+//
+// Schema objects have non-enumerable properties that MUST be preserved 
+// on Clone. The following is the optimal path these objects.
+// ------------------------------------------------------------------
+function IsSchemaObject(value) {
+    return (Guard.HasPropertyKey(value, '~kind') ||
+        Guard.HasPropertyKey(value, '~unsafe'));
+}
+function FromSchemaObject(value) {
+    const result = {};
+    for (const key of Guard.Keys(value)) {
+        if (Guard.IsUnsafePropertyKey(key))
+            continue; // (ignore: prototype-pollution)
+        const descriptor = Object.getOwnPropertyDescriptor(value, key); // safe-name!
+        descriptor.value = FromValue(descriptor.value);
+        if (Guard.IsEqual(descriptor.enumerable, true)) {
+            result[key] = descriptor.value;
+        }
+        else {
+            Object.defineProperty(result, key, descriptor);
+        }
+    }
+    return result;
+}
+// ------------------------------------------------------------------
+// PlainObject
+// ------------------------------------------------------------------
+function FromPlainObject(value) {
+    const result = {};
+    for (const key of Guard.Keys(value)) {
+        if (Guard.IsUnsafePropertyKey(key))
+            continue; // (ignore: prototype-pollution)
+        result[key] = FromValue(value[key]);
+    }
+    for (const key of Guard.Symbols(value)) {
+        result[key] = FromValue(value[key]);
+    }
+    return result;
+}
+// ------------------------------------------------------------------
+// Object
+// ------------------------------------------------------------------
+function FromObject(value) {
+    return (Guard.IsClassInstance(value) ? FromClassInstance(value) :
+        IsSchemaObject(value) ? FromSchemaObject(value) :
+            FromPlainObject(value));
+}
+// ------------------------------------------------------------------
+// Array
+// ------------------------------------------------------------------
+function FromArray(value) {
+    return value.map((element) => FromValue(element));
+}
+// ------------------------------------------------------------------
+// TypeArray
+// ------------------------------------------------------------------
+function FromTypedArray(value) {
+    return value.slice();
+}
+// ------------------------------------------------------------------
+// RegExp
+// ------------------------------------------------------------------
+function FromRegExp(value) {
+    return new RegExp(value.source, value.flags);
+}
+// ------------------------------------------------------------------
+// Map
+// ------------------------------------------------------------------
+function FromMap(value) {
+    return new Map(FromValue([...value.entries()]));
+}
+// ------------------------------------------------------------------
+// Set
+// ------------------------------------------------------------------
+function FromSet(value) {
+    return new Set(FromValue([...value.values()]));
+}
+function FromValue(value) {
+    return (GlobalsGuard.IsTypeArray(value) ? FromTypedArray(value) :
+        GlobalsGuard.IsRegExp(value) ? FromRegExp(value) :
+            GlobalsGuard.IsMap(value) ? FromMap(value) :
+                GlobalsGuard.IsSet(value) ? FromSet(value) :
+                    Guard.IsArray(value) ? FromArray(value) :
+                        Guard.IsObject(value) ? FromObject(value) :
+                            value);
+}
+// ------------------------------------------------------------------
+// Deep
+// ------------------------------------------------------------------
+/** Returns a deep Clone of the given value. This function is similar to structuredClone() but also supports deep cloning instances of Map, Set and TypeArray. */
+export function Deep(value) {
+    return FromValue(value);
+}

package/node_modules/typebox/build/system/memory/discard.d.mts

@@ -1,4 +1,4 @@
 type ObjectLike = Record<PropertyKey, any>;
-/** Discards multiple property keys from the given object value */
+/** Discards property keys from the given object. */
 export declare function Discard(value: ObjectLike, propertyKeys: PropertyKey[]): ObjectLike;
 export {};

package/node_modules/typebox/build/system/memory/discard.mjs

@@ -1,18 +1,19 @@
 // deno-lint-ignore-file no-explicit-any
-import { Guard } from '../../guard/index.mjs';
 import { Metrics } from './metrics.mjs';
-import { Freeze } from './freeze.mjs';
-import { Clone } from './clone.mjs';
-/** Discards multiple property keys from the given object value */
+import { Finalize } from './finalize.mjs';
+import { Keys } from './keys.mjs';
+// ------------------------------------------------------------------
+// Discard
+// ------------------------------------------------------------------
+/** Discards property keys from the given object. */
 export function Discard(value, propertyKeys) {
     Metrics.discard += 1;
     const result = {};
-    for (const key of Guard.Keys(value)) {
+    for (const key of Keys(value)) {
         if (propertyKeys.includes(key))
             continue;
-        const descriptor = Object.getOwnPropertyDescriptor(value, key); // safe-name!
-        descriptor.value = Clone(descriptor.value);
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
         Object.defineProperty(result, key, descriptor);
     }
-    return Freeze(result);
+    return Finalize(result);
 }

package/node_modules/typebox/build/system/memory/finalize.d.mts

@@ -0,0 +1,4 @@
+type ObjectLike = Record<PropertyKey, any>;
+/** Finalizes a type. Will recursively freeze if `immutableTypes` is true, otherwise no action. */
+export declare function Finalize(value: ObjectLike): ObjectLike;
+export {};

package/node_modules/typebox/build/system/memory/finalize.mjs

@@ -0,0 +1,30 @@
+// deno-lint-ignore-file no-explicit-any
+import { Guard } from '../../guard/index.mjs';
+import { Settings } from '../settings/index.mjs';
+import { Keys } from './keys.mjs';
+// ------------------------------------------------------------------
+// Freeze
+// ------------------------------------------------------------------
+function Freeze(value, seen) {
+    if (seen.has(value))
+        return;
+    seen.add(value);
+    for (const key of Keys(value)) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!descriptor || !('value' in descriptor))
+            continue;
+        if (Guard.IsObject(descriptor.value))
+            Freeze(descriptor.value, seen);
+    }
+    Object.freeze(value);
+}
+// ------------------------------------------------------------------
+// Finalize
+// ------------------------------------------------------------------
+/** Finalizes a type. Will recursively freeze if `immutableTypes` is true, otherwise no action. */
+export function Finalize(value) {
+    if (!Settings.Get().immutableTypes)
+        return value;
+    Freeze(value, new WeakSet());
+    return value;
+}

package/node_modules/typebox/build/system/memory/keys.d.mts

@@ -0,0 +1,2 @@
+/** Returns the own string and symbol keys of the given object. */
+export declare function Keys(value: Record<PropertyKey, unknown>): PropertyKey[];

package/node_modules/typebox/build/system/memory/keys.mjs

@@ -0,0 +1,8 @@
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Keys (alternatively, Reflect.ownKeys(...))
+// ------------------------------------------------------------------
+/** Returns the own string and symbol keys of the given object. */
+export function Keys(value) {
+    return [...Guard.Keys(value), ...Guard.Symbols(value)];
+}

package/node_modules/typebox/build/system/memory/update.d.mts

@@ -1,7 +1,4 @@
 type ObjectLike = Record<PropertyKey, any>;
-/**
- * Updates a value with new properties while preserving property enumerability. Use this function to modify
- * existing types without altering their configuration.
- */
+/** Updates an existing type with additional hidden and enumerable properties while preserving property configuration. */
 export declare function Update(current: ObjectLike, hidden: ObjectLike, enumerable: ObjectLike): ObjectLike;
 export {};

package/node_modules/typebox/build/system/memory/update.mjs

@@ -1,27 +1,43 @@
 // deno-lint-ignore-file no-explicit-any
+import { Guard } from '../../guard/index.mjs';
 import { Settings } from '../settings/index.mjs';
 import { Metrics } from './metrics.mjs';
-import { Freeze } from './freeze.mjs';
-import { Clone } from './clone.mjs';
-/**
- * Updates a value with new properties while preserving property enumerability. Use this function to modify
- * existing types without altering their configuration.
- */
-export function Update(current, hidden, enumerable) {
-    Metrics.update += 1;
-    const settings = Settings.Get();
-    const result = Clone(current);
-    // hidden
-    for (const key of Object.keys(hidden)) {
+import { Finalize } from './finalize.mjs';
+import { Keys } from './keys.mjs';
+// ------------------------------------------------------------------
+// WithCurrent
+// ------------------------------------------------------------------
+function WithCurrent(current, hiddenKeys, enumerableKeys, result) {
+    for (const key of Keys(current)) {
+        if (Guard.IsUnsafePropertyKey(key) || hiddenKeys.includes(key) || enumerableKeys.includes(key))
+            continue; // (ignore: prototype-pollution)
+        const descriptor = Object.getOwnPropertyDescriptor(current, key); // safe-name!
+        Object.defineProperty(result, key, descriptor);
+    }
+}
+// ------------------------------------------------------------------
+// WithHidden
+// ------------------------------------------------------------------
+function WithHidden(hidden, keys, result) {
+    const enumerableKind = Settings.Get().enumerableKind;
+    for (const key of keys) {
+        if (Guard.IsUnsafePropertyKey(key))
+            continue; // (ignore: prototype-pollution)
         Object.defineProperty(result, key, {
             configurable: true,
             writable: true,
-            enumerable: settings.enumerableKind,
+            enumerable: enumerableKind,
             value: hidden[key]
         });
     }
-    // enumerable
-    for (const key of Object.keys(enumerable)) {
+}
+// ------------------------------------------------------------------
+// WithEnumerable
+// ------------------------------------------------------------------
+function WithEnumerable(enumerable, keys, result) {
+    for (const key of keys) {
+        if (Guard.IsUnsafePropertyKey(key))
+            continue; // (ignore: prototype-pollution)
         Object.defineProperty(result, key, {
             configurable: true,
             enumerable: true,
@@ -29,5 +45,16 @@ export function Update(current, hidden, enumerable) {
             value: enumerable[key]
         });
     }
-    return Freeze(result);
+}
+// ------------------------------------------------------------------
+// Update
+// ------------------------------------------------------------------
+/** Updates an existing type with additional hidden and enumerable properties while preserving property configuration. */
+export function Update(current, hidden, enumerable) {
+    Metrics.update += 1;
+    const result = {}, hiddenKeys = Keys(hidden), enumerableKeys = Keys(enumerable);
+    WithCurrent(current, hiddenKeys, enumerableKeys, result);
+    WithHidden(hidden, hiddenKeys, result);
+    WithEnumerable(enumerable, enumerableKeys, result);
+    return Finalize(result);
 }

package/node_modules/typebox/build/type/engine/call/index.d.mts

@@ -0,0 +1 @@
+export * from './instantiate.mjs';

package/node_modules/typebox/build/type/engine/call/index.mjs

@@ -0,0 +1 @@
+export * from './instantiate.mjs';

package/node_modules/typebox/build/type/engine/evaluate/composite.d.mts

@@ -1,33 +1,11 @@
-import { type TReadonly } from '../../types/_readonly.mjs';
-import { type TOptional } from '../../types/_optional.mjs';
 import { type TSchema } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TObject } from '../../types/object.mjs';
 import { type TNever } from '../../types/never.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
-import { type TAddReadonly } from '../../action/_add_readonly.mjs';
-import { type TAddOptional } from '../../action/_add_optional.mjs';
-import { type TRemoveReadonly } from '../../action/_remove_readonly.mjs';
-import { type TRemoveOptional } from '../../action/_remove_optional.mjs';
 import { type TTupleElementsToProperties } from '../tuple/to_object.mjs';
-import { type TEvaluateIntersect } from './evaluate.mjs';
-/** Returns true if the type is a valid operand to Composite. */
-export type TCanComposite<Type extends TSchema> = (Type extends TObject<infer _ extends TProperties> ? true : Type extends TTuple<infer _ extends TSchema[]> ? true : false);
-/** Returns true if the type is a valid operand to Composite. */
-export declare function CanComposite<Type extends TSchema>(type: Type): TCanComposite<Type>;
-type TIsReadonlyProperty<Left extends TSchema, Right extends TSchema> = (Left extends TReadonly<Left> ? Right extends TReadonly<Right> ? true : false : false);
-type TIsOptionalProperty<Left extends TSchema, Right extends TSchema> = (Left extends TOptional<Left> ? Right extends TOptional<Right> ? true : false : false);
-type TCompositeProperty<Left extends TSchema, Right extends TSchema, IsReadonly extends boolean = TIsReadonlyProperty<Left, Right>, IsOptional extends boolean = TIsOptionalProperty<Left, Right>, Evaluated extends TSchema = TEvaluateIntersect<[Left, Right]>, Property extends TSchema = TRemoveReadonly<TRemoveOptional<Evaluated>>> = ([
-    IsReadonly,
-    IsOptional
-] extends [true, true] ? TAddReadonly<TAddOptional<Property>> : [
-    IsReadonly,
-    IsOptional
-] extends [true, false] ? TAddReadonly<Property> : [
-    IsReadonly,
-    IsOptional
-] extends [false, true] ? TAddOptional<Property> : Property);
-type TCompositePropertyKey<Left extends TProperties, Right extends TProperties, Key extends PropertyKey, Result extends TSchema = (Key extends keyof Left ? Key extends keyof Right ? TCompositeProperty<Left[Key], Right[Key]> : Left[Key] : Key extends keyof Right ? Right[Key] : TNever)> = Result;
+import { type TEvaluatePropertyIntersect } from './property.mjs';
+type TCompositePropertyKey<Left extends TProperties, Right extends TProperties, Key extends PropertyKey, Result extends TSchema = (Key extends keyof Left ? Key extends keyof Right ? TEvaluatePropertyIntersect<Left[Key], Right[Key]> : Left[Key] : Key extends keyof Right ? Right[Key] : TNever)> = Result;
 type TCompositeProperties<Left extends TProperties, Right extends TProperties, Keys extends PropertyKey = keyof (Left & Right), Result extends TProperties = {
     [Key in Keys]: TCompositePropertyKey<Left, Right, Key>;
 }> = Result;

package/node_modules/typebox/build/type/engine/evaluate/composite.mjs

@@ -1,41 +1,14 @@
 // deno-fmt-ignore-file
 // deno-lint-ignore-file
 import { Guard } from '../../../guard/index.mjs';
-import { IsReadonly } from '../../types/_readonly.mjs';
-import { IsOptional } from '../../types/_optional.mjs';
 import { Object, IsObject } from '../../types/object.mjs';
 import { Never } from '../../types/never.mjs';
 import { IsTuple } from '../../types/tuple.mjs';
-import { AddReadonly } from '../../action/_add_readonly.mjs';
-import { AddOptional } from '../../action/_add_optional.mjs';
-import { RemoveReadonly } from '../../action/_remove_readonly.mjs';
-import { RemoveOptional } from '../../action/_remove_optional.mjs';
 import { TupleElementsToProperties } from '../tuple/to_object.mjs';
-import { EvaluateIntersect } from './evaluate.mjs';
-/** Returns true if the type is a valid operand to Composite. */
-export function CanComposite(type) {
-    return (IsObject(type) || IsTuple(type));
-}
-function IsReadonlyProperty(left, right) {
-    return (IsReadonly(left) ? IsReadonly(right) ? true : false : false);
-}
-function IsOptionalProperty(left, right) {
-    return (IsOptional(left) ? IsOptional(right) ? true : false : false);
-}
-function CompositeProperty(left, right) {
-    const isReadonly = IsReadonlyProperty(left, right);
-    const isOptional = IsOptionalProperty(left, right);
-    const evaluated = EvaluateIntersect([left, right]);
-    // Modifiers need to be discarded and re-applied
-    const property = RemoveReadonly(RemoveOptional(evaluated));
-    return (isReadonly && isOptional ? AddReadonly(AddOptional(property)) :
-        isReadonly && !isOptional ? AddReadonly(property) :
-            !isReadonly && isOptional ? AddOptional(property) :
-                property);
-}
+import { EvaluatePropertyIntersect } from './property.mjs';
 function CompositePropertyKey(left, right, key) {
     return (key in left
-        ? key in right ? CompositeProperty(left[key], right[key]) : left[key]
+        ? key in right ? EvaluatePropertyIntersect(left[key], right[key]) : left[key]
         : key in right ? right[key] : Never());
 }
 function CompositeProperties(left, right) {

package/node_modules/typebox/build/type/engine/evaluate/index.d.mts

@@ -6,3 +6,4 @@ export * from './evaluate.mjs';
 export * from './flatten.mjs';
 export * from './instantiate.mjs';
 export * from './narrow.mjs';
+export * from './property.mjs';

package/node_modules/typebox/build/type/engine/evaluate/index.mjs

@@ -6,3 +6,4 @@ export * from './evaluate.mjs';
 export * from './flatten.mjs';
 export * from './instantiate.mjs';
 export * from './narrow.mjs';
+export * from './property.mjs';

package/node_modules/typebox/build/type/engine/evaluate/narrow.d.mts

@@ -1,10 +1,14 @@
 import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TObject } from '../../types/object.mjs';
 import { type TAny } from '../../types/any.mjs';
 import { type TNever } from '../../types/never.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
 import { type TUnknown } from '../../types/unknown.mjs';
 import { type TCompare, type TCompareResult, CompareResultLeftInside, CompareResultRightInside, CompareResultEqual } from './compare.mjs';
-import { type TComposite, type TCanComposite } from './composite.mjs';
+import { type TComposite } from './composite.mjs';
 type TNarrowCompareRule<Left extends TSchema, Right extends TSchema, Result extends TCompareResult = TCompare<Left, Right>> = (Result extends typeof CompareResultLeftInside ? Left : Result extends typeof CompareResultRightInside ? Right : Result extends typeof CompareResultEqual ? Right : TNever);
+type TCanComposite<Type extends TSchema> = (Type extends TObject<infer _ extends TProperties> ? true : Type extends TTuple<infer _ extends TSchema[]> ? true : false);
 type TNarrowCompositeRule<Left extends TSchema, Right extends TSchema, CanCompositeLeft extends boolean = TCanComposite<Left>, CanCompositeRight extends boolean = TCanComposite<Right>> = ([
     CanCompositeLeft,
     CanCompositeRight