bunshin-clone 2.0.0 → 2.0.2

package/README.md

@@ -37,7 +37,6 @@ interface BunshinCloneOptions {
   preserveBufferSharing: boolean; // default: false
   preserveDescriptors: boolean;   // default: false
   preserveSymbolKeys: boolean;    // default: false
-  strictDescriptors: boolean;     // default: false
 }
 ```
 
@@ -52,155 +51,3 @@ If `true`, preserves property descriptors, including non-enumerable properties.
 ### `preserveSymbolKeys`
 
 If `true`, preserves symbol keys (slower).
-
-### `strictDescriptors`
-
-If `true`, throws if property descriptor cannot be copied (e.g. non-configurable or non-writable).
-
-## 📖 Details
-
-<details>
-<summary>Read more</summary>
-
-### Example
-
-```ts
-const source = { foo: 1, nested: { x: 1 } };
-
-const result = bunshinClone(source);
-
-console.log(result);
-// { foo: 1, nested: { x: 1 } }
-
-console.log(result === source); // false
-console.log(result.nested === source.nested); // false
-```
-
-### Supported Types
-
-bunshin-clone correctly handles:
-
-- Object (plain + prototype preserved)
-- Array
-- Map
-- Set
-- Date
-- RegExp
-- ArrayBuffer
-- DataView
-- TypedArray (Uint8Array, etc.)
-- DOMException / Error
-- Blob
-- ImageData
-- URL
-- URLSearchParams
-
-### Circular ref
-
-```ts
-const a: any = { x: 1 };
-a.self = a;
-
-const result = bunshinClone(a);
-
-result.self === result; // true
-```
-
-### Descriptor Behavior
-
-#### Default (fast path)
-
-```ts
-const source = {
-  get x() {
-    return 42;
-  },
-};
-
-const result = bunshinClone(source);
-
-result.x; // 42
-// getter is NOT preserved
-```
-
-#### preserveDescriptors: true
-
-```ts
-const source = {};
-Object.defineProperty(source, 'x', {
-  get: () => 42,
-  enumerable: true,
-});
-
-const result = bunshinClone(source, {
-  preserveDescriptors: true,
-});
-
-Object.getOwnPropertyDescriptor(result, 'x')?.get;
-// => preserved
-```
-
-#### Unsupported / Pass-through Types
-
-Some values are returned as-is:
-
-- Function
-- WeakMap / WeakSet
-- Proxy (not cloned)
-- Other non-cloneable host objects
-
-```ts
-const fn = () => {};
-
-bunshinClone(fn) === fn; // true
-```
-
-### Design Notes
-
-#### Deep clone (no structural sharing)
-
-Unlike merge utilities, bunshin-clone always produces a new structure:
-
-```ts
-const source = { a: { b: 1 } };
-
-const result = bunshinClone(source);
-
-result !== source; // true
-result.a !== source.a; // true
-```
-
-#### Getter / Setter behavior
-
-- Default: evaluated and converted to value
-- preserveDescriptors: preserved as-is
-
-#### Descriptor safety
-
-When `preserveDescriptors` is enabled:
-
-- descriptors are cloned safely
-- original object is never mutated
-- errors are controlled via `strictDescriptors`
-
-### Performance
-
-- No proxy / no diffing
-- Minimal branching
-- Fast path for plain objects and arrays
-- Competitive with structuredClone in many cases
-
-### Comparison
-
-| Feature             | Bunshin Clone | structuredClone | lodash.clonedeep |
-| ------------------- | ------------- | --------------- | ---------------- |
-| Circular refs       | ✅            | ✅              | ✅               |
-| Map / Set           | ✅            | ✅              | ⚠️ (partial)     |
-| TypedArray          | ✅            | ✅              | ⚠️ (shallow)     |
-| Descriptor support  | ✅            | ❌              | ❌               |
-| Functions           | pass-through  | ❌ (throws)     | pass-through     |
-| Prototype preserved | ✅            | ❌              | ⚠️               |
-| Custom control      | ✅            | ❌              | ❌               |
-| Performance         | ⚡ fast       | ⚡ fast         | 🐢 slower        |
-
-</details>

package/dist/index.bundle.cjs

@@ -0,0 +1,359 @@
+'use strict';
+
+// src/utils.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function isPlainObject(value) {
+  if (!isObject(value)) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+
+// src/clone/array.ts
+function cloneArray(array, settings, refs) {
+  const result = isPrimitiveArray(array) ? array.slice() : array.map((i) => clone(i, settings, refs));
+  refs.set(array, result);
+  return result;
+}
+function isPrimitiveArray(array) {
+  return array.every((i) => !isObject(i));
+}
+
+// src/clone/array-buffer.ts
+function cloneArrayBuffer(buffer, refs) {
+  const result = buffer.slice(0);
+  refs.set(buffer, result);
+  return result;
+}
+
+// src/clone/array-buffer-view.ts
+function cloneArrayBufferView(view, settings, refs) {
+  if (view instanceof DataView) {
+    const { buffer: buffer2, byteOffset: byteOffset2, byteLength } = view;
+    const result2 = new DataView(
+      cloneBuffer(buffer2, refs),
+      byteOffset2,
+      byteLength
+    );
+    refs.set(view, result2);
+    return result2;
+  }
+  if (!settings.preserveBufferSharing) {
+    const Ctor2 = view.constructor;
+    const result2 = new Ctor2(view);
+    refs.set(view, result2);
+    return result2;
+  }
+  const Ctor = view.constructor;
+  const { buffer, byteOffset, length } = view;
+  const result = new Ctor(cloneBuffer(buffer, refs), byteOffset, length);
+  refs.set(view, result);
+  return result;
+}
+function cloneBuffer(buffer, refs) {
+  if (refs.has(buffer)) {
+    return refs.get(buffer);
+  }
+  const result = buffer.slice(0);
+  refs.set(buffer, result);
+  return result;
+}
+
+// src/clone/blob.ts
+function cloneBlob(blob, refs) {
+  const { size, type } = blob;
+  const result = blob.slice(0, size, type);
+  refs.set(blob, result);
+  return result;
+}
+
+// src/clone/date.ts
+function cloneDate(date, refs) {
+  const result = new Date(date.getTime());
+  refs.set(date, result);
+  return result;
+}
+
+// src/clone/error.ts
+function cloneError(error, settings, refs) {
+  const result = createErrorInstance(error, settings, refs);
+  refs.set(error, result);
+  if (error instanceof DOMException) {
+    return result;
+  }
+  const { stack, cause } = error;
+  if (stack) {
+    try {
+      result.stack = stack;
+    } catch {
+    }
+  }
+  if ("cause" in error && cause !== void 0) {
+    result.cause = clone(cause, settings, refs);
+  }
+  for (const key of Object.keys(error)) {
+    Reflect.set(result, key, clone(Reflect.get(error, key), settings, refs));
+  }
+  return result;
+}
+var ERROR_CTORS = {
+  EvalError,
+  RangeError,
+  ReferenceError,
+  SyntaxError,
+  TypeError,
+  URIError
+};
+function createErrorInstance(error, settings, refs) {
+  const { message, name } = error;
+  if (error instanceof DOMException) {
+    return new DOMException(message, name);
+  }
+  if (error instanceof AggregateError) {
+    return new AggregateError(
+      error.errors.map((e) => clone(e, settings, refs)),
+      message
+    );
+  }
+  const Ctor = ERROR_CTORS[name];
+  if (Ctor) {
+    return new Ctor(message);
+  }
+  const result = new Error(message);
+  result.name = name;
+  return result;
+}
+
+// src/clone/image-data.ts
+function cloneImageData(data, refs) {
+  const { data: d, width, height, colorSpace } = data;
+  const result = new ImageData(new Uint8ClampedArray(d), width, height, {
+    colorSpace
+  });
+  refs.set(data, result);
+  return result;
+}
+
+// src/clone/map.ts
+function cloneMap(map, settings, refs) {
+  const result = /* @__PURE__ */ new Map();
+  refs.set(map, result);
+  for (const [key, value] of map) {
+    result.set(clone(key, settings, refs), clone(value, settings, refs));
+  }
+  return result;
+}
+var OWN_DESCS = Object.getOwnPropertyDescriptors;
+function OWN_ENUM_STRING_KEYS(object) {
+  const keys = Object.keys(object);
+  for (const key of keys) {
+    if (isUnsafeKey(key)) {
+      keys.splice(keys.indexOf(key), 1);
+    }
+  }
+  return keys;
+}
+function OWN_ENUM_SYMBOL_KEYS(object) {
+  const keys = OWN_SYMBOL_KEYS(object);
+  for (const key of keys) {
+    if (!Object.prototype.propertyIsEnumerable.call(object, key)) {
+      keys.splice(keys.indexOf(key), 1);
+    }
+  }
+  return keys;
+}
+function OWN_STRING_KEYS(object) {
+  const keys = Object.getOwnPropertyNames(object);
+  for (const key of keys) {
+    if (isUnsafeKey(key)) {
+      keys.splice(keys.indexOf(key), 1);
+    }
+  }
+  return keys;
+}
+var OWN_SYMBOL_KEYS = Object.getOwnPropertySymbols;
+function isUnsafeKey(key) {
+  return typeof key === "string" && (key === "__proto__" || key === "prototype" || key === "constructor");
+}
+
+// src/clone/plain-object.ts
+function clonePlainObject(object, settings, refs) {
+  const result = Object.create(Object.getPrototypeOf(object));
+  refs.set(object, result);
+  function copy(key) {
+    result[key] = clone(object[key], settings, refs);
+  }
+  for (const key of OWN_ENUM_STRING_KEYS(object)) {
+    copy(key);
+  }
+  if (settings.preserveSymbolKeys) {
+    for (const key of OWN_ENUM_SYMBOL_KEYS(object)) {
+      copy(key);
+    }
+  }
+  return result;
+}
+
+// src/clone/regexp.ts
+function cloneRegExp(re, refs) {
+  const { source, flags, lastIndex } = re;
+  const result = new RegExp(source, flags);
+  refs.set(re, result);
+  result.lastIndex = lastIndex;
+  return result;
+}
+
+// src/clone/set.ts
+function cloneSet(set, settings, refs) {
+  if (isPrimitiveSet(set)) {
+    const result2 = new Set(set);
+    refs.set(set, result2);
+    return result2;
+  }
+  const result = /* @__PURE__ */ new Set();
+  refs.set(set, result);
+  for (const item of set) {
+    result.add(clone(item, settings, refs));
+  }
+  return result;
+}
+function isPrimitiveSet(set) {
+  for (const value of set) {
+    if (isObject(value)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/clone/url.ts
+function cloneURL(url, refs) {
+  const result = new URL(url.href);
+  refs.set(url, result);
+  return result;
+}
+
+// src/clone/url-search-params.ts
+function cloneURLSearchParams(params, refs) {
+  const result = new URLSearchParams(params);
+  refs.set(params, result);
+  return result;
+}
+
+// src/clone/with-descriptors.ts
+function cloneWithDescriptors(object, settings, refs) {
+  const result = Object.create(Object.getPrototypeOf(object));
+  refs.set(object, result);
+  const descs = OWN_DESCS(object);
+  function copy(key) {
+    const desc = { ...descs[key] };
+    if ("value" in desc) {
+      desc.value = clone(desc.value, settings, refs);
+    }
+    Object.defineProperty(result, key, desc);
+  }
+  for (const key of OWN_STRING_KEYS(object)) {
+    copy(key);
+  }
+  if (settings.preserveSymbolKeys) {
+    for (const key of OWN_SYMBOL_KEYS(object)) {
+      copy(key);
+    }
+  }
+  return result;
+}
+
+// src/index.ts
+function bunshinClone(value, options = {}) {
+  return clone(value, resolveOptions(options), /* @__PURE__ */ new WeakMap());
+}
+function clone(value, settings, refs) {
+  if (!isObject(value)) {
+    return value;
+  }
+  if (refs.has(value)) {
+    return refs.get(value);
+  }
+  const isClonePlainObject = isPlainObject(value);
+  if (settings.preserveDescriptors && isClonePlainObject) {
+    return cloneWithDescriptors(value, settings, refs);
+  }
+  if (Array.isArray(value)) {
+    return cloneArray(value, settings, refs);
+  }
+  if (isClonePlainObject) {
+    return clonePlainObject(value, settings, refs);
+  }
+  if (value instanceof Map) {
+    return cloneMap(value, settings, refs);
+  }
+  if (value instanceof Set) {
+    return cloneSet(value, settings, refs);
+  }
+  if (value instanceof Date) {
+    return cloneDate(value, refs);
+  }
+  if (value instanceof RegExp) {
+    return cloneRegExp(value, refs);
+  }
+  if (value instanceof ArrayBuffer) {
+    return cloneArrayBuffer(value, refs);
+  }
+  if (ArrayBuffer.isView(value)) {
+    return cloneArrayBufferView(
+      value,
+      settings,
+      refs
+    );
+  }
+  if (value instanceof Error) {
+    return cloneError(value, settings, refs);
+  }
+  if (value instanceof Blob) {
+    return cloneBlob(value, refs);
+  }
+  if (typeof ImageData !== "undefined" && value instanceof ImageData) {
+    return cloneImageData(value, refs);
+  }
+  if (value instanceof URL) {
+    return cloneURL(value, refs);
+  }
+  if (value instanceof URLSearchParams) {
+    return cloneURLSearchParams(value, refs);
+  }
+  refs.set(value, value);
+  return value;
+}
+function resolveOptions(options) {
+  let {
+    preserveBufferSharing = false,
+    preserveDescriptors = false,
+    preserveSymbolKeys = false
+  } = options;
+  if (typeof preserveBufferSharing !== "boolean") {
+    console.warn("Invalid preserveBufferSharing option. Fallback: false.");
+    preserveBufferSharing = false;
+  }
+  if (typeof preserveDescriptors !== "boolean") {
+    console.warn("Invalid preserveDescriptors option. Fallback: false.");
+    preserveDescriptors = false;
+  }
+  if (typeof preserveSymbolKeys !== "boolean") {
+    console.warn("Invalid preserveSymbolKeys option. Fallback: false.");
+    preserveSymbolKeys = false;
+  }
+  return {
+    preserveBufferSharing,
+    preserveDescriptors,
+    preserveSymbolKeys
+  };
+}
+
+exports.bunshinClone = bunshinClone;
+exports.clone = clone;
+exports.isObject = isObject;
+exports.isPlainObject = isPlainObject;
+exports.isPrimitiveArray = isPrimitiveArray;

package/dist/index.bundle.js

@@ -0,0 +1,353 @@
+// src/utils.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function isPlainObject(value) {
+  if (!isObject(value)) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+
+// src/clone/array.ts
+function cloneArray(array, settings, refs) {
+  const result = isPrimitiveArray(array) ? array.slice() : array.map((i) => clone(i, settings, refs));
+  refs.set(array, result);
+  return result;
+}
+function isPrimitiveArray(array) {
+  return array.every((i) => !isObject(i));
+}
+
+// src/clone/array-buffer.ts
+function cloneArrayBuffer(buffer, refs) {
+  const result = buffer.slice(0);
+  refs.set(buffer, result);
+  return result;
+}
+
+// src/clone/array-buffer-view.ts
+function cloneArrayBufferView(view, settings, refs) {
+  if (view instanceof DataView) {
+    const { buffer: buffer2, byteOffset: byteOffset2, byteLength } = view;
+    const result2 = new DataView(
+      cloneBuffer(buffer2, refs),
+      byteOffset2,
+      byteLength
+    );
+    refs.set(view, result2);
+    return result2;
+  }
+  if (!settings.preserveBufferSharing) {
+    const Ctor2 = view.constructor;
+    const result2 = new Ctor2(view);
+    refs.set(view, result2);
+    return result2;
+  }
+  const Ctor = view.constructor;
+  const { buffer, byteOffset, length } = view;
+  const result = new Ctor(cloneBuffer(buffer, refs), byteOffset, length);
+  refs.set(view, result);
+  return result;
+}
+function cloneBuffer(buffer, refs) {
+  if (refs.has(buffer)) {
+    return refs.get(buffer);
+  }
+  const result = buffer.slice(0);
+  refs.set(buffer, result);
+  return result;
+}
+
+// src/clone/blob.ts
+function cloneBlob(blob, refs) {
+  const { size, type } = blob;
+  const result = blob.slice(0, size, type);
+  refs.set(blob, result);
+  return result;
+}
+
+// src/clone/date.ts
+function cloneDate(date, refs) {
+  const result = new Date(date.getTime());
+  refs.set(date, result);
+  return result;
+}
+
+// src/clone/error.ts
+function cloneError(error, settings, refs) {
+  const result = createErrorInstance(error, settings, refs);
+  refs.set(error, result);
+  if (error instanceof DOMException) {
+    return result;
+  }
+  const { stack, cause } = error;
+  if (stack) {
+    try {
+      result.stack = stack;
+    } catch {
+    }
+  }
+  if ("cause" in error && cause !== void 0) {
+    result.cause = clone(cause, settings, refs);
+  }
+  for (const key of Object.keys(error)) {
+    Reflect.set(result, key, clone(Reflect.get(error, key), settings, refs));
+  }
+  return result;
+}
+var ERROR_CTORS = {
+  EvalError,
+  RangeError,
+  ReferenceError,
+  SyntaxError,
+  TypeError,
+  URIError
+};
+function createErrorInstance(error, settings, refs) {
+  const { message, name } = error;
+  if (error instanceof DOMException) {
+    return new DOMException(message, name);
+  }
+  if (error instanceof AggregateError) {
+    return new AggregateError(
+      error.errors.map((e) => clone(e, settings, refs)),
+      message
+    );
+  }
+  const Ctor = ERROR_CTORS[name];
+  if (Ctor) {
+    return new Ctor(message);
+  }
+  const result = new Error(message);
+  result.name = name;
+  return result;
+}
+
+// src/clone/image-data.ts
+function cloneImageData(data, refs) {
+  const { data: d, width, height, colorSpace } = data;
+  const result = new ImageData(new Uint8ClampedArray(d), width, height, {
+    colorSpace
+  });
+  refs.set(data, result);
+  return result;
+}
+
+// src/clone/map.ts
+function cloneMap(map, settings, refs) {
+  const result = /* @__PURE__ */ new Map();
+  refs.set(map, result);
+  for (const [key, value] of map) {
+    result.set(clone(key, settings, refs), clone(value, settings, refs));
+  }
+  return result;
+}
+var OWN_DESCS = Object.getOwnPropertyDescriptors;
+function OWN_ENUM_STRING_KEYS(object) {
+  const keys = Object.keys(object);
+  for (const key of keys) {
+    if (isUnsafeKey(key)) {
+      keys.splice(keys.indexOf(key), 1);
+    }
+  }
+  return keys;
+}
+function OWN_ENUM_SYMBOL_KEYS(object) {
+  const keys = OWN_SYMBOL_KEYS(object);
+  for (const key of keys) {
+    if (!Object.prototype.propertyIsEnumerable.call(object, key)) {
+      keys.splice(keys.indexOf(key), 1);
+    }
+  }
+  return keys;
+}
+function OWN_STRING_KEYS(object) {
+  const keys = Object.getOwnPropertyNames(object);
+  for (const key of keys) {
+    if (isUnsafeKey(key)) {
+      keys.splice(keys.indexOf(key), 1);
+    }
+  }
+  return keys;
+}
+var OWN_SYMBOL_KEYS = Object.getOwnPropertySymbols;
+function isUnsafeKey(key) {
+  return typeof key === "string" && (key === "__proto__" || key === "prototype" || key === "constructor");
+}
+
+// src/clone/plain-object.ts
+function clonePlainObject(object, settings, refs) {
+  const result = Object.create(Object.getPrototypeOf(object));
+  refs.set(object, result);
+  function copy(key) {
+    result[key] = clone(object[key], settings, refs);
+  }
+  for (const key of OWN_ENUM_STRING_KEYS(object)) {
+    copy(key);
+  }
+  if (settings.preserveSymbolKeys) {
+    for (const key of OWN_ENUM_SYMBOL_KEYS(object)) {
+      copy(key);
+    }
+  }
+  return result;
+}
+
+// src/clone/regexp.ts
+function cloneRegExp(re, refs) {
+  const { source, flags, lastIndex } = re;
+  const result = new RegExp(source, flags);
+  refs.set(re, result);
+  result.lastIndex = lastIndex;
+  return result;
+}
+
+// src/clone/set.ts
+function cloneSet(set, settings, refs) {
+  if (isPrimitiveSet(set)) {
+    const result2 = new Set(set);
+    refs.set(set, result2);
+    return result2;
+  }
+  const result = /* @__PURE__ */ new Set();
+  refs.set(set, result);
+  for (const item of set) {
+    result.add(clone(item, settings, refs));
+  }
+  return result;
+}
+function isPrimitiveSet(set) {
+  for (const value of set) {
+    if (isObject(value)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/clone/url.ts
+function cloneURL(url, refs) {
+  const result = new URL(url.href);
+  refs.set(url, result);
+  return result;
+}
+
+// src/clone/url-search-params.ts
+function cloneURLSearchParams(params, refs) {
+  const result = new URLSearchParams(params);
+  refs.set(params, result);
+  return result;
+}
+
+// src/clone/with-descriptors.ts
+function cloneWithDescriptors(object, settings, refs) {
+  const result = Object.create(Object.getPrototypeOf(object));
+  refs.set(object, result);
+  const descs = OWN_DESCS(object);
+  function copy(key) {
+    const desc = { ...descs[key] };
+    if ("value" in desc) {
+      desc.value = clone(desc.value, settings, refs);
+    }
+    Object.defineProperty(result, key, desc);
+  }
+  for (const key of OWN_STRING_KEYS(object)) {
+    copy(key);
+  }
+  if (settings.preserveSymbolKeys) {
+    for (const key of OWN_SYMBOL_KEYS(object)) {
+      copy(key);
+    }
+  }
+  return result;
+}
+
+// src/index.ts
+function bunshinClone(value, options = {}) {
+  return clone(value, resolveOptions(options), /* @__PURE__ */ new WeakMap());
+}
+function clone(value, settings, refs) {
+  if (!isObject(value)) {
+    return value;
+  }
+  if (refs.has(value)) {
+    return refs.get(value);
+  }
+  const isClonePlainObject = isPlainObject(value);
+  if (settings.preserveDescriptors && isClonePlainObject) {
+    return cloneWithDescriptors(value, settings, refs);
+  }
+  if (Array.isArray(value)) {
+    return cloneArray(value, settings, refs);
+  }
+  if (isClonePlainObject) {
+    return clonePlainObject(value, settings, refs);
+  }
+  if (value instanceof Map) {
+    return cloneMap(value, settings, refs);
+  }
+  if (value instanceof Set) {
+    return cloneSet(value, settings, refs);
+  }
+  if (value instanceof Date) {
+    return cloneDate(value, refs);
+  }
+  if (value instanceof RegExp) {
+    return cloneRegExp(value, refs);
+  }
+  if (value instanceof ArrayBuffer) {
+    return cloneArrayBuffer(value, refs);
+  }
+  if (ArrayBuffer.isView(value)) {
+    return cloneArrayBufferView(
+      value,
+      settings,
+      refs
+    );
+  }
+  if (value instanceof Error) {
+    return cloneError(value, settings, refs);
+  }
+  if (value instanceof Blob) {
+    return cloneBlob(value, refs);
+  }
+  if (typeof ImageData !== "undefined" && value instanceof ImageData) {
+    return cloneImageData(value, refs);
+  }
+  if (value instanceof URL) {
+    return cloneURL(value, refs);
+  }
+  if (value instanceof URLSearchParams) {
+    return cloneURLSearchParams(value, refs);
+  }
+  refs.set(value, value);
+  return value;
+}
+function resolveOptions(options) {
+  let {
+    preserveBufferSharing = false,
+    preserveDescriptors = false,
+    preserveSymbolKeys = false
+  } = options;
+  if (typeof preserveBufferSharing !== "boolean") {
+    console.warn("Invalid preserveBufferSharing option. Fallback: false.");
+    preserveBufferSharing = false;
+  }
+  if (typeof preserveDescriptors !== "boolean") {
+    console.warn("Invalid preserveDescriptors option. Fallback: false.");
+    preserveDescriptors = false;
+  }
+  if (typeof preserveSymbolKeys !== "boolean") {
+    console.warn("Invalid preserveSymbolKeys option. Fallback: false.");
+    preserveSymbolKeys = false;
+  }
+  return {
+    preserveBufferSharing,
+    preserveDescriptors,
+    preserveSymbolKeys
+  };
+}
+
+export { bunshinClone, clone, isObject, isPlainObject, isPrimitiveArray };

package/dist/index.cjs

@@ -219,13 +219,7 @@ function cloneWithDescriptors(object, settings, refs) {
     if ("value" in desc) {
       desc.value = clone(desc.value, settings, refs);
     }
-    try {
-      Object.defineProperty(result, key, desc);
-    } catch (error) {
-      if (settings.strictDescriptors) {
-        throw error;
-      }
-    }
+    Object.defineProperty(result, key, desc);
   }
   for (const key of own.OWN_STRING_KEYS(object)) {
     copy(key);
@@ -303,13 +297,8 @@ function resolveOptions(options) {
   let {
     preserveBufferSharing = false,
     preserveDescriptors = false,
-    strictDescriptors = false,
     preserveSymbolKeys = false
   } = options;
-  if (typeof preserveSymbolKeys !== "boolean") {
-    console.warn("Invalid preserveSymbolKeys option. Fallback: false.");
-    preserveSymbolKeys = false;
-  }
   if (typeof preserveBufferSharing !== "boolean") {
     console.warn("Invalid preserveBufferSharing option. Fallback: false.");
     preserveBufferSharing = false;
@@ -318,15 +307,14 @@ function resolveOptions(options) {
     console.warn("Invalid preserveDescriptors option. Fallback: false.");
     preserveDescriptors = false;
   }
-  if (typeof strictDescriptors !== "boolean") {
-    console.warn("Invalid strictDescriptors option. Fallback: false.");
-    strictDescriptors = false;
+  if (typeof preserveSymbolKeys !== "boolean") {
+    console.warn("Invalid preserveSymbolKeys option. Fallback: false.");
+    preserveSymbolKeys = false;
   }
   return {
     preserveBufferSharing,
     preserveDescriptors,
-    preserveSymbolKeys,
-    strictDescriptors
+    preserveSymbolKeys
   };
 }
 

package/dist/index.d.cts

@@ -4,7 +4,6 @@ interface BunshinCloneOptions {
     preserveBufferSharing: boolean;
     preserveDescriptors: boolean;
     preserveSymbolKeys: boolean;
-    strictDescriptors: boolean;
 }
 type PlainObject = Record<PropertyKey, unknown>;
 

package/dist/index.d.ts

@@ -4,7 +4,6 @@ interface BunshinCloneOptions {
     preserveBufferSharing: boolean;
     preserveDescriptors: boolean;
     preserveSymbolKeys: boolean;
-    strictDescriptors: boolean;
 }
 type PlainObject = Record<PropertyKey, unknown>;
 

package/dist/index.js

@@ -217,13 +217,7 @@ function cloneWithDescriptors(object, settings, refs) {
     if ("value" in desc) {
       desc.value = clone(desc.value, settings, refs);
     }
-    try {
-      Object.defineProperty(result, key, desc);
-    } catch (error) {
-      if (settings.strictDescriptors) {
-        throw error;
-      }
-    }
+    Object.defineProperty(result, key, desc);
   }
   for (const key of OWN_STRING_KEYS(object)) {
     copy(key);
@@ -301,13 +295,8 @@ function resolveOptions(options) {
   let {
     preserveBufferSharing = false,
     preserveDescriptors = false,
-    strictDescriptors = false,
     preserveSymbolKeys = false
   } = options;
-  if (typeof preserveSymbolKeys !== "boolean") {
-    console.warn("Invalid preserveSymbolKeys option. Fallback: false.");
-    preserveSymbolKeys = false;
-  }
   if (typeof preserveBufferSharing !== "boolean") {
     console.warn("Invalid preserveBufferSharing option. Fallback: false.");
     preserveBufferSharing = false;
@@ -316,15 +305,14 @@ function resolveOptions(options) {
     console.warn("Invalid preserveDescriptors option. Fallback: false.");
     preserveDescriptors = false;
   }
-  if (typeof strictDescriptors !== "boolean") {
-    console.warn("Invalid strictDescriptors option. Fallback: false.");
-    strictDescriptors = false;
+  if (typeof preserveSymbolKeys !== "boolean") {
+    console.warn("Invalid preserveSymbolKeys option. Fallback: false.");
+    preserveSymbolKeys = false;
   }
   return {
     preserveBufferSharing,
     preserveDescriptors,
-    preserveSymbolKeys,
-    strictDescriptors
+    preserveSymbolKeys
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunshin-clone",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "High-performance deep clone utility with descriptor support",
   "keywords": [
     "array",
@@ -69,7 +69,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@y14e/own": "^1.0.0"
+    "@y14e/own": "^1.0.1"
   },
   "devDependencies": {
     "bun-types": "latest",