bunshin-clone 1.8.0 → 1.8.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist/index.cjs +91 -88
  2. package/dist/index.js +91 -88
  3. package/package.json +1 -1
package/dist/index.cjs CHANGED
@@ -1,55 +1,24 @@
1
1
  'use strict';
2
2
 
3
3
  // src/index.ts
4
- var EMPTY_OPTIONS = {};
5
- var { hasOwnProperty: HAS_OWN, propertyIsEnumerable: IS_ENUMERABLE } = Object.prototype;
6
- function bunshinClone(value, options = EMPTY_OPTIONS, refs = /* @__PURE__ */ new WeakMap()) {
4
+ function bunshinClone(value, options = {}, refs = /* @__PURE__ */ new WeakMap()) {
7
5
  return clone(value, resolveOptions(options), refs);
8
6
  }
9
7
  function clone(value, settings, refs) {
10
8
  if (!isObject(value)) {
11
9
  return value;
12
10
  }
13
- const ref = refs.get(value);
14
- if (ref !== void 0) {
15
- return ref;
11
+ if (refs.has(value)) {
12
+ return refs.get(value);
16
13
  }
17
14
  if (settings.preserveDescriptors && isPlainObject(value)) {
18
15
  return cloneWithDescriptors(value, settings, refs);
19
16
  }
20
17
  if (Array.isArray(value)) {
21
- if (isShallowArray(value)) {
22
- const result2 = value.slice();
23
- refs.set(value, result2);
24
- return result2;
25
- }
26
- const { length } = value;
27
- const result = new Array(length);
28
- refs.set(value, result);
29
- for (let i = 0; i < length; i++) {
30
- result[i] = clone(value[i], settings, refs);
31
- }
32
- return result;
18
+ return cloneArray(value, settings, refs);
33
19
  }
34
20
  if (isPlainObject(value)) {
35
- const result = Object.create(Object.getPrototypeOf(value));
36
- refs.set(value, result);
37
- if (!settings.preserveSymbolKeys) {
38
- for (const key in value) {
39
- if (isUnsafeKey(key) || !HAS_OWN.call(value, key)) {
40
- continue;
41
- }
42
- result[key] = clone(value[key], settings, refs);
43
- }
44
- } else {
45
- for (const key of Reflect.ownKeys(value)) {
46
- if (isUnsafeKey(key) || !IS_ENUMERABLE.call(value, key)) {
47
- continue;
48
- }
49
- result[key] = clone(value[key], settings, refs);
50
- }
51
- }
52
- return result;
21
+ return clonePlainObject(value, settings, refs);
53
22
  }
54
23
  if (value instanceof Map) {
55
24
  const result = /* @__PURE__ */ new Map();
@@ -84,28 +53,11 @@ function clone(value, settings, refs) {
84
53
  return result;
85
54
  }
86
55
  if (ArrayBuffer.isView(value)) {
87
- if (value instanceof DataView) {
88
- const { buffer: buffer2, byteOffset: byteOffset2, byteLength } = value;
89
- const result2 = new DataView(
90
- cloneBuffer(buffer2, refs),
91
- byteOffset2,
92
- byteLength
93
- );
94
- refs.set(value, result2);
95
- return result2;
96
- }
97
- const view = value;
98
- if (!settings.preserveBufferSharing) {
99
- const Ctor2 = view.constructor;
100
- const result2 = new Ctor2(view);
101
- refs.set(value, result2);
102
- return result2;
103
- }
104
- const Ctor = view.constructor;
105
- const { buffer, byteOffset, length } = view;
106
- const result = new Ctor(cloneBuffer(buffer, refs), byteOffset, length);
107
- refs.set(value, result);
108
- return result;
56
+ return cloneArrayBufferView(
57
+ value,
58
+ settings,
59
+ refs
60
+ );
109
61
  }
110
62
  if (value instanceof DOMException || value instanceof Error) {
111
63
  return cloneError(value, settings, refs);
@@ -139,9 +91,87 @@ function clone(value, settings, refs) {
139
91
  refs.set(value, value);
140
92
  return value;
141
93
  }
94
+ function cloneWithDescriptors(object, settings, refs) {
95
+ const result = Object.create(Object.getPrototypeOf(object));
96
+ refs.set(object, result);
97
+ const descs = Object.getOwnPropertyDescriptors(object);
98
+ forEachOwnKey(descs, (key) => {
99
+ if (isUnsafeKey(key)) {
100
+ return;
101
+ }
102
+ const desc = { ...descs[key] };
103
+ if ("value" in desc) {
104
+ desc.value = clone(desc.value, settings, refs);
105
+ }
106
+ try {
107
+ Object.defineProperty(result, key, desc);
108
+ } catch (error) {
109
+ if (settings.strictDescriptors) {
110
+ throw error;
111
+ }
112
+ }
113
+ });
114
+ return result;
115
+ }
116
+ function cloneArray(array, settings, refs) {
117
+ if (isShallowArray(array)) {
118
+ const result2 = array.slice();
119
+ refs.set(array, result2);
120
+ return result2;
121
+ }
122
+ const { length } = array;
123
+ const result = new Array(length);
124
+ refs.set(array, result);
125
+ for (let i = 0; i < length; i++) {
126
+ result[i] = clone(array[i], settings, refs);
127
+ }
128
+ return result;
129
+ }
130
+ function clonePlainObject(object, settings, refs) {
131
+ const result = Object.create(Object.getPrototypeOf(object));
132
+ refs.set(object, result);
133
+ if (!settings.preserveSymbolKeys) {
134
+ for (const key in object) {
135
+ if (isUnsafeKey(key) || !Object.hasOwn(object, key)) {
136
+ continue;
137
+ }
138
+ result[key] = clone(object[key], settings, refs);
139
+ }
140
+ } else {
141
+ for (const key of Reflect.ownKeys(object)) {
142
+ if (isUnsafeKey(key) || !Object.propertyIsEnumerable.call(object, key)) {
143
+ continue;
144
+ }
145
+ result[key] = clone(object[key], settings, refs);
146
+ }
147
+ }
148
+ return result;
149
+ }
150
+ function cloneArrayBufferView(view, settings, refs) {
151
+ if (view instanceof DataView) {
152
+ const { buffer: buffer2, byteOffset: byteOffset2, byteLength } = view;
153
+ const result2 = new DataView(
154
+ cloneBuffer(buffer2, refs),
155
+ byteOffset2,
156
+ byteLength
157
+ );
158
+ refs.set(view, result2);
159
+ return result2;
160
+ }
161
+ if (!settings.preserveBufferSharing) {
162
+ const Ctor2 = view.constructor;
163
+ const result2 = new Ctor2(view);
164
+ refs.set(view, result2);
165
+ return result2;
166
+ }
167
+ const Ctor = view.constructor;
168
+ const { buffer, byteOffset, length } = view;
169
+ const result = new Ctor(cloneBuffer(buffer, refs), byteOffset, length);
170
+ refs.set(view, result);
171
+ return result;
172
+ }
142
173
  function cloneBuffer(buffer, refs) {
143
- const ref = refs.get(buffer);
144
- if (ref !== void 0) {
174
+ if (refs.has(buffer)) {
145
175
  return refs.get(buffer);
146
176
  }
147
177
  const result = buffer.slice(0);
@@ -169,28 +199,6 @@ function cloneError(error, settings, refs) {
169
199
  }
170
200
  return result;
171
201
  }
172
- function cloneWithDescriptors(object, settings, refs) {
173
- const result = Object.create(Object.getPrototypeOf(object));
174
- refs.set(object, result);
175
- const descs = Object.getOwnPropertyDescriptors(object);
176
- forEachOwnKey(descs, (key) => {
177
- if (isUnsafeKey(key)) {
178
- return;
179
- }
180
- const desc = { ...descs[key] };
181
- if ("value" in desc) {
182
- desc.value = clone(desc.value, settings, refs);
183
- }
184
- try {
185
- Object.defineProperty(result, key, desc);
186
- } catch (error) {
187
- if (settings.strictDescriptors) {
188
- throw error;
189
- }
190
- }
191
- });
192
- return result;
193
- }
194
202
  var ERROR_CTORS = {
195
203
  EvalError,
196
204
  RangeError,
@@ -237,12 +245,7 @@ function isPlainObject(value) {
237
245
  return proto === Object.prototype || proto === null;
238
246
  }
239
247
  function isShallowArray(array) {
240
- for (let i = 0, l = array.length; i < l; i++) {
241
- if (isObject(array[i])) {
242
- return false;
243
- }
244
- }
245
- return true;
248
+ return array.every((item) => !isObject(item));
246
249
  }
247
250
  function isUnsafeKey(key) {
248
251
  return typeof key === "string" && (key === "__proto__" || key === "prototype" || key === "constructor");
package/dist/index.js CHANGED
@@ -1,53 +1,22 @@
1
1
  // src/index.ts
2
- var EMPTY_OPTIONS = {};
3
- var { hasOwnProperty: HAS_OWN, propertyIsEnumerable: IS_ENUMERABLE } = Object.prototype;
4
- function bunshinClone(value, options = EMPTY_OPTIONS, refs = /* @__PURE__ */ new WeakMap()) {
2
+ function bunshinClone(value, options = {}, refs = /* @__PURE__ */ new WeakMap()) {
5
3
  return clone(value, resolveOptions(options), refs);
6
4
  }
7
5
  function clone(value, settings, refs) {
8
6
  if (!isObject(value)) {
9
7
  return value;
10
8
  }
11
- const ref = refs.get(value);
12
- if (ref !== void 0) {
13
- return ref;
9
+ if (refs.has(value)) {
10
+ return refs.get(value);
14
11
  }
15
12
  if (settings.preserveDescriptors && isPlainObject(value)) {
16
13
  return cloneWithDescriptors(value, settings, refs);
17
14
  }
18
15
  if (Array.isArray(value)) {
19
- if (isShallowArray(value)) {
20
- const result2 = value.slice();
21
- refs.set(value, result2);
22
- return result2;
23
- }
24
- const { length } = value;
25
- const result = new Array(length);
26
- refs.set(value, result);
27
- for (let i = 0; i < length; i++) {
28
- result[i] = clone(value[i], settings, refs);
29
- }
30
- return result;
16
+ return cloneArray(value, settings, refs);
31
17
  }
32
18
  if (isPlainObject(value)) {
33
- const result = Object.create(Object.getPrototypeOf(value));
34
- refs.set(value, result);
35
- if (!settings.preserveSymbolKeys) {
36
- for (const key in value) {
37
- if (isUnsafeKey(key) || !HAS_OWN.call(value, key)) {
38
- continue;
39
- }
40
- result[key] = clone(value[key], settings, refs);
41
- }
42
- } else {
43
- for (const key of Reflect.ownKeys(value)) {
44
- if (isUnsafeKey(key) || !IS_ENUMERABLE.call(value, key)) {
45
- continue;
46
- }
47
- result[key] = clone(value[key], settings, refs);
48
- }
49
- }
50
- return result;
19
+ return clonePlainObject(value, settings, refs);
51
20
  }
52
21
  if (value instanceof Map) {
53
22
  const result = /* @__PURE__ */ new Map();
@@ -82,28 +51,11 @@ function clone(value, settings, refs) {
82
51
  return result;
83
52
  }
84
53
  if (ArrayBuffer.isView(value)) {
85
- if (value instanceof DataView) {
86
- const { buffer: buffer2, byteOffset: byteOffset2, byteLength } = value;
87
- const result2 = new DataView(
88
- cloneBuffer(buffer2, refs),
89
- byteOffset2,
90
- byteLength
91
- );
92
- refs.set(value, result2);
93
- return result2;
94
- }
95
- const view = value;
96
- if (!settings.preserveBufferSharing) {
97
- const Ctor2 = view.constructor;
98
- const result2 = new Ctor2(view);
99
- refs.set(value, result2);
100
- return result2;
101
- }
102
- const Ctor = view.constructor;
103
- const { buffer, byteOffset, length } = view;
104
- const result = new Ctor(cloneBuffer(buffer, refs), byteOffset, length);
105
- refs.set(value, result);
106
- return result;
54
+ return cloneArrayBufferView(
55
+ value,
56
+ settings,
57
+ refs
58
+ );
107
59
  }
108
60
  if (value instanceof DOMException || value instanceof Error) {
109
61
  return cloneError(value, settings, refs);
@@ -137,9 +89,87 @@ function clone(value, settings, refs) {
137
89
  refs.set(value, value);
138
90
  return value;
139
91
  }
92
+ function cloneWithDescriptors(object, settings, refs) {
93
+ const result = Object.create(Object.getPrototypeOf(object));
94
+ refs.set(object, result);
95
+ const descs = Object.getOwnPropertyDescriptors(object);
96
+ forEachOwnKey(descs, (key) => {
97
+ if (isUnsafeKey(key)) {
98
+ return;
99
+ }
100
+ const desc = { ...descs[key] };
101
+ if ("value" in desc) {
102
+ desc.value = clone(desc.value, settings, refs);
103
+ }
104
+ try {
105
+ Object.defineProperty(result, key, desc);
106
+ } catch (error) {
107
+ if (settings.strictDescriptors) {
108
+ throw error;
109
+ }
110
+ }
111
+ });
112
+ return result;
113
+ }
114
+ function cloneArray(array, settings, refs) {
115
+ if (isShallowArray(array)) {
116
+ const result2 = array.slice();
117
+ refs.set(array, result2);
118
+ return result2;
119
+ }
120
+ const { length } = array;
121
+ const result = new Array(length);
122
+ refs.set(array, result);
123
+ for (let i = 0; i < length; i++) {
124
+ result[i] = clone(array[i], settings, refs);
125
+ }
126
+ return result;
127
+ }
128
+ function clonePlainObject(object, settings, refs) {
129
+ const result = Object.create(Object.getPrototypeOf(object));
130
+ refs.set(object, result);
131
+ if (!settings.preserveSymbolKeys) {
132
+ for (const key in object) {
133
+ if (isUnsafeKey(key) || !Object.hasOwn(object, key)) {
134
+ continue;
135
+ }
136
+ result[key] = clone(object[key], settings, refs);
137
+ }
138
+ } else {
139
+ for (const key of Reflect.ownKeys(object)) {
140
+ if (isUnsafeKey(key) || !Object.propertyIsEnumerable.call(object, key)) {
141
+ continue;
142
+ }
143
+ result[key] = clone(object[key], settings, refs);
144
+ }
145
+ }
146
+ return result;
147
+ }
148
+ function cloneArrayBufferView(view, settings, refs) {
149
+ if (view instanceof DataView) {
150
+ const { buffer: buffer2, byteOffset: byteOffset2, byteLength } = view;
151
+ const result2 = new DataView(
152
+ cloneBuffer(buffer2, refs),
153
+ byteOffset2,
154
+ byteLength
155
+ );
156
+ refs.set(view, result2);
157
+ return result2;
158
+ }
159
+ if (!settings.preserveBufferSharing) {
160
+ const Ctor2 = view.constructor;
161
+ const result2 = new Ctor2(view);
162
+ refs.set(view, result2);
163
+ return result2;
164
+ }
165
+ const Ctor = view.constructor;
166
+ const { buffer, byteOffset, length } = view;
167
+ const result = new Ctor(cloneBuffer(buffer, refs), byteOffset, length);
168
+ refs.set(view, result);
169
+ return result;
170
+ }
140
171
  function cloneBuffer(buffer, refs) {
141
- const ref = refs.get(buffer);
142
- if (ref !== void 0) {
172
+ if (refs.has(buffer)) {
143
173
  return refs.get(buffer);
144
174
  }
145
175
  const result = buffer.slice(0);
@@ -167,28 +197,6 @@ function cloneError(error, settings, refs) {
167
197
  }
168
198
  return result;
169
199
  }
170
- function cloneWithDescriptors(object, settings, refs) {
171
- const result = Object.create(Object.getPrototypeOf(object));
172
- refs.set(object, result);
173
- const descs = Object.getOwnPropertyDescriptors(object);
174
- forEachOwnKey(descs, (key) => {
175
- if (isUnsafeKey(key)) {
176
- return;
177
- }
178
- const desc = { ...descs[key] };
179
- if ("value" in desc) {
180
- desc.value = clone(desc.value, settings, refs);
181
- }
182
- try {
183
- Object.defineProperty(result, key, desc);
184
- } catch (error) {
185
- if (settings.strictDescriptors) {
186
- throw error;
187
- }
188
- }
189
- });
190
- return result;
191
- }
192
200
  var ERROR_CTORS = {
193
201
  EvalError,
194
202
  RangeError,
@@ -235,12 +243,7 @@ function isPlainObject(value) {
235
243
  return proto === Object.prototype || proto === null;
236
244
  }
237
245
  function isShallowArray(array) {
238
- for (let i = 0, l = array.length; i < l; i++) {
239
- if (isObject(array[i])) {
240
- return false;
241
- }
242
- }
243
- return true;
246
+ return array.every((item) => !isObject(item));
244
247
  }
245
248
  function isUnsafeKey(key) {
246
249
  return typeof key === "string" && (key === "__proto__" || key === "prototype" || key === "constructor");
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "bunshin-clone",
3
- "version": "1.8.0",
3
+ "version": "1.8.2",
4
4
  "description": "High-performance deep clone utility with descriptor support",
5
5
  "keywords": [
6
6
  "array",