@openclaw/google-meet 2026.10.10 → 2026.11.5-beta.1

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

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import * as Schema from '../types/index.mjs';
-import { Unique } from './_unique.mjs';
+import * as Unique from './_unique.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -13,13 +13,13 @@ function IsValid(schema) {
 // Build
 // ------------------------------------------------------------------
 function BuildContainsStandard(stack, context, schema, value) {
-    const [item, index] = [Unique(), Unique()];
+    const [item, index] = [Unique.CreateUnique(), Unique.CreateUnique()];
     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 [item] = [Unique.CreateUnique()];
     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);

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

@@ -4,6 +4,7 @@ export * from './_functions.mjs';
 export * from './_reducer.mjs';
 export * from './_refine.mjs';
 export * from './_stack.mjs';
+export * from './_unique.mjs';
 export * from './additionalItems.mjs';
 export * from './additionalProperties.mjs';
 export * from './allOf.mjs';

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

@@ -7,6 +7,7 @@ export * from './_functions.mjs';
 export * from './_reducer.mjs';
 export * from './_refine.mjs';
 export * from './_stack.mjs';
+export * from './_unique.mjs';
 // ------------------------------------------------------------------
 // Schematics
 // ------------------------------------------------------------------

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

@@ -1,5 +1,6 @@
 // deno-fmt-ignore-file
 import * as Schema from '../types/index.mjs';
+import * as Unique from './_unique.mjs';
 import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
@@ -44,14 +45,16 @@ function ErrorItemsSized(stack, context, schemaPath, instancePath, 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 [item] = [Unique.CreateUnique()];
+    const isSchema = BuildSchemaPushStack(stack, context, schema.items, item);
     const addIndex = context.AddIndex('index');
-    return E.Every(value, E.Constant(offset), ['element', 'index'], E.And(isSchema, addIndex));
+    return E.Every(value, E.Constant(offset), [item, '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);
+    const [item] = [Unique.CreateUnique()];
+    const isSchema = BuildSchemaPushStack(stack, context, schema.items, item);
+    return E.Every(value, E.Constant(offset), [item, 'index'], isSchema);
 }
 function BuildItemsUnsized(stack, context, schema, value) {
     return context.UseUnevaluated()

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

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import * as Schema from '../types/index.mjs';
-import { Unique } from './_unique.mjs';
+import * as Unique from './_unique.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -15,7 +15,7 @@ function IsValid(schema) {
 export function BuildMaxContains(stack, context, schema, value) {
     if (!IsValid(schema))
         return E.Constant(true);
-    const [item] = [Unique()];
+    const [item] = [Unique.CreateUnique()];
     const count = E.Counted(value, [item, '_'], BuildSchema(stack, context, schema.contains, item));
     return E.IsLessEqualThan(count, E.Constant(schema.maxContains));
 }

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

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import * as Schema from '../types/index.mjs';
-import { Unique } from './_unique.mjs';
+import * as Unique from './_unique.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -13,12 +13,12 @@ function IsValid(schema) {
 // Build
 // ------------------------------------------------------------------
 function BuildMinContainsStandard(stack, context, schema, value) {
-    const [item, index] = [Unique(), Unique()];
+    const [item, index] = [Unique.CreateUnique(), Unique.CreateUnique()];
     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 [item] = [Unique.CreateUnique()];
     const count = E.Counted(value, [item, '_'], BuildSchema(stack, context, schema.contains, item));
     return E.IsGreaterEqualThan(count, E.Constant(schema.minContains));
 }

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

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Reducer } from './_reducer.mjs';
-import { Unique } from './_unique.mjs';
+import * as Unique from './_unique.mjs';
 import { CheckContext, ErrorContext } from './_context.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
@@ -11,7 +11,7 @@ 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 [result] = [Unique.CreateUnique()];
     const results = E.ArrayLiteral(schema.oneOf.map((schema) => BuildSchema(stack, context, schema, value)));
     const count = E.Counted(results, [result, '_'], E.IsEqual(result, E.Constant(true)));
     return E.IsEqual(count, E.Constant(1));

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

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
+import * as Unique from './_unique.mjs';
 import * as Externals from './_externals.mjs';
 import * as Pathing from './_pathing.mjs';
-import { Unique } from './_unique.mjs';
 import { UnicodeRegExp } from './_regexp.mjs';
 import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
@@ -10,7 +10,7 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 export function BuildPatternProperties(stack, context, schema, value) {
     return E.ReduceAnd(G.Entries(schema.patternProperties).map(([pattern, schema]) => {
-        const [key, prop] = [Unique(), Unique()];
+        const [key, prop] = [Unique.CreateUnique(), Unique.CreateUnique()];
         const regexp = Externals.CreateVariable(UnicodeRegExp(pattern));
         const notKey = E.Not(E.Call(E.Member(regexp, 'test'), [key]));
         const isSchema = BuildSchemaPushStack(stack, context, schema, prop);

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

@@ -1,13 +1,13 @@
 // deno-fmt-ignore-file
 import * as Pathing from './_pathing.mjs';
-import { Unique } from './_unique.mjs';
+import * as Unique from './_unique.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
 export function BuildPropertyNames(stack, context, schema, value) {
-    const [key, _index] = [Unique(), Unique()];
+    const [key, _index] = [Unique.CreateUnique(), Unique.CreateUnique()];
     return E.Every(E.Keys(value), E.Constant(0), [key, _index], BuildSchema(stack, context, schema.propertyNames, key));
 }
 // ------------------------------------------------------------------

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

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { Unique } from './_unique.mjs';
+import * as Unique from './_unique.mjs';
 import { ErrorContext } from './_context.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
@@ -7,7 +7,7 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // Build
 // ------------------------------------------------------------------
 export function BuildUnevaluatedItems(stack, context, schema, value) {
-    const [index, item] = [Unique(), Unique()];
+    const [index, item] = [Unique.CreateUnique(), Unique.CreateUnique()];
     const indices = E.Call(E.Member('context', 'GetIndices'), []);
     const hasIndex = E.Call(E.Member('indices', 'has'), [index]);
     const isSchema = BuildSchema(stack, context, schema.unevaluatedItems, item);

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

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { Unique } from './_unique.mjs';
+import * as Unique from './_unique.mjs';
 import { ErrorContext } from './_context.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
@@ -7,7 +7,7 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // Build
 // ------------------------------------------------------------------
 export function BuildUnevaluatedProperties(stack, context, schema, value) {
-    const [key, prop] = [Unique(), Unique()];
+    const [key, prop] = [Unique.CreateUnique(), Unique.CreateUnique()];
     const keys = E.Call(E.Member('context', 'GetKeys'), []);
     const hasKey = E.Call(E.Member('keys', 'has'), [key]);
     const addKey = E.Call(E.Member('context', 'AddKey'), [key]);

package/node_modules/typebox/build/system/hashing/hash.mjs

@@ -1,16 +1,16 @@
 // deno-fmt-ignore-file
 import { Unreachable } from '../unreachable/index.mjs';
-import { Guard, GlobalsGuard } from '../../guard/index.mjs';
+import { GlobalsGuard, Guard } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // InstanceKeys
 //
-// Retrieves all enumerable and non-enumerable own property keys 
-// and inherited prototype keys (excluding symbols and the 'constructor') 
+// Retrieves all enumerable and non-enumerable own property keys
+// and inherited prototype keys (excluding symbols and the 'constructor')
 // from an object instance.
 //
-// This function is useful for differentiating between class instances 
-// based on their structural keys rather than relying on the 
-// constructor name. It provides a more reliable structural comparison 
+// This function is useful for differentiating between class instances
+// based on their structural keys rather than relying on the
+// constructor name. It provides a more reliable structural comparison
 // by capturing both own and prototype properties.
 //
 // ------------------------------------------------------------------
@@ -40,38 +40,57 @@ function IsIEEE754(value) {
 // ------------------------------------------------------------------
 // ByteMarker
 // ------------------------------------------------------------------
-var ByteMarker;
-(function (ByteMarker) {
-    ByteMarker[ByteMarker["Array"] = 0] = "Array";
-    ByteMarker[ByteMarker["BigInt"] = 1] = "BigInt";
-    ByteMarker[ByteMarker["Boolean"] = 2] = "Boolean";
-    ByteMarker[ByteMarker["Date"] = 3] = "Date";
-    ByteMarker[ByteMarker["Constructor"] = 4] = "Constructor";
-    ByteMarker[ByteMarker["Function"] = 5] = "Function";
-    ByteMarker[ByteMarker["Null"] = 6] = "Null";
-    ByteMarker[ByteMarker["Number"] = 7] = "Number";
-    ByteMarker[ByteMarker["Object"] = 8] = "Object";
-    ByteMarker[ByteMarker["RegExp"] = 9] = "RegExp";
-    ByteMarker[ByteMarker["String"] = 10] = "String";
-    ByteMarker[ByteMarker["Symbol"] = 11] = "Symbol";
-    ByteMarker[ByteMarker["TypeArray"] = 12] = "TypeArray";
-    ByteMarker[ByteMarker["Undefined"] = 13] = "Undefined";
-})(ByteMarker || (ByteMarker = {}));
+const ByteMarker = {
+    Array: 0x0,
+    BigInt: 0x1,
+    Boolean: 0x2,
+    Date: 0x3,
+    Constructor: 0x4,
+    Function: 0x5,
+    Null: 0x6,
+    Number: 0x7,
+    Object: 0x8,
+    RegExp: 0x9,
+    String: 0xA,
+    Symbol: 0xB,
+    TypeArray: 0xC,
+    Undefined: 0xD
+};
 // ------------------------------------------------------------------
 // State
 // ------------------------------------------------------------------
-let Accumulator = BigInt('14695981039346656037');
-const [Prime, Size] = [BigInt('1099511628211'), BigInt('18446744073709551616' /* 2 ^ 64 */)];
-const Bytes = Array.from({ length: 256 }).map((_, i) => BigInt(i));
+//
+// The 64-bit accumulator is held as four 16-bit limbs (A0 is the least
+// significant) so the FNV1A64 operation can be computed with number
+// arithmetic, avoiding a BigInt multiply and modulo for every byte.
+//
+// Offset: 14695981039346656037 (0xCBF29CE484222325)
+//
+// ------------------------------------------------------------------
+let A0 = 0x2325, A1 = 0x8422, A2 = 0x9CE4, A3 = 0xCBF2;
 const F64 = new Float64Array(1);
 const F64In = new DataView(F64.buffer);
 const F64Out = new Uint8Array(F64.buffer);
 // ------------------------------------------------------------------
 // Operation
+//
+// Prime: 1099511628211 (0x100000001B3 = 2^40 + 0x1B3)
+//
+// The multiply is computed as (A * 0x1B3) + (A << 40) modulo 2^64, 
+// where (A << 40) adds (A0 << 8) to the third limb and (A1 << 8) 
+// to the fourth.
+//
 // ------------------------------------------------------------------
 function FNV1A64_OP(byte) {
-    Accumulator = Accumulator ^ Bytes[byte];
-    Accumulator = (Accumulator * Prime) % Size;
+    const L0 = A0 ^ byte;
+    const T0 = L0 * 0x1B3;
+    const T1 = A1 * 0x1B3 + (T0 >>> 16);
+    const T2 = A2 * 0x1B3 + (T1 >>> 16) + (L0 << 8);
+    const T3 = A3 * 0x1B3 + (T2 >>> 16) + (A1 << 8);
+    A0 = T0 & 0xFFFF;
+    A1 = T1 & 0xFFFF;
+    A2 = T2 & 0xFFFF;
+    A3 = T3 & 0xFFFF;
 }
 // ------------------------------------------------------------------
 // Array
@@ -159,8 +178,15 @@ function FromRegExp(value) {
 const encoder = new TextEncoder();
 function FromString(value) {
     FNV1A64_OP(ByteMarker.String);
-    for (const byte of encoder.encode(value)) {
-        FNV1A64_OP(byte);
+    for (let i = 0; i < value.length; i++) {
+        const code = value.charCodeAt(i);
+        if (code > 0x7F) {
+            for (const byte of encoder.encode(value.slice(i))) {
+                FNV1A64_OP(byte);
+            }
+            return;
+        }
+        FNV1A64_OP(code);
     }
 }
 // ------------------------------------------------------------------
@@ -220,13 +246,16 @@ function FromValue(value) {
 // ------------------------------------------------------------------
 // Hash
 // ------------------------------------------------------------------
+function Hex(limb) {
+    return limb.toString(16).padStart(4, '0');
+}
 /** Generates a FNV1A-64 non cryptographic hash of the given value */
 export function HashCode(value) {
-    Accumulator = BigInt('14695981039346656037');
-    FromValue(value);
-    return Accumulator;
+    return BigInt(`0x${Hash(value)}`);
 }
 /** Generates a FNV1A-64 non cryptographic hash of the given value */
 export function Hash(value) {
-    return HashCode(value).toString(16).padStart(16, '0');
+    A0 = 0x2325, A1 = 0x8422, A2 = 0x9CE4, A3 = 0xCBF2;
+    FromValue(value);
+    return `${Hex(A3)}${Hex(A2)}${Hex(A1)}${Hex(A0)}`;
 }

package/node_modules/typebox/build/system/locale/en_US.mjs

@@ -33,7 +33,8 @@ export function en_US(error) {
         case 'unevaluatedProperties': return 'must not have unevaluated properties';
         case 'uniqueItems': return `must not have duplicate items`;
         case '~refine': return error.params.message;
-        // deno-coverage-ignore - unreachable
+        // deno-coverage-ignore-start - unreachable
         default: return 'an unknown validation error occurred';
+        // deno-coverage-ignore-stop
     }
 }

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;