@mikro-orm/core 7.2.6-dev.9 → 7.2.7-dev.0

package/entity/EntityFactory.d.ts

@@ -38,6 +38,13 @@ export declare class EntityFactory {
     constructor(em: EntityManager);
     /** Creates a new entity instance or returns an existing one from the identity map, hydrating it with the provided data. */
     create<T extends object, P extends string = string>(entityName: EntityName<T>, data: EntityData<T>, options?: FactoryOptions): New<T, P>;
+    /**
+     * Whether merging `data` into an initialized entity would change nothing: every key is a scalar the entity already
+     * holds by identity, and keys `mergeData` always re-applies (formula, version, generated, discriminator) match the snapshot.
+     */
+    private isNoopMerge;
+    /** Whether hydrating `value` into `prop` would leave `current` as is, mirroring the hydrator's Date and boolean coercion. */
+    private holdsValue;
     /** Merges new data into an existing entity, preserving user-modified properties. */
     mergeData<T extends object>(meta: EntityMetadata<T>, entity: T, data: EntityData<T>, options?: FactoryOptions): void;
     /** Creates or retrieves an uninitialized entity reference by its primary key or alternate key. */

package/entity/EntityFactory.js

@@ -149,8 +149,45 @@ export class EntityFactory {
         wrapped.__processing = false;
         return entity;
     }
+    /**
+     * Whether merging `data` into an initialized entity would change nothing: every key is a scalar the entity already
+     * holds by identity, and keys `mergeData` always re-applies (formula, version, generated, discriminator) match the snapshot.
+     */
+    isNoopMerge(meta, entity, data, options) {
+        const wrapped = helper(entity);
+        if (!wrapped.__initialized || options.normalizeAccessors) {
+            return false;
+        }
+        for (const key of Utils.keys(data)) {
+            const prop = meta.properties[key];
+            const value = data[key];
+            // custom types are left to the full merge, as their JS and database values can differ
+            if (!prop || prop.customType || value === undefined || !this.holdsValue(prop, entity[key], value)) {
+                return false;
+            }
+            const reapplied = prop.formula || prop.version || prop.generated || key === meta.root.discriminatorColumn;
+            if (reapplied && (wrapped.__originalEntityData?.[key] !== value || !wrapped.__loadedProperties.has(key))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /** Whether hydrating `value` into `prop` would leave `current` as is, mirroring the hydrator's Date and boolean coercion. */
+    holdsValue(prop, current, value) {
+        if (current instanceof Date && value instanceof Date) {
+            return current.getTime() === value.getTime();
+        }
+        if (prop.runtimeType === 'boolean' && value != null) {
+            return current === !!value;
+        }
+        return current === value;
+    }
     /** Merges new data into an existing entity, preserving user-modified properties. */
     mergeData(meta, entity, data, options = {}) {
+        // joined rows often repeat exactly what the entity already holds, skip the snapshot and diffing then
+        if (this.isNoopMerge(meta, entity, data, options)) {
+            return;
+        }
         // merge unchanged properties automatically
         data = QueryHelper.processParams(data);
         const existsData = this.#comparator.prepareEntity(entity);

package/entity/EntityLoader.js

@@ -815,7 +815,7 @@ export class EntityLoader {
         if ([ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(wrapped.__meta.properties[f].kind)) {
             return entity[f].getItems(false).every((item) => this.isPropertyLoaded(item, r.join('.')));
         }
-        return this.isPropertyLoaded(entity[f], r.join('.'));
+        return this.isPropertyLoaded(Reference.unwrapReference(entity[f]), r.join('.'));
     }
     filterReferences(entities, field, options, ref, populate) {
         if (ref) {

package/entity/defineEntity.d.ts

@@ -630,6 +630,21 @@ type AllKeys<TProperties, TBase> = keyof TProperties | (IsNever<TBase> extends t
 type PartialWhere<TProperties, TBase> = string | FilterQuery<{
     [K in AllKeys<TProperties, TBase> & string]?: unknown;
 }>;
+type DefineEntityFilterMap = Dictionary<{
+    name: string;
+    cond: Dictionary | ((args: Dictionary, type: 'read' | 'update' | 'delete', em: any, options?: FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any>, entityName?: string) => MaybePromise<FilterQuery<any>>);
+    default?: boolean;
+    entity?: EntityName<any> | EntityName<any>[];
+    args?: boolean;
+    strict?: boolean;
+    rls?: boolean | {
+        setting?: string;
+    };
+}>;
+type DefineEntityFilterMapLoose = Dictionary<{
+    name: string;
+    cond: Dictionary;
+}>;
 /** Metadata descriptor for `defineEntity()`, combining entity options with property definitions. */
 export interface EntityMetadataWithProperties<TName extends string, TTableName extends string, TProperties extends Record<string, any>, TPK extends (keyof TProperties)[] | undefined = undefined, TBase = never, TRepository = never, TForceObject extends boolean = false, TDiscriminatorColumn extends string | undefined = undefined, TDiscriminatorValue extends string | number | undefined = undefined, TBaseDiscriminatorColumn extends string | undefined = undefined, TEmbeddable extends boolean = false> extends Omit<Partial<EntityMetadata<InferEntityFromProperties<TProperties, TPK, TBase, TRepository>>>, 'properties' | 'extends' | 'primaryKeys' | 'hooks' | 'discriminator' | 'discriminatorColumn' | 'discriminatorValue' | 'versionProperty' | 'concurrencyCheckKeys' | 'serializedPrimaryKey' | 'indexes' | 'uniques' | 'triggers' | 'repository' | 'filters' | 'orderBy'> {
     name: TName;
@@ -644,17 +659,7 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
     primaryKeys?: TPK & NoInfer<InferPrimaryKeyConstraint<TProperties>>[];
     hooks?: DefineEntityHooks;
     repository?: () => TRepository;
-    filters?: Dictionary<{
-        name: string;
-        cond: Dictionary | ((args: Dictionary, type: 'read' | 'update' | 'delete', em: any, options?: FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any>, entityName?: string) => MaybePromise<FilterQuery<any>>);
-        default?: boolean;
-        entity?: EntityName<any> | EntityName<any>[];
-        args?: boolean;
-        strict?: boolean;
-        rls?: boolean | {
-            setting?: string;
-        };
-    }>;
+    filters?: DefineEntityFilterMap | IsNever<TRepository, never, DefineEntityFilterMapLoose>;
     forceObject?: TForceObject;
     embeddable?: TEmbeddable;
     inheritance?: 'tpt';

package/metadata/MetadataDiscovery.d.ts

@@ -34,6 +34,11 @@ export declare class MetadataDiscovery {
     private initManyToOneFields;
     private initOneToManyFields;
     private processEntity;
+    /**
+     * Groups the relations of all entities by target class name in one pass, so `findReferencingProperties()`
+     * does not go over the relations of every entity for each entity. Lists keep the order of `metadata` and `relations`.
+     */
+    private indexReferencingProperties;
     private findReferencingProperties;
     private initFactoryField;
     private ensureCorrectFKOrderInPivotEntity;

package/metadata/MetadataDiscovery.js

@@ -183,10 +183,11 @@ export class MetadataDiscovery {
         }
         discovered.forEach(meta => meta.sync(true));
         this.#metadataProvider.combineCache();
+        const referencingProperties = this.indexReferencingProperties(filtered);
         return discovered.map(meta => {
             meta = this.#metadata.get(meta.class);
             meta.sync(true);
-            this.findReferencingProperties(meta, filtered);
+            this.findReferencingProperties(meta, referencingProperties);
             if (meta.inheritanceType === 'tpt') {
                 this.computeTPTOwnProps(meta);
             }
@@ -217,18 +218,20 @@ export class MetadataDiscovery {
             .replace(/Array<(.*)>/, '$1') // unwrap array
             .replace(/\[]$/, '') // remove array suffix
             .replace(/\((.*)\)/, '$1'); // unwrap union types
+        const discoveredNames = new Set(this.#discovered.map(m => m.className));
         // Names can be ambiguous when a minifier mangles two classes to the same name,
         // so class references also need to be checked by identity.
+        const discoveredClasses = new Set(this.#discovered.map(m => m.class));
         const discoveredByIdentity = (target) => {
             const cls = EntitySchema.is(target) ? target.meta.class : target;
-            return typeof cls !== 'function' || this.#discovered.some(m => m.class === cls);
+            return typeof cls !== 'function' || discoveredClasses.has(cls);
         };
         const missing = [];
         this.#discovered.forEach(meta => Object.values(meta.properties).forEach(prop => {
             const indirect = (prop.kind === ReferenceKind.MANY_TO_MANY ? prop.pivotEntity : prop.through);
             if (indirect) {
                 const target = typeof indirect === 'function' && !indirect.prototype ? indirect() : indirect;
-                if (!this.#discovered.find(m => m.className === Utils.className(target)) || !discoveredByIdentity(target)) {
+                if (!discoveredNames.has(Utils.className(target)) || !discoveredByIdentity(target)) {
                     missing.push(target);
                 }
             }
@@ -236,7 +239,7 @@ export class MetadataDiscovery {
                 const target = typeof prop.entity === 'function' && !prop.entity.prototype ? prop.entity() : prop.type;
                 if (!unwrap(prop.type)
                     .split(/ ?\| ?/)
-                    .every(type => this.#discovered.find(m => m.className === type)) ||
+                    .every(type => discoveredNames.has(type)) ||
                     !Utils.asArray(target).every(discoveredByIdentity)) {
                     missing.push(...Utils.asArray(target));
                 }
@@ -302,7 +305,8 @@ export class MetadataDiscovery {
         if (validate) {
             this.#validator.validateDiscovered(this.#discovered, this.#config.get('discovery'));
         }
-        return this.#discovered.filter(meta => found.find(m => m.name === meta.className));
+        const foundNames = new Set(found.map(m => m.name));
+        return this.#discovered.filter(meta => foundNames.has(meta.className));
     }
     reset(entityName) {
         const exists = this.#discovered.findIndex(m => m.class === entityName || m.className === Utils.className(entityName));
@@ -668,20 +672,47 @@ export class MetadataDiscovery {
         }
         return [];
     }
-    findReferencingProperties(meta, metadata) {
+    /**
+     * Groups the relations of all entities by target class name in one pass, so `findReferencingProperties()`
+     * does not go over the relations of every entity for each entity. Lists keep the order of `metadata` and `relations`.
+     */
+    indexReferencingProperties(metadata) {
+        const index = { byType: new Map(), withTargetKey: new Map() };
+        const add = (map, key, value) => {
+            const list = map.get(key);
+            if (list) {
+                list.push(value);
+            }
+            else {
+                map.set(key, [value]);
+            }
+        };
         for (const meta2 of metadata) {
             for (const prop2 of meta2.relations) {
-                if (prop2.kind !== ReferenceKind.SCALAR && prop2.type === meta.className) {
-                    meta.referencingProperties.push({ meta: meta2, prop: prop2 });
+                if (prop2.kind !== ReferenceKind.SCALAR) {
+                    add(index.byType, prop2.type, [meta2, prop2]);
                 }
-                if (prop2.targetKey &&
-                    (prop2.type === meta.className || prop2.polymorphTargets?.some(t => t.className === meta.className)) &&
-                    !(meta.primaryKeys.length === 1 && meta.primaryKeys[0] === prop2.targetKey) &&
-                    !meta.root.targetKeys?.includes(prop2.targetKey)) {
-                    (meta.root.targetKeys ??= []).push(prop2.targetKey);
+                if (prop2.targetKey) {
+                    const targets = new Set([prop2.type, ...(prop2.polymorphTargets?.map(t => t.className) ?? [])]);
+                    for (const target of targets) {
+                        add(index.withTargetKey, target, prop2);
+                    }
                 }
             }
         }
+        return index;
+    }
+    findReferencingProperties(meta, index) {
+        for (const [meta2, prop2] of index.byType.get(meta.className) ?? []) {
+            meta.referencingProperties.push({ meta: meta2, prop: prop2 });
+        }
+        for (const prop2 of index.withTargetKey.get(meta.className) ?? []) {
+            const targetKey = prop2.targetKey;
+            if (!(meta.primaryKeys.length === 1 && meta.primaryKeys[0] === targetKey) &&
+                !meta.root.targetKeys?.includes(targetKey)) {
+                (meta.root.targetKeys ??= []).push(targetKey);
+            }
+        }
     }
     initFactoryField(meta, prop) {
         ['mappedBy', 'inversedBy', 'pivotEntity'].forEach(type => {
@@ -1904,9 +1935,9 @@ export class MetadataDiscovery {
         // guard preserves the legacy convention where JSON defaults are passed pre-stringified.
         // Array defaults are converted unconditionally (e.g. `default: []` on a JSON-backed embedded array).
         if (prop.customType && (Array.isArray(prop.default) || prop.customType.compareAsType() !== 'any')) {
-            val = prop.customType.convertToDatabaseValue(prop.default, this.#platform);
+            val = prop.customType.convertToDatabaseValue(prop.default, this.#platform, { mode: 'discovery' });
         }
-        prop.defaultRaw = typeof val === 'string' ? `'${val}'` : '' + val;
+        prop.defaultRaw = typeof val === 'string' ? this.#platform.quoteDefaultValue(val) : '' + val;
     }
     inferTypeFromDefault(prop) {
         if ((prop.defaultRaw == null && prop.default == null) || prop.type !== 'any') {

package/metadata/MetadataStorage.d.ts

@@ -9,6 +9,7 @@ export declare class MetadataStorage {
     /** Returns the global metadata dictionary, or a specific entry by entity name and path (keyed by the class reference when `target` is provided). */
     static getMetadata(): Dictionary<EntityMetadata>;
     static getMetadata<T = any>(entity: string, path: string, target?: EntityCtor): EntityMetadata<T>;
+    private static hashPath;
     /** Checks whether an entity with the given class name exists in the global metadata. */
     static isKnownEntity(name: string): boolean;
     /** Clears all entries from the global metadata registry. */

package/metadata/MetadataStorage.js

@@ -13,6 +13,10 @@ export class MetadataStorage {
     static PATH_SYMBOL = Symbol.for('@mikro-orm/core/MetadataStorage.PATH_SYMBOL');
     static META_SYMBOL = Symbol.for('@mikro-orm/core/MetadataStorage.META_SYMBOL');
     static #metadata = getGlobalStorage('metadata');
+    /** Lives in the global storage next to the registry, so it stays in sync when several copies of this module share it (e.g. after `vi.resetModules()`). */
+    static #classNames = getGlobalStorage('metadata-class-names');
+    /** Hashes of entity file paths, decorators call `getMetadata()` with the same path for every decorated member. */
+    static #pathHashes = new Map();
     #metadataMap = new Map();
     #idMap;
     #classNameMap;
@@ -31,7 +35,7 @@ export class MetadataStorage {
         }
     }
     static getMetadata(entity, path, target) {
-        const key = entity && path ? entity + '-' + Utils.hash(path) : null;
+        const key = entity && path ? entity + '-' + MetadataStorage.hashPath(path) : null;
         // Key the registry by the class reference when available, so two classes minified
         // to the same mangled name don't collide on the `className-path` key.
         if (key && target) {
@@ -43,23 +47,36 @@ export class MetadataStorage {
             }
             // Keep the name-keyed entry in sync, the class-keyed metadata survives `MetadataStorage.clear()`.
             MetadataStorage.#metadata[key] = target[MetadataStorage.META_SYMBOL];
+            MetadataStorage.#classNames.names?.add(target[MetadataStorage.META_SYMBOL].className);
             return target[MetadataStorage.META_SYMBOL];
         }
         if (key && !MetadataStorage.#metadata[key]) {
-            MetadataStorage.#metadata[key] = new EntityMetadata({ className: entity, path });
+            const meta = new EntityMetadata({ className: entity, path });
+            MetadataStorage.#metadata[key] = meta;
+            MetadataStorage.#classNames.names?.add(meta.className);
         }
         if (key) {
             return MetadataStorage.#metadata[key];
         }
         return MetadataStorage.#metadata;
     }
+    static hashPath(path) {
+        let hash = MetadataStorage.#pathHashes.get(path);
+        if (hash === undefined) {
+            hash = Utils.hash(path);
+            MetadataStorage.#pathHashes.set(path, hash);
+        }
+        return hash;
+    }
     /** Checks whether an entity with the given class name exists in the global metadata. */
     static isKnownEntity(name) {
-        return !!Object.values(this.#metadata).find(meta => meta.className === name);
+        this.#classNames.names ??= new Set(Object.values(this.#metadata).map(meta => meta.className));
+        return this.#classNames.names.has(name);
     }
     /** Clears all entries from the global metadata registry. */
     static clear() {
         Object.keys(this.#metadata).forEach(k => delete this.#metadata[k]);
+        delete this.#classNames.names;
     }
     /** Returns the map of all registered entity metadata. */
     getAll() {

package/metadata/MetadataValidator.js

@@ -118,12 +118,13 @@ export class MetadataValidator {
             return Utils.className(p);
         };
         const pivotProps = new Map();
+        const discoveredNames = new Set(discovered.map(m => m.className));
         // check for not discovered entities
         discovered.forEach(meta => Object.values(meta.properties).forEach(prop => {
             if (prop.kind !== ReferenceKind.SCALAR &&
                 !unwrap(prop.type)
                     .split(/ ?\| ?/)
-                    .every(type => discovered.find(m => m.className === type))) {
+                    .every(type => discoveredNames.has(type))) {
                 throw MetadataError.fromUnknownEntity(prop.type, `${meta.className}.${prop.name}`);
             }
             if (prop.pivotEntity) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.2.6-dev.9",
+  "version": "7.2.7-dev.0",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "keywords": [
     "data-mapper",

package/platforms/Platform.d.ts

@@ -274,6 +274,8 @@ export declare abstract class Platform {
     }, quote?: string): string;
     /** Quotes a literal value for safe embedding in SQL. */
     quoteValue(value: any): string;
+    /** Quotes a string default value for DDL; dialects that escape with backslashes override this. */
+    quoteDefaultValue(value: string): string;
     escape(value: any): string;
     /** Replaces `?` placeholders in SQL with quoted parameter values. */
     formatQuery(sql: string, params: readonly any[]): string;

package/platforms/Platform.js

@@ -573,6 +573,10 @@ export class Platform {
     quoteValue(value) {
         return value;
     }
+    /** Quotes a string default value for DDL; dialects that escape with backslashes override this. */
+    quoteDefaultValue(value) {
+        return `'${value.replaceAll("'", "''")}'`;
+    }
     /* v8 ignore next */
     escape(value) {
         return value;

package/typings.js

@@ -304,8 +304,11 @@ export class EntityMetadata {
         }, { __gettersDefined: { value: true, enumerable: false } });
     }
     initIndexes(prop) {
-        const simpleIndex = this.indexes.find(index => index.properties === prop.name && !index.options && !index.type && !index.expression && index.where == null);
-        const simpleUnique = this.uniques.find(index => index.properties === prop.name && !index.options && !index.expression && index.where == null);
+        // `prop.index`/`prop.unique` keep only the name, so an index with any other option must stay in `meta.indexes`
+        const isSimple = (index) => index.properties === prop.name &&
+            Object.entries(index).every(([key, value]) => key === 'name' || key === 'properties' || value == null);
+        const simpleIndex = this.indexes.find(isSimple);
+        const simpleUnique = this.uniques.find(isSimple);
         const owner = prop.kind === ReferenceKind.MANY_TO_ONE;
         if (!prop.index && simpleIndex) {
             Utils.defaultValue(simpleIndex, 'name', true);

package/utils/EntityComparator.js

@@ -1,6 +1,7 @@
 import { clone } from './clone.js';
 import { ReferenceKind } from '../enums.js';
 import { compareArrays, compareBooleans, compareBuffers, compareObjects, equals, parseJsonSafe, Utils, } from './Utils.js';
+import { DateType } from '../types/DateType.js';
 import { JsonType } from '../types/JsonType.js';
 import { Raw } from './RawQueryFragment.js';
 import { EntityIdentifier } from '../entity/EntityIdentifier.js';
@@ -395,6 +396,14 @@ export class EntityComparator {
                     lines.push(`${padding}    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
                     lines.push(`${padding}  }`);
                 }
+                else if (prop.customType instanceof DateType) {
+                    // tedious returns DATE columns as `Date`, map them to the string the entity holds, so the snapshot matches it
+                    context.set('convertDateToJSValue', (value) => this.#platform.convertDateToJSValue(value));
+                    lines.push(`${padding}  if (${defined}) {`);
+                    lines.push(`${padding}    ret${this.wrap(prop.name)} = ${this.propName(prop.fieldNames[0])} instanceof Date ? convertDateToJSValue(${this.propName(prop.fieldNames[0])}) : ${this.propName(prop.fieldNames[0])};`);
+                    lines.push(`${padding}    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
+                    lines.push(`${padding}  }`);
+                }
                 else if (prop.kind === ReferenceKind.EMBEDDED && (prop.object || meta.embeddable)) {
                     const idx = this.#tmpIndex++;
                     context.set(`mapEmbeddedResult_${idx}`, (data) => {

package/utils/QueryHelper.js

@@ -308,6 +308,13 @@ export class QueryHelper {
                 o[key] = { [op]: value };
                 return o;
             }
+            // `$all` items are matched like separate `$some` payloads, so they need the same processing
+            if (key === '$all' && Array.isArray(value)) {
+                o[key] = value.map(item => Utils.isPlainObject(item)
+                    ? QueryHelper.processWhere({ ...options, where: item, entityName, root: false })
+                    : item);
+                return o;
+            }
             if (Utils.isPlainObject(value)) {
                 o[key] = QueryHelper.processWhere({
                     ...options,

package/utils/Utils.js

@@ -153,7 +153,7 @@ export function parseJsonSafe(value) {
 /** Collection of general-purpose utility methods used throughout the ORM. */
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.2.6-dev.9';
+    static #ORM_VERSION = '7.2.7-dev.0';
     /** Default session variable name backing an RLS filter argument (`current_setting('mikro.<filter>.<arg>')`). */
     static getRlsSettingName(filterName, argName) {
         return `mikro.${filterName}.${argName}`;
@@ -651,14 +651,19 @@ export class Utils {
     static isCollection(item) {
         return Collection.isCollection(item);
     }
-    // FNV-1a 64-bit
+    // FNV-1a 64-bit, computed on two uint32 halves instead of a BigInt. The prime is 2^40 + 0x1b3, so
+    // `h * prime mod 2^64` is `h * 0x1b3` plus the low half shifted up by 40 bits. Every partial product
+    // stays below 2^41, so the double arithmetic is exact.
     static hash(data, length) {
-        let h1 = 0xcbf29ce484222325n;
+        let hi = 0xcbf29ce4;
+        let lo = 0x84222325;
         for (let i = 0; i < data.length; i++) {
-            h1 ^= BigInt(data.charCodeAt(i));
-            h1 = (h1 * 0x100000001b3n) & 0xffffffffffffffffn;
+            lo = (lo ^ data.charCodeAt(i)) >>> 0;
+            const loProduct = lo * 0x1b3;
+            hi = (((hi * 0x1b3) >>> 0) + Math.floor(loProduct / 0x100000000) + ((lo << 8) >>> 0)) >>> 0;
+            lo = loProduct >>> 0;
         }
-        const hash = h1.toString(16).padStart(16, '0');
+        const hash = hi.toString(16).padStart(8, '0') + lo.toString(16).padStart(8, '0');
         if (length) {
             return hash.substring(0, length);
         }

package/utils/clone.js

@@ -22,8 +22,8 @@ function getPropertyDescriptor(obj, prop) {
 }
 const TypedArray = Object.getPrototypeOf(Uint8Array);
 export function clone(parent, respectCustomCloneMethod = true) {
-    const allParents = [];
-    const allChildren = [];
+    // already cloned objects, so shared references and cycles map to a single clone
+    const clones = new Map();
     function _clone(parent) {
         // cloning null always returns null
         if (parent === null) {
@@ -92,12 +92,10 @@ export function clone(parent, respectCustomCloneMethod = true) {
             proto = Object.getPrototypeOf(parent);
             child = Object.create(proto);
         }
-        const index = allParents.indexOf(parent);
-        if (index !== -1) {
-            return allChildren[index];
+        if (clones.has(parent)) {
+            return clones.get(parent);
         }
-        allParents.push(parent);
-        allChildren.push(child);
+        clones.set(parent, child);
         if (parent instanceof Map) {
             parent.forEach((value, key) => {
                 const keyChild = _clone(key);