ts-patch-mongoose 2.9.6 → 3.0.0

package/src/hooks/update-hooks.ts

@@ -1,12 +1,5 @@
-// Using CJS lodash with .js extensions for ESM compatibility
-import cloneDeep from 'lodash/cloneDeep.js'
-import forEach from 'lodash/forEach.js'
-import isArray from 'lodash/isArray.js'
-import isEmpty from 'lodash/isEmpty.js'
-import isObjectLike from 'lodash/isObjectLike.js'
-import keys from 'lodash/keys.js'
 import { assign } from 'power-assign'
-import { isHookIgnored, toObjectOptions } from '../helpers'
+import { cloneDeep, isArray, isEmpty, isHookIgnored, isObjectLike, toObjectOptions } from '../helpers'
 import { createPatch, updatePatch } from '../patch'
 
 import type { HydratedDocument, Model, MongooseQueryMiddleware, Schema, UpdateQuery, UpdateWithAggregationPipeline } from 'mongoose'
@@ -16,14 +9,13 @@ const updateMethods = ['update', 'updateOne', 'replaceOne', 'updateMany', 'findO
 
 export const assignUpdate = <T>(document: HydratedDocument<T>, update: UpdateQuery<T>, commands: Record<string, unknown>[]): HydratedDocument<T> => {
   let updated = assign(document.toObject(toObjectOptions), update)
-  // Try catch not working for of loop, keep it as is
-  forEach(commands, (command) => {
+  for (const command of commands) {
     try {
       updated = assign(updated, command)
     } catch {
       // we catch assign keys that are not implemented
     }
-  })
+  }
 
   const doc = document.set(updated).toObject(toObjectOptions) as HydratedDocument<T> & { createdAt?: Date }
   if (update.createdAt) doc.createdAt = update.createdAt
@@ -36,12 +28,12 @@ export const splitUpdateAndCommands = <T>(updateQuery: UpdateWithAggregationPipe
 
   if (!isEmpty(updateQuery) && !isArray(updateQuery) && isObjectLike(updateQuery)) {
     update = cloneDeep(updateQuery)
-    const keysWithDollarSign = keys(update).filter((key) => key.startsWith('$'))
+    const keysWithDollarSign = Object.keys(update).filter((key) => key.startsWith('$'))
     if (!isEmpty(keysWithDollarSign)) {
-      forEach(keysWithDollarSign, (key) => {
+      for (const key of keysWithDollarSign) {
         commands.push({ [key]: update[key] as unknown })
         delete update[key]
-      })
+      }
     }
   }
 
@@ -98,7 +90,6 @@ export const updateHooksInitialize = <T>(schema: Schema<T>, opts: PluginOptions<
     }
 
     if (!isEmpty(filter) && !current) {
-      console.log('filter', filter)
       current = (await model.findOne(filter).sort('desc').lean().exec()) as HydratedDocument<T>
     }
 

package/src/index.ts

@@ -1,6 +1,4 @@
-// Using CJS lodash with .js extension for ESM compatibility
-import isEmpty from 'lodash/isEmpty.js'
-import { toObjectOptions } from './helpers'
+import { isEmpty, toObjectOptions } from './helpers'
 import { deleteHooksInitialize } from './hooks/delete-hooks'
 import { saveHooksInitialize } from './hooks/save-hooks'
 import { updateHooksInitialize } from './hooks/update-hooks'
@@ -12,34 +10,17 @@ import type { PatchContext, PluginOptions } from './types'
 
 const remove = isMongooseLessThan7 ? 'remove' : 'deleteOne'
 
-/**
- * @description Event emitter for patch operations.
- */
 export { default as patchEventEmitter } from './em'
 export { setPatchHistoryTTL } from './helpers'
 export * from './types'
 
-/**
- * @description Mongoose plugin to track and manage patch history for documents.
- * This plugin initializes hooks for save, update, and delete operations to create
- * and manage patches.
- *
- * @template T
- * @param {Schema<T>} schema - The Mongoose schema to apply the plugin to.
- * @param {PluginOptions<T>} opts - Options for configuring the plugin.
- * @returns {void}
- */
-export const patchHistoryPlugin = function plugin<T>(schema: Schema<T>, opts: PluginOptions<T>): void {
-  // Initialize hooks
+export type { Duration } from './ms'
+
+export const patchHistoryPlugin = <T>(schema: Schema<T>, opts: PluginOptions<T>): void => {
   saveHooksInitialize(schema, opts)
   updateHooksInitialize(schema, opts)
   deleteHooksInitialize(schema, opts)
 
-  /**
-   * @description Corner case for insertMany()
-   * @param {Array<HydratedDocument<T>>} docs - The documents being inserted.
-   * @returns {Promise<void>}
-   */
   schema.post('insertMany', async function (docs) {
     const context = {
       op: 'create',
@@ -55,10 +36,6 @@ export const patchHistoryPlugin = function plugin<T>(schema: Schema<T>, opts: Pl
   // In Mongoose 7, doc.deleteOne() returned a promise that resolved to doc.
   // In Mongoose 8, doc.deleteOne() returns a query for easier chaining, as well as consistency with doc.updateOne().
   if (isMongooseLessThan8) {
-    /**
-     * @description Pre-delete hook for Mongoose 7 and below
-     * @returns {Promise<void>}
-     */
     // @ts-expect-error - Mongoose 7 and below
     schema.pre(remove, { document: true, query: false }, async function () {
       // @ts-expect-error - Mongoose 7 and below
@@ -69,11 +46,6 @@ export const patchHistoryPlugin = function plugin<T>(schema: Schema<T>, opts: Pl
       }
     })
 
-    /**
-     * @description Post-delete hook for Mongoose 7 and below
-     * @param {HydratedDocument<T>} this - The document being deleted.
-     * @returns {Promise<void>}
-     */
     // @ts-expect-error - Mongoose 7 and below
     schema.post(remove, { document: true, query: false }, async function (this: HydratedDocument<T>) {
       const original = this.toObject(toObjectOptions) as HydratedDocument<T>

package/src/ms.ts

@@ -0,0 +1,66 @@
+const s = 1000
+const m = s * 60
+const h = m * 60
+const d = h * 24
+const w = d * 7
+const y = d * 365.25
+const mo = y / 12
+
+export const UNITS = {
+  milliseconds: 1,
+  millisecond: 1,
+  msecs: 1,
+  msec: 1,
+  ms: 1,
+  seconds: s,
+  second: s,
+  secs: s,
+  sec: s,
+  s,
+  minutes: m,
+  minute: m,
+  mins: m,
+  min: m,
+  m,
+  hours: h,
+  hour: h,
+  hrs: h,
+  hr: h,
+  h,
+  days: d,
+  day: d,
+  d,
+  weeks: w,
+  week: w,
+  w,
+  months: mo,
+  month: mo,
+  mo,
+  years: y,
+  year: y,
+  yrs: y,
+  yr: y,
+  y,
+} as const satisfies Record<string, number>
+
+export type Unit = keyof typeof UNITS
+
+export type Duration = number | `${number}` | `${number}${Unit}` | `${number} ${Unit}`
+
+const unitPattern = Object.keys(UNITS)
+  .sort((a, b) => b.length - a.length)
+  .join('|')
+
+const RE = new RegExp(String.raw`^(-?(?:\d+)?\.?\d+)\s*(${unitPattern})?$`, 'i')
+
+export const ms = (val: Duration): number => {
+  const str = String(val)
+  if (str.length > 100) return Number.NaN
+
+  const match = RE.exec(str)
+  if (!match) return Number.NaN
+
+  const n = Number.parseFloat(match[1] ?? '')
+  const type = (match[2] ?? 'ms').toLowerCase()
+  return n * (UNITS[type as Unit] ?? 0)
+}

package/src/omit-deep.ts

@@ -0,0 +1,95 @@
+const isPlainObject = (val: unknown): val is Record<string, unknown> => {
+  if (Object.prototype.toString.call(val) !== '[object Object]') return false
+  const prot = Object.getPrototypeOf(val) as object | null
+  return prot === null || prot === Object.prototype
+}
+
+const isUnsafeKey = (key: string): boolean => {
+  return key === '__proto__' || key === 'constructor' || key === 'prototype'
+}
+
+const getValue = (obj: Record<string, unknown>, path: string): unknown => {
+  const segs = path.split('.')
+  let current: unknown = obj
+  for (const seg of segs) {
+    if (current == null || typeof current !== 'object') return undefined
+    current = (current as Record<string, unknown>)[seg]
+  }
+  return current
+}
+
+const hasValue = (val: unknown): boolean => {
+  if (val == null) return false
+  if (typeof val === 'boolean' || typeof val === 'number' || typeof val === 'function') return true
+  if (typeof val === 'string') return val.length !== 0
+  if (Array.isArray(val)) return val.length !== 0
+  if (val instanceof RegExp) return val.source !== '(?:)' && val.source !== ''
+  if (val instanceof Error) return val.message !== ''
+  if (val instanceof Map || val instanceof Set) return val.size !== 0
+  if (typeof val === 'object') {
+    for (const key of Object.keys(val)) {
+      if (hasValue((val as Record<string, unknown>)[key])) return true
+    }
+    return false
+  }
+  return true
+}
+
+const has = (obj: unknown, path: string): boolean => {
+  if (obj != null && typeof obj === 'object' && typeof path === 'string') {
+    return hasValue(getValue(obj as Record<string, unknown>, path))
+  }
+  return false
+}
+
+const unset = (obj: Record<string, unknown>, prop: string): boolean => {
+  if (typeof obj !== 'object' || obj === null) return false
+
+  if (Object.hasOwn(obj, prop)) {
+    delete obj[prop]
+    return true
+  }
+
+  if (has(obj, prop)) {
+    const segs = prop.split('.')
+    let last = segs.pop()
+    while (segs.length && segs.at(-1)?.slice(-1) === '\\') {
+      last = `${(segs.pop() as string).slice(0, -1)}.${last}`
+    }
+    let target: unknown = obj
+    while (segs.length) {
+      const seg = segs.shift() as string
+      if (isUnsafeKey(seg)) return false
+      target = (target as Record<string, unknown>)[seg]
+    }
+    return delete (target as Record<string, unknown>)[last ?? '']
+  }
+
+  return true
+}
+
+export const omitDeep = <T>(value: T, keys: string | string[]): T => {
+  if (value === undefined) return {} as T
+
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      value[i] = omitDeep(value[i], keys)
+    }
+    return value
+  }
+
+  if (!isPlainObject(value)) return value
+
+  const omitKeys = typeof keys === 'string' ? [keys] : keys
+  if (!Array.isArray(omitKeys)) return value
+
+  for (const key of omitKeys) {
+    unset(value, key)
+  }
+
+  for (const key of Object.keys(value)) {
+    ;(value as Record<string, unknown>)[key] = omitDeep((value as Record<string, unknown>)[key], omitKeys)
+  }
+
+  return value
+}

package/src/patch.ts

@@ -1,20 +1,18 @@
 import jsonpatch from 'fast-json-patch'
-// Using CJS lodash with .js extensions for ESM compatibility
-import chunk from 'lodash/chunk.js'
-import isEmpty from 'lodash/isEmpty.js'
-import isFunction from 'lodash/isFunction.js'
-import omit from 'omit-deep'
 import em from './em'
+import { chunk, isEmpty, isFunction } from './helpers'
 import { HistoryModel } from './model'
+import { omitDeep as omit } from './omit-deep'
 
 import type { HydratedDocument, MongooseError, Types } from 'mongoose'
 import type { Metadata, PatchContext, PatchEvent, PluginOptions, User } from './types'
 
-function isPatchHistoryEnabled<T>(opts: PluginOptions<T>, context: PatchContext<T>): boolean {
+const isPatchHistoryEnabled = <T>(opts: PluginOptions<T>, context: PatchContext<T>): boolean => {
   return !opts.patchHistoryDisabled && !context.ignorePatchHistory
 }
 
-export function getJsonOmit<T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Partial<T> {
+export const getJsonOmit = <T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Partial<T> => {
+  // NOSONAR — structuredClone cannot handle mongoose documents (they contain non-cloneable methods)
   const object = JSON.parse(JSON.stringify(doc)) as Partial<T>
 
   if (opts.omit) {
@@ -24,7 +22,7 @@ export function getJsonOmit<T>(opts: PluginOptions<T>, doc: HydratedDocument<T>)
   return object
 }
 
-export function getObjectOmit<T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Partial<T> {
+export const getObjectOmit = <T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Partial<T> => {
   if (opts.omit) {
     return omit(isFunction(doc?.toObject) ? doc.toObject() : doc, opts.omit)
   }
@@ -32,56 +30,56 @@ export function getObjectOmit<T>(opts: PluginOptions<T>, doc: HydratedDocument<T
   return doc
 }
 
-export async function getUser<T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Promise<User | undefined> {
+export const getUser = async <T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Promise<User | undefined> => {
   if (isFunction(opts.getUser)) {
     return await opts.getUser(doc)
   }
   return undefined
 }
 
-export async function getReason<T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Promise<string | undefined> {
+export const getReason = async <T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Promise<string | undefined> => {
   if (isFunction(opts.getReason)) {
     return await opts.getReason(doc)
   }
   return undefined
 }
 
-export async function getMetadata<T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Promise<Metadata | undefined> {
+export const getMetadata = async <T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Promise<Metadata | undefined> => {
   if (isFunction(opts.getMetadata)) {
     return await opts.getMetadata(doc)
   }
   return undefined
 }
 
-export function getValue<T>(item: PromiseSettledResult<T>): T | undefined {
+export const getValue = <T>(item: PromiseSettledResult<T>): T | undefined => {
   return item.status === 'fulfilled' ? item.value : undefined
 }
 
-export async function getData<T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Promise<[User | undefined, string | undefined, Metadata | undefined]> {
+export const getData = async <T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Promise<[User | undefined, string | undefined, Metadata | undefined]> => {
   return Promise.allSettled([getUser(opts, doc), getReason(opts, doc), getMetadata(opts, doc)]).then(([user, reason, metadata]) => {
     return [getValue(user), getValue(reason), getValue(metadata)]
   })
 }
 
-export function emitEvent<T>(context: PatchContext<T>, event: string | undefined, data: PatchEvent<T>): void {
+export const emitEvent = <T>(context: PatchContext<T>, event: string | undefined, data: PatchEvent<T>): void => {
   if (event && !context.ignoreEvent) {
     em.emit(event, data)
   }
 }
 
-export async function bulkPatch<T>(opts: PluginOptions<T>, context: PatchContext<T>, eventKey: 'eventCreated' | 'eventDeleted', docsKey: 'createdDocs' | 'deletedDocs'): Promise<void> {
+export const bulkPatch = async <T>(opts: PluginOptions<T>, context: PatchContext<T>, eventKey: 'eventCreated' | 'eventDeleted', docsKey: 'createdDocs' | 'deletedDocs'): Promise<void> => {
   const history = isPatchHistoryEnabled(opts, context)
   const event = opts[eventKey]
   const docs = context[docsKey]
   const key = eventKey === 'eventCreated' ? 'doc' : 'oldDoc'
 
-  if (isEmpty(docs) || (!event && !history)) return
+  if (isEmpty(docs) || !docs || (!event && !history)) return
 
   const chunks = chunk(docs, 1000)
-  for (const chunk of chunks) {
+  for (const batch of chunks) {
     const bulk = []
 
-    for (const doc of chunk) {
+    for (const doc of batch) {
       emitEvent(context, event, { [key]: doc })
 
       if (history) {
@@ -112,11 +110,11 @@ export async function bulkPatch<T>(opts: PluginOptions<T>, context: PatchContext
   }
 }
 
-export async function createPatch<T>(opts: PluginOptions<T>, context: PatchContext<T>): Promise<void> {
+export const createPatch = async <T>(opts: PluginOptions<T>, context: PatchContext<T>): Promise<void> => {
   await bulkPatch(opts, context, 'eventCreated', 'createdDocs')
 }
 
-export async function updatePatch<T>(opts: PluginOptions<T>, context: PatchContext<T>, current: HydratedDocument<T>, original: HydratedDocument<T>): Promise<void> {
+export const updatePatch = async <T>(opts: PluginOptions<T>, context: PatchContext<T>, current: HydratedDocument<T>, original: HydratedDocument<T>): Promise<void> => {
   const history = isPatchHistoryEnabled(opts, context)
 
   const currentObject = getJsonOmit(opts, current)
@@ -154,6 +152,6 @@ export async function updatePatch<T>(opts: PluginOptions<T>, context: PatchConte
   }
 }
 
-export async function deletePatch<T>(opts: PluginOptions<T>, context: PatchContext<T>): Promise<void> {
+export const deletePatch = async <T>(opts: PluginOptions<T>, context: PatchContext<T>): Promise<void> => {
   await bulkPatch(opts, context, 'eventDeleted', 'deletedDocs')
 }

package/src/version.ts

@@ -1,9 +1,10 @@
 import mongoose from 'mongoose'
-import { satisfies } from 'semver'
 
-export const isMongooseLessThan8 = satisfies(mongoose.version, '<8')
-export const isMongooseLessThan7 = satisfies(mongoose.version, '<7')
-export const isMongoose6 = satisfies(mongoose.version, '6')
+const major = Number.parseInt(mongoose.version, 10)
+
+export const isMongooseLessThan8 = major < 8
+export const isMongooseLessThan7 = major < 7
+export const isMongoose6 = major === 6
 
 /* v8 ignore start */
 if (isMongoose6) {

package/tests/em.test.ts

@@ -27,6 +27,7 @@ describe('em', () => {
       collectionName: 'tests',
     }
 
+    // @ts-expect-error expected
     emitEvent(context, 'test', { doc: { name: 'test' } })
     expect(fn).toHaveBeenCalledTimes(1)
 
@@ -44,6 +45,7 @@ describe('em', () => {
       collectionName: 'tests',
     }
 
+    // @ts-expect-error expected
     emitEvent(context, 'test', { doc: { name: 'test' } })
     expect(fn).toHaveBeenCalledTimes(0)
 

package/tests/helpers.test.ts

@@ -1,9 +1,9 @@
 import type { Mock, MockInstance } from 'vitest'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
-import ms from 'ms'
-import { setPatchHistoryTTL } from '../src/helpers'
+import { cloneDeep, isEmpty, setPatchHistoryTTL } from '../src/helpers'
 import { HistoryModel } from '../src/model'
+import { ms } from '../src/ms'
 
 vi.mock('../src/model', () => ({
   HistoryModel: {
@@ -82,3 +82,230 @@ describe('useTTL', () => {
     expect(createIndexSpy).toHaveBeenCalledWith({ createdAt: 1 }, { expireAfterSeconds, name })
   })
 })
+
+describe('isEmpty', () => {
+  it('should return true for null and undefined', () => {
+    expect(isEmpty(null)).toBe(true)
+    expect(isEmpty(undefined)).toBe(true)
+  })
+
+  it('should return true for empty arrays and strings', () => {
+    expect(isEmpty([])).toBe(true)
+    expect(isEmpty('')).toBe(true)
+  })
+
+  it('should return false for non-empty arrays and strings', () => {
+    expect(isEmpty([1, 2])).toBe(false)
+    expect(isEmpty('hello')).toBe(false)
+  })
+
+  it('should return true for empty objects', () => {
+    expect(isEmpty({})).toBe(true)
+  })
+
+  it('should return false for non-empty objects', () => {
+    expect(isEmpty({ a: 1 })).toBe(false)
+  })
+
+  it('should return true for empty Map and Set', () => {
+    expect(isEmpty(new Map())).toBe(true)
+    expect(isEmpty(new Set())).toBe(true)
+  })
+
+  it('should return false for non-empty Map and Set', () => {
+    expect(isEmpty(new Map([['a', 1]]))).toBe(false)
+    expect(isEmpty(new Set([1]))).toBe(false)
+  })
+
+  it('should return true for numbers, booleans, and functions (matches lodash)', () => {
+    expect(isEmpty(0)).toBe(true)
+    expect(isEmpty(1)).toBe(true)
+    expect(isEmpty(true)).toBe(true)
+    expect(isEmpty(false)).toBe(true)
+    expect(isEmpty(() => {})).toBe(true)
+  })
+
+  it('should return true for Date and RegExp (matches lodash)', () => {
+    expect(isEmpty(new Date())).toBe(true)
+    expect(isEmpty(/test/)).toBe(true)
+  })
+})
+
+describe('cloneDeep', () => {
+  it('should clone primitives', () => {
+    expect(cloneDeep(42)).toBe(42)
+    expect(cloneDeep('hello')).toBe('hello')
+    expect(cloneDeep(null)).toBe(null)
+    expect(cloneDeep(undefined)).toBe(undefined)
+    expect(cloneDeep(true)).toBe(true)
+  })
+
+  it('should deep clone plain objects', () => {
+    const original = { a: 1, b: { c: 2 } }
+    const cloned = cloneDeep(original)
+    expect(cloned).toEqual(original)
+    expect(cloned).not.toBe(original)
+    expect(cloned.b).not.toBe(original.b)
+  })
+
+  it('should deep clone arrays', () => {
+    const original = [1, [2, 3], { a: 4 }]
+    const cloned = cloneDeep(original)
+    expect(cloned).toEqual(original)
+    expect(cloned).not.toBe(original)
+    expect(cloned[1]).not.toBe(original[1])
+    expect(cloned[2]).not.toBe(original[2])
+  })
+
+  it('should clone Date instances', () => {
+    const original = new Date('2026-01-01')
+    const cloned = cloneDeep(original)
+    expect(cloned).toEqual(original)
+    expect(cloned).not.toBe(original)
+    expect(cloned.getTime()).toBe(original.getTime())
+  })
+
+  it('should clone RegExp instances', () => {
+    const original = /test/gi
+    const cloned = cloneDeep(original)
+    expect(cloned).not.toBe(original)
+    expect(cloned.source).toBe(original.source)
+    expect(cloned.flags).toBe(original.flags)
+  })
+
+  it('should clone Map instances', () => {
+    const original = new Map([['a', { nested: 1 }]])
+    const cloned = cloneDeep(original)
+    expect(cloned).not.toBe(original)
+    expect(cloned.get('a')).toEqual({ nested: 1 })
+    expect(cloned.get('a')).not.toBe(original.get('a'))
+  })
+
+  it('should clone Set instances', () => {
+    const obj = { a: 1 }
+    const original = new Set([obj])
+    const cloned = cloneDeep(original)
+    expect(cloned).not.toBe(original)
+    expect(cloned.size).toBe(1)
+    const [clonedItem] = cloned
+    expect(clonedItem).toEqual(obj)
+    expect(clonedItem).not.toBe(obj)
+  })
+
+  it('should handle circular references in objects', () => {
+    const original: Record<string, unknown> = { a: 1 }
+    original.self = original
+    const cloned = cloneDeep(original)
+    expect(cloned.a).toBe(1)
+    expect(cloned.self).toBe(cloned)
+    expect(cloned).not.toBe(original)
+  })
+
+  it('should handle circular references in arrays', () => {
+    const original: unknown[] = [1, 2]
+    original.push(original)
+    const cloned = cloneDeep(original)
+    expect(cloned[0]).toBe(1)
+    expect(cloned[1]).toBe(2)
+    expect(cloned[2]).toBe(cloned)
+    expect(cloned).not.toBe(original)
+  })
+
+  it('should handle circular references in nested objects', () => {
+    const child: Record<string, unknown> = { value: 'child' }
+    const parent: Record<string, unknown> = { child }
+    child.parent = parent
+    const cloned = cloneDeep(parent)
+    expect(cloned).not.toBe(parent)
+    expect(cloned.child).not.toBe(child)
+    expect((cloned.child as Record<string, unknown>).value).toBe('child')
+    expect((cloned.child as Record<string, unknown>).parent).toBe(cloned)
+  })
+
+  it('should handle circular references in Maps', () => {
+    const original = new Map<string, unknown>()
+    original.set('self', original)
+    const cloned = cloneDeep(original)
+    expect(cloned).not.toBe(original)
+    expect(cloned.get('self')).toBe(cloned)
+  })
+
+  it('should handle circular references in Sets', () => {
+    const original = new Set<unknown>()
+    original.add(original)
+    const cloned = cloneDeep(original)
+    expect(cloned).not.toBe(original)
+    expect(cloned.has(cloned)).toBe(true)
+    expect(cloned.size).toBe(1)
+  })
+
+  it('should clone objects with toJSON method via JSON round-trip', () => {
+    const original = { value: 42, toJSON: () => ({ value: 42 }) }
+    const cloned = cloneDeep(original)
+    expect(cloned).toEqual({ value: 42 })
+    expect(cloned).not.toBe(original)
+  })
+
+  it('should clone ArrayBuffer', () => {
+    const original = new ArrayBuffer(8)
+    new Uint8Array(original).set([1, 2, 3, 4, 5, 6, 7, 8])
+    const cloned = cloneDeep(original)
+    expect(cloned).not.toBe(original)
+    expect(cloned.byteLength).toBe(8)
+    expect(new Uint8Array(cloned)).toEqual(new Uint8Array(original))
+  })
+
+  it('should clone DataView', () => {
+    const buffer = new ArrayBuffer(16)
+    const original = new DataView(buffer, 4, 8)
+    original.setInt32(0, 42)
+    const cloned = cloneDeep(original)
+    expect(cloned).not.toBe(original)
+    expect(cloned.buffer).not.toBe(original.buffer)
+    expect(cloned.byteOffset).toBe(4)
+    expect(cloned.byteLength).toBe(8)
+    expect(cloned.getInt32(0)).toBe(42)
+  })
+
+  it('should clone TypedArrays with offset and length', () => {
+    const buffer = new ArrayBuffer(16)
+    const original = new Uint8Array(buffer, 4, 8)
+    original.set([10, 20, 30, 40, 50, 60, 70, 80])
+    const cloned = cloneDeep(original)
+    expect(cloned).not.toBe(original)
+    expect(cloned.buffer).not.toBe(original.buffer)
+    expect(cloned.byteOffset).toBe(4)
+    expect(cloned.length).toBe(8)
+    expect(Array.from(cloned)).toEqual([10, 20, 30, 40, 50, 60, 70, 80])
+  })
+
+  it('should clone Float64Array', () => {
+    const original = new Float64Array([1.1, 2.2, 3.3])
+    const cloned = cloneDeep(original)
+    expect(cloned).not.toBe(original)
+    expect(cloned.buffer).not.toBe(original.buffer)
+    expect(Array.from(cloned)).toEqual([1.1, 2.2, 3.3])
+  })
+
+  it('should clone RegExp with lastIndex', () => {
+    const original = /foo/g
+    original.exec('foobar')
+    expect(original.lastIndex).toBe(3)
+    const cloned = cloneDeep(original)
+    expect(cloned).not.toBe(original)
+    expect(cloned.lastIndex).toBe(3)
+    expect(cloned.source).toBe('foo')
+    expect(cloned.flags).toBe('g')
+  })
+
+  it('should clone object without constructor', () => {
+    const original = Object.create(null) as Record<string, unknown>
+    original.a = 1
+    original.b = { c: 2 }
+    const cloned = cloneDeep(original)
+    expect(cloned).not.toBe(original)
+    expect(cloned.a).toBe(1)
+    expect(cloned.b).toEqual({ c: 2 })
+    expect(cloned.b).not.toBe(original.b)
+  })
+})