@vue/reactivity 3.2.40 → 3.2.41

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 (9) hide show
  1. package/dist/reactivity.cjs.js +1221 -1219
  2. package/dist/reactivity.cjs.prod.js +1146 -1144
  3. package/dist/reactivity.d.ts +1 -0
  4. package/dist/reactivity.esm-browser.js +1273 -1271
  5. package/dist/reactivity.esm-browser.prod.js +1 -1
  6. package/dist/reactivity.esm-bundler.js +1234 -1232
  7. package/dist/reactivity.global.js +1273 -1271
  8. package/dist/reactivity.global.prod.js +1 -1
  9. package/package.json +2 -2
package/dist/reactivity.esm-browser.js CHANGED
@@ -1,1296 +1,1298 @@
1
- /**
2
- * Make a map and return a function for checking if a key
3
- * is in that map.
4
- * IMPORTANT: all calls of this function must be prefixed with
5
- * \/\*#\_\_PURE\_\_\*\/
6
- * So that rollup can tree-shake them if necessary.
7
- */
8
- function makeMap(str, expectsLowerCase) {
9
- const map = Object.create(null);
10
- const list = str.split(',');
11
- for (let i = 0; i < list.length; i++) {
12
- map[list[i]] = true;
13
- }
14
- return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];
1
+ /**
2
+ * Make a map and return a function for checking if a key
3
+ * is in that map.
4
+ * IMPORTANT: all calls of this function must be prefixed with
5
+ * \/\*#\_\_PURE\_\_\*\/
6
+ * So that rollup can tree-shake them if necessary.
7
+ */
8
+ function makeMap(str, expectsLowerCase) {
9
+ const map = Object.create(null);
10
+ const list = str.split(',');
11
+ for (let i = 0; i < list.length; i++) {
12
+ map[list[i]] = true;
13
+ }
14
+ return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];
15
15
  }
16
16
 
17
- Object.freeze({})
18
- ;
19
- Object.freeze([]) ;
20
- const extend = Object.assign;
21
- const hasOwnProperty = Object.prototype.hasOwnProperty;
22
- const hasOwn = (val, key) => hasOwnProperty.call(val, key);
23
- const isArray = Array.isArray;
24
- const isMap = (val) => toTypeString(val) === '[object Map]';
25
- const isFunction = (val) => typeof val === 'function';
26
- const isString = (val) => typeof val === 'string';
27
- const isSymbol = (val) => typeof val === 'symbol';
28
- const isObject = (val) => val !== null && typeof val === 'object';
29
- const objectToString = Object.prototype.toString;
30
- const toTypeString = (value) => objectToString.call(value);
31
- const toRawType = (value) => {
32
- // extract "RawType" from strings like "[object RawType]"
33
- return toTypeString(value).slice(8, -1);
34
- };
35
- const isIntegerKey = (key) => isString(key) &&
36
- key !== 'NaN' &&
37
- key[0] !== '-' &&
38
- '' + parseInt(key, 10) === key;
39
- const cacheStringFunction = (fn) => {
40
- const cache = Object.create(null);
41
- return ((str) => {
42
- const hit = cache[str];
43
- return hit || (cache[str] = fn(str));
44
- });
45
- };
46
- /**
47
- * @private
48
- */
49
- const capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));
50
- // compare whether a value has changed, accounting for NaN.
51
- const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
52
- const def = (obj, key, value) => {
53
- Object.defineProperty(obj, key, {
54
- configurable: true,
55
- enumerable: false,
56
- value
57
- });
17
+ Object.freeze({})
18
+ ;
19
+ Object.freeze([]) ;
20
+ const extend = Object.assign;
21
+ const hasOwnProperty = Object.prototype.hasOwnProperty;
22
+ const hasOwn = (val, key) => hasOwnProperty.call(val, key);
23
+ const isArray = Array.isArray;
24
+ const isMap = (val) => toTypeString(val) === '[object Map]';
25
+ const isFunction = (val) => typeof val === 'function';
26
+ const isString = (val) => typeof val === 'string';
27
+ const isSymbol = (val) => typeof val === 'symbol';
28
+ const isObject = (val) => val !== null && typeof val === 'object';
29
+ const objectToString = Object.prototype.toString;
30
+ const toTypeString = (value) => objectToString.call(value);
31
+ const toRawType = (value) => {
32
+ // extract "RawType" from strings like "[object RawType]"
33
+ return toTypeString(value).slice(8, -1);
34
+ };
35
+ const isIntegerKey = (key) => isString(key) &&
36
+ key !== 'NaN' &&
37
+ key[0] !== '-' &&
38
+ '' + parseInt(key, 10) === key;
39
+ const cacheStringFunction = (fn) => {
40
+ const cache = Object.create(null);
41
+ return ((str) => {
42
+ const hit = cache[str];
43
+ return hit || (cache[str] = fn(str));
44
+ });
45
+ };
46
+ /**
47
+ * @private
48
+ */
49
+ const capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));
50
+ // compare whether a value has changed, accounting for NaN.
51
+ const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
52
+ const def = (obj, key, value) => {
53
+ Object.defineProperty(obj, key, {
54
+ configurable: true,
55
+ enumerable: false,
56
+ value
57
+ });
58
58
  };
59
59
 
60
- function warn(msg, ...args) {
61
- console.warn(`[Vue warn] ${msg}`, ...args);
60
+ function warn(msg, ...args) {
61
+ console.warn(`[Vue warn] ${msg}`, ...args);
62
62
  }
63
63
 
64
- let activeEffectScope;
65
- class EffectScope {
66
- constructor(detached = false) {
67
- /**
68
- * @internal
69
- */
70
- this.active = true;
71
- /**
72
- * @internal
73
- */
74
- this.effects = [];
75
- /**
76
- * @internal
77
- */
78
- this.cleanups = [];
79
- if (!detached && activeEffectScope) {
80
- this.parent = activeEffectScope;
81
- this.index =
82
- (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1;
83
- }
84
- }
85
- run(fn) {
86
- if (this.active) {
87
- const currentEffectScope = activeEffectScope;
88
- try {
89
- activeEffectScope = this;
90
- return fn();
91
- }
92
- finally {
93
- activeEffectScope = currentEffectScope;
94
- }
95
- }
96
- else {
97
- warn(`cannot run an inactive effect scope.`);
98
- }
99
- }
100
- /**
101
- * This should only be called on non-detached scopes
102
- * @internal
103
- */
104
- on() {
105
- activeEffectScope = this;
106
- }
107
- /**
108
- * This should only be called on non-detached scopes
109
- * @internal
110
- */
111
- off() {
112
- activeEffectScope = this.parent;
113
- }
114
- stop(fromParent) {
115
- if (this.active) {
116
- let i, l;
117
- for (i = 0, l = this.effects.length; i < l; i++) {
118
- this.effects[i].stop();
119
- }
120
- for (i = 0, l = this.cleanups.length; i < l; i++) {
121
- this.cleanups[i]();
122
- }
123
- if (this.scopes) {
124
- for (i = 0, l = this.scopes.length; i < l; i++) {
125
- this.scopes[i].stop(true);
126
- }
127
- }
128
- // nested scope, dereference from parent to avoid memory leaks
129
- if (this.parent && !fromParent) {
130
- // optimized O(1) removal
131
- const last = this.parent.scopes.pop();
132
- if (last && last !== this) {
133
- this.parent.scopes[this.index] = last;
134
- last.index = this.index;
135
- }
136
- }
137
- this.active = false;
138
- }
139
- }
140
- }
141
- function effectScope(detached) {
142
- return new EffectScope(detached);
143
- }
144
- function recordEffectScope(effect, scope = activeEffectScope) {
145
- if (scope && scope.active) {
146
- scope.effects.push(effect);
147
- }
148
- }
149
- function getCurrentScope() {
150
- return activeEffectScope;
151
- }
152
- function onScopeDispose(fn) {
153
- if (activeEffectScope) {
154
- activeEffectScope.cleanups.push(fn);
155
- }
156
- else {
157
- warn(`onScopeDispose() is called when there is no active effect scope` +
158
- ` to be associated with.`);
159
- }
64
+ let activeEffectScope;
65
+ class EffectScope {
66
+ constructor(detached = false) {
67
+ this.detached = detached;
68
+ /**
69
+ * @internal
70
+ */
71
+ this.active = true;
72
+ /**
73
+ * @internal
74
+ */
75
+ this.effects = [];
76
+ /**
77
+ * @internal
78
+ */
79
+ this.cleanups = [];
80
+ this.parent = activeEffectScope;
81
+ if (!detached && activeEffectScope) {
82
+ this.index =
83
+ (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1;
84
+ }
85
+ }
86
+ run(fn) {
87
+ if (this.active) {
88
+ const currentEffectScope = activeEffectScope;
89
+ try {
90
+ activeEffectScope = this;
91
+ return fn();
92
+ }
93
+ finally {
94
+ activeEffectScope = currentEffectScope;
95
+ }
96
+ }
97
+ else {
98
+ warn(`cannot run an inactive effect scope.`);
99
+ }
100
+ }
101
+ /**
102
+ * This should only be called on non-detached scopes
103
+ * @internal
104
+ */
105
+ on() {
106
+ activeEffectScope = this;
107
+ }
108
+ /**
109
+ * This should only be called on non-detached scopes
110
+ * @internal
111
+ */
112
+ off() {
113
+ activeEffectScope = this.parent;
114
+ }
115
+ stop(fromParent) {
116
+ if (this.active) {
117
+ let i, l;
118
+ for (i = 0, l = this.effects.length; i < l; i++) {
119
+ this.effects[i].stop();
120
+ }
121
+ for (i = 0, l = this.cleanups.length; i < l; i++) {
122
+ this.cleanups[i]();
123
+ }
124
+ if (this.scopes) {
125
+ for (i = 0, l = this.scopes.length; i < l; i++) {
126
+ this.scopes[i].stop(true);
127
+ }
128
+ }
129
+ // nested scope, dereference from parent to avoid memory leaks
130
+ if (!this.detached && this.parent && !fromParent) {
131
+ // optimized O(1) removal
132
+ const last = this.parent.scopes.pop();
133
+ if (last && last !== this) {
134
+ this.parent.scopes[this.index] = last;
135
+ last.index = this.index;
136
+ }
137
+ }
138
+ this.parent = undefined;
139
+ this.active = false;
140
+ }
141
+ }
142
+ }
143
+ function effectScope(detached) {
144
+ return new EffectScope(detached);
145
+ }
146
+ function recordEffectScope(effect, scope = activeEffectScope) {
147
+ if (scope && scope.active) {
148
+ scope.effects.push(effect);
149
+ }
150
+ }
151
+ function getCurrentScope() {
152
+ return activeEffectScope;
153
+ }
154
+ function onScopeDispose(fn) {
155
+ if (activeEffectScope) {
156
+ activeEffectScope.cleanups.push(fn);
157
+ }
158
+ else {
159
+ warn(`onScopeDispose() is called when there is no active effect scope` +
160
+ ` to be associated with.`);
161
+ }
160
162
  }
161
163
 
162
- const createDep = (effects) => {
163
- const dep = new Set(effects);
164
- dep.w = 0;
165
- dep.n = 0;
166
- return dep;
167
- };
168
- const wasTracked = (dep) => (dep.w & trackOpBit) > 0;
169
- const newTracked = (dep) => (dep.n & trackOpBit) > 0;
170
- const initDepMarkers = ({ deps }) => {
171
- if (deps.length) {
172
- for (let i = 0; i < deps.length; i++) {
173
- deps[i].w |= trackOpBit; // set was tracked
174
- }
175
- }
176
- };
177
- const finalizeDepMarkers = (effect) => {
178
- const { deps } = effect;
179
- if (deps.length) {
180
- let ptr = 0;
181
- for (let i = 0; i < deps.length; i++) {
182
- const dep = deps[i];
183
- if (wasTracked(dep) && !newTracked(dep)) {
184
- dep.delete(effect);
185
- }
186
- else {
187
- deps[ptr++] = dep;
188
- }
189
- // clear bits
190
- dep.w &= ~trackOpBit;
191
- dep.n &= ~trackOpBit;
192
- }
193
- deps.length = ptr;
194
- }
164
+ const createDep = (effects) => {
165
+ const dep = new Set(effects);
166
+ dep.w = 0;
167
+ dep.n = 0;
168
+ return dep;
169
+ };
170
+ const wasTracked = (dep) => (dep.w & trackOpBit) > 0;
171
+ const newTracked = (dep) => (dep.n & trackOpBit) > 0;
172
+ const initDepMarkers = ({ deps }) => {
173
+ if (deps.length) {
174
+ for (let i = 0; i < deps.length; i++) {
175
+ deps[i].w |= trackOpBit; // set was tracked
176
+ }
177
+ }
178
+ };
179
+ const finalizeDepMarkers = (effect) => {
180
+ const { deps } = effect;
181
+ if (deps.length) {
182
+ let ptr = 0;
183
+ for (let i = 0; i < deps.length; i++) {
184
+ const dep = deps[i];
185
+ if (wasTracked(dep) && !newTracked(dep)) {
186
+ dep.delete(effect);
187
+ }
188
+ else {
189
+ deps[ptr++] = dep;
190
+ }
191
+ // clear bits
192
+ dep.w &= ~trackOpBit;
193
+ dep.n &= ~trackOpBit;
194
+ }
195
+ deps.length = ptr;
196
+ }
195
197
  };
196
198
 
197
- const targetMap = new WeakMap();
198
- // The number of effects currently being tracked recursively.
199
- let effectTrackDepth = 0;
200
- let trackOpBit = 1;
201
- /**
202
- * The bitwise track markers support at most 30 levels of recursion.
203
- * This value is chosen to enable modern JS engines to use a SMI on all platforms.
204
- * When recursion depth is greater, fall back to using a full cleanup.
205
- */
206
- const maxMarkerBits = 30;
207
- let activeEffect;
208
- const ITERATE_KEY = Symbol('iterate' );
209
- const MAP_KEY_ITERATE_KEY = Symbol('Map key iterate' );
210
- class ReactiveEffect {
211
- constructor(fn, scheduler = null, scope) {
212
- this.fn = fn;
213
- this.scheduler = scheduler;
214
- this.active = true;
215
- this.deps = [];
216
- this.parent = undefined;
217
- recordEffectScope(this, scope);
218
- }
219
- run() {
220
- if (!this.active) {
221
- return this.fn();
222
- }
223
- let parent = activeEffect;
224
- let lastShouldTrack = shouldTrack;
225
- while (parent) {
226
- if (parent === this) {
227
- return;
228
- }
229
- parent = parent.parent;
230
- }
231
- try {
232
- this.parent = activeEffect;
233
- activeEffect = this;
234
- shouldTrack = true;
235
- trackOpBit = 1 << ++effectTrackDepth;
236
- if (effectTrackDepth <= maxMarkerBits) {
237
- initDepMarkers(this);
238
- }
239
- else {
240
- cleanupEffect(this);
241
- }
242
- return this.fn();
243
- }
244
- finally {
245
- if (effectTrackDepth <= maxMarkerBits) {
246
- finalizeDepMarkers(this);
247
- }
248
- trackOpBit = 1 << --effectTrackDepth;
249
- activeEffect = this.parent;
250
- shouldTrack = lastShouldTrack;
251
- this.parent = undefined;
252
- if (this.deferStop) {
253
- this.stop();
254
- }
255
- }
256
- }
257
- stop() {
258
- // stopped while running itself - defer the cleanup
259
- if (activeEffect === this) {
260
- this.deferStop = true;
261
- }
262
- else if (this.active) {
263
- cleanupEffect(this);
264
- if (this.onStop) {
265
- this.onStop();
266
- }
267
- this.active = false;
268
- }
269
- }
270
- }
271
- function cleanupEffect(effect) {
272
- const { deps } = effect;
273
- if (deps.length) {
274
- for (let i = 0; i < deps.length; i++) {
275
- deps[i].delete(effect);
276
- }
277
- deps.length = 0;
278
- }
279
- }
280
- function effect(fn, options) {
281
- if (fn.effect) {
282
- fn = fn.effect.fn;
283
- }
284
- const _effect = new ReactiveEffect(fn);
285
- if (options) {
286
- extend(_effect, options);
287
- if (options.scope)
288
- recordEffectScope(_effect, options.scope);
289
- }
290
- if (!options || !options.lazy) {
291
- _effect.run();
292
- }
293
- const runner = _effect.run.bind(_effect);
294
- runner.effect = _effect;
295
- return runner;
296
- }
297
- function stop(runner) {
298
- runner.effect.stop();
299
- }
300
- let shouldTrack = true;
301
- const trackStack = [];
302
- function pauseTracking() {
303
- trackStack.push(shouldTrack);
304
- shouldTrack = false;
305
- }
306
- function enableTracking() {
307
- trackStack.push(shouldTrack);
308
- shouldTrack = true;
309
- }
310
- function resetTracking() {
311
- const last = trackStack.pop();
312
- shouldTrack = last === undefined ? true : last;
313
- }
314
- function track(target, type, key) {
315
- if (shouldTrack && activeEffect) {
316
- let depsMap = targetMap.get(target);
317
- if (!depsMap) {
318
- targetMap.set(target, (depsMap = new Map()));
319
- }
320
- let dep = depsMap.get(key);
321
- if (!dep) {
322
- depsMap.set(key, (dep = createDep()));
323
- }
324
- const eventInfo = { effect: activeEffect, target, type, key }
325
- ;
326
- trackEffects(dep, eventInfo);
327
- }
328
- }
329
- function trackEffects(dep, debuggerEventExtraInfo) {
330
- let shouldTrack = false;
331
- if (effectTrackDepth <= maxMarkerBits) {
332
- if (!newTracked(dep)) {
333
- dep.n |= trackOpBit; // set newly tracked
334
- shouldTrack = !wasTracked(dep);
335
- }
336
- }
337
- else {
338
- // Full cleanup mode.
339
- shouldTrack = !dep.has(activeEffect);
340
- }
341
- if (shouldTrack) {
342
- dep.add(activeEffect);
343
- activeEffect.deps.push(dep);
344
- if (activeEffect.onTrack) {
345
- activeEffect.onTrack(Object.assign({ effect: activeEffect }, debuggerEventExtraInfo));
346
- }
347
- }
348
- }
349
- function trigger(target, type, key, newValue, oldValue, oldTarget) {
350
- const depsMap = targetMap.get(target);
351
- if (!depsMap) {
352
- // never been tracked
353
- return;
354
- }
355
- let deps = [];
356
- if (type === "clear" /* TriggerOpTypes.CLEAR */) {
357
- // collection being cleared
358
- // trigger all effects for target
359
- deps = [...depsMap.values()];
360
- }
361
- else if (key === 'length' && isArray(target)) {
362
- depsMap.forEach((dep, key) => {
363
- if (key === 'length' || key >= newValue) {
364
- deps.push(dep);
365
- }
366
- });
367
- }
368
- else {
369
- // schedule runs for SET | ADD | DELETE
370
- if (key !== void 0) {
371
- deps.push(depsMap.get(key));
372
- }
373
- // also run for iteration key on ADD | DELETE | Map.SET
374
- switch (type) {
375
- case "add" /* TriggerOpTypes.ADD */:
376
- if (!isArray(target)) {
377
- deps.push(depsMap.get(ITERATE_KEY));
378
- if (isMap(target)) {
379
- deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
380
- }
381
- }
382
- else if (isIntegerKey(key)) {
383
- // new index added to array -> length changes
384
- deps.push(depsMap.get('length'));
385
- }
386
- break;
387
- case "delete" /* TriggerOpTypes.DELETE */:
388
- if (!isArray(target)) {
389
- deps.push(depsMap.get(ITERATE_KEY));
390
- if (isMap(target)) {
391
- deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
392
- }
393
- }
394
- break;
395
- case "set" /* TriggerOpTypes.SET */:
396
- if (isMap(target)) {
397
- deps.push(depsMap.get(ITERATE_KEY));
398
- }
399
- break;
400
- }
401
- }
402
- const eventInfo = { target, type, key, newValue, oldValue, oldTarget }
403
- ;
404
- if (deps.length === 1) {
405
- if (deps[0]) {
406
- {
407
- triggerEffects(deps[0], eventInfo);
408
- }
409
- }
410
- }
411
- else {
412
- const effects = [];
413
- for (const dep of deps) {
414
- if (dep) {
415
- effects.push(...dep);
416
- }
417
- }
418
- {
419
- triggerEffects(createDep(effects), eventInfo);
420
- }
421
- }
422
- }
423
- function triggerEffects(dep, debuggerEventExtraInfo) {
424
- // spread into array for stabilization
425
- const effects = isArray(dep) ? dep : [...dep];
426
- for (const effect of effects) {
427
- if (effect.computed) {
428
- triggerEffect(effect, debuggerEventExtraInfo);
429
- }
430
- }
431
- for (const effect of effects) {
432
- if (!effect.computed) {
433
- triggerEffect(effect, debuggerEventExtraInfo);
434
- }
435
- }
436
- }
437
- function triggerEffect(effect, debuggerEventExtraInfo) {
438
- if (effect !== activeEffect || effect.allowRecurse) {
439
- if (effect.onTrigger) {
440
- effect.onTrigger(extend({ effect }, debuggerEventExtraInfo));
441
- }
442
- if (effect.scheduler) {
443
- effect.scheduler();
444
- }
445
- else {
446
- effect.run();
447
- }
448
- }
199
+ const targetMap = new WeakMap();
200
+ // The number of effects currently being tracked recursively.
201
+ let effectTrackDepth = 0;
202
+ let trackOpBit = 1;
203
+ /**
204
+ * The bitwise track markers support at most 30 levels of recursion.
205
+ * This value is chosen to enable modern JS engines to use a SMI on all platforms.
206
+ * When recursion depth is greater, fall back to using a full cleanup.
207
+ */
208
+ const maxMarkerBits = 30;
209
+ let activeEffect;
210
+ const ITERATE_KEY = Symbol('iterate' );
211
+ const MAP_KEY_ITERATE_KEY = Symbol('Map key iterate' );
212
+ class ReactiveEffect {
213
+ constructor(fn, scheduler = null, scope) {
214
+ this.fn = fn;
215
+ this.scheduler = scheduler;
216
+ this.active = true;
217
+ this.deps = [];
218
+ this.parent = undefined;
219
+ recordEffectScope(this, scope);
220
+ }
221
+ run() {
222
+ if (!this.active) {
223
+ return this.fn();
224
+ }
225
+ let parent = activeEffect;
226
+ let lastShouldTrack = shouldTrack;
227
+ while (parent) {
228
+ if (parent === this) {
229
+ return;
230
+ }
231
+ parent = parent.parent;
232
+ }
233
+ try {
234
+ this.parent = activeEffect;
235
+ activeEffect = this;
236
+ shouldTrack = true;
237
+ trackOpBit = 1 << ++effectTrackDepth;
238
+ if (effectTrackDepth <= maxMarkerBits) {
239
+ initDepMarkers(this);
240
+ }
241
+ else {
242
+ cleanupEffect(this);
243
+ }
244
+ return this.fn();
245
+ }
246
+ finally {
247
+ if (effectTrackDepth <= maxMarkerBits) {
248
+ finalizeDepMarkers(this);
249
+ }
250
+ trackOpBit = 1 << --effectTrackDepth;
251
+ activeEffect = this.parent;
252
+ shouldTrack = lastShouldTrack;
253
+ this.parent = undefined;
254
+ if (this.deferStop) {
255
+ this.stop();
256
+ }
257
+ }
258
+ }
259
+ stop() {
260
+ // stopped while running itself - defer the cleanup
261
+ if (activeEffect === this) {
262
+ this.deferStop = true;
263
+ }
264
+ else if (this.active) {
265
+ cleanupEffect(this);
266
+ if (this.onStop) {
267
+ this.onStop();
268
+ }
269
+ this.active = false;
270
+ }
271
+ }
272
+ }
273
+ function cleanupEffect(effect) {
274
+ const { deps } = effect;
275
+ if (deps.length) {
276
+ for (let i = 0; i < deps.length; i++) {
277
+ deps[i].delete(effect);
278
+ }
279
+ deps.length = 0;
280
+ }
281
+ }
282
+ function effect(fn, options) {
283
+ if (fn.effect) {
284
+ fn = fn.effect.fn;
285
+ }
286
+ const _effect = new ReactiveEffect(fn);
287
+ if (options) {
288
+ extend(_effect, options);
289
+ if (options.scope)
290
+ recordEffectScope(_effect, options.scope);
291
+ }
292
+ if (!options || !options.lazy) {
293
+ _effect.run();
294
+ }
295
+ const runner = _effect.run.bind(_effect);
296
+ runner.effect = _effect;
297
+ return runner;
298
+ }
299
+ function stop(runner) {
300
+ runner.effect.stop();
301
+ }
302
+ let shouldTrack = true;
303
+ const trackStack = [];
304
+ function pauseTracking() {
305
+ trackStack.push(shouldTrack);
306
+ shouldTrack = false;
307
+ }
308
+ function enableTracking() {
309
+ trackStack.push(shouldTrack);
310
+ shouldTrack = true;
311
+ }
312
+ function resetTracking() {
313
+ const last = trackStack.pop();
314
+ shouldTrack = last === undefined ? true : last;
315
+ }
316
+ function track(target, type, key) {
317
+ if (shouldTrack && activeEffect) {
318
+ let depsMap = targetMap.get(target);
319
+ if (!depsMap) {
320
+ targetMap.set(target, (depsMap = new Map()));
321
+ }
322
+ let dep = depsMap.get(key);
323
+ if (!dep) {
324
+ depsMap.set(key, (dep = createDep()));
325
+ }
326
+ const eventInfo = { effect: activeEffect, target, type, key }
327
+ ;
328
+ trackEffects(dep, eventInfo);
329
+ }
330
+ }
331
+ function trackEffects(dep, debuggerEventExtraInfo) {
332
+ let shouldTrack = false;
333
+ if (effectTrackDepth <= maxMarkerBits) {
334
+ if (!newTracked(dep)) {
335
+ dep.n |= trackOpBit; // set newly tracked
336
+ shouldTrack = !wasTracked(dep);
337
+ }
338
+ }
339
+ else {
340
+ // Full cleanup mode.
341
+ shouldTrack = !dep.has(activeEffect);
342
+ }
343
+ if (shouldTrack) {
344
+ dep.add(activeEffect);
345
+ activeEffect.deps.push(dep);
346
+ if (activeEffect.onTrack) {
347
+ activeEffect.onTrack(Object.assign({ effect: activeEffect }, debuggerEventExtraInfo));
348
+ }
349
+ }
350
+ }
351
+ function trigger(target, type, key, newValue, oldValue, oldTarget) {
352
+ const depsMap = targetMap.get(target);
353
+ if (!depsMap) {
354
+ // never been tracked
355
+ return;
356
+ }
357
+ let deps = [];
358
+ if (type === "clear" /* TriggerOpTypes.CLEAR */) {
359
+ // collection being cleared
360
+ // trigger all effects for target
361
+ deps = [...depsMap.values()];
362
+ }
363
+ else if (key === 'length' && isArray(target)) {
364
+ depsMap.forEach((dep, key) => {
365
+ if (key === 'length' || key >= newValue) {
366
+ deps.push(dep);
367
+ }
368
+ });
369
+ }
370
+ else {
371
+ // schedule runs for SET | ADD | DELETE
372
+ if (key !== void 0) {
373
+ deps.push(depsMap.get(key));
374
+ }
375
+ // also run for iteration key on ADD | DELETE | Map.SET
376
+ switch (type) {
377
+ case "add" /* TriggerOpTypes.ADD */:
378
+ if (!isArray(target)) {
379
+ deps.push(depsMap.get(ITERATE_KEY));
380
+ if (isMap(target)) {
381
+ deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
382
+ }
383
+ }
384
+ else if (isIntegerKey(key)) {
385
+ // new index added to array -> length changes
386
+ deps.push(depsMap.get('length'));
387
+ }
388
+ break;
389
+ case "delete" /* TriggerOpTypes.DELETE */:
390
+ if (!isArray(target)) {
391
+ deps.push(depsMap.get(ITERATE_KEY));
392
+ if (isMap(target)) {
393
+ deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
394
+ }
395
+ }
396
+ break;
397
+ case "set" /* TriggerOpTypes.SET */:
398
+ if (isMap(target)) {
399
+ deps.push(depsMap.get(ITERATE_KEY));
400
+ }
401
+ break;
402
+ }
403
+ }
404
+ const eventInfo = { target, type, key, newValue, oldValue, oldTarget }
405
+ ;
406
+ if (deps.length === 1) {
407
+ if (deps[0]) {
408
+ {
409
+ triggerEffects(deps[0], eventInfo);
410
+ }
411
+ }
412
+ }
413
+ else {
414
+ const effects = [];
415
+ for (const dep of deps) {
416
+ if (dep) {
417
+ effects.push(...dep);
418
+ }
419
+ }
420
+ {
421
+ triggerEffects(createDep(effects), eventInfo);
422
+ }
423
+ }
424
+ }
425
+ function triggerEffects(dep, debuggerEventExtraInfo) {
426
+ // spread into array for stabilization
427
+ const effects = isArray(dep) ? dep : [...dep];
428
+ for (const effect of effects) {
429
+ if (effect.computed) {
430
+ triggerEffect(effect, debuggerEventExtraInfo);
431
+ }
432
+ }
433
+ for (const effect of effects) {
434
+ if (!effect.computed) {
435
+ triggerEffect(effect, debuggerEventExtraInfo);
436
+ }
437
+ }
438
+ }
439
+ function triggerEffect(effect, debuggerEventExtraInfo) {
440
+ if (effect !== activeEffect || effect.allowRecurse) {
441
+ if (effect.onTrigger) {
442
+ effect.onTrigger(extend({ effect }, debuggerEventExtraInfo));
443
+ }
444
+ if (effect.scheduler) {
445
+ effect.scheduler();
446
+ }
447
+ else {
448
+ effect.run();
449
+ }
450
+ }
449
451
  }
450
452
 
451
- const isNonTrackableKeys = /*#__PURE__*/ makeMap(`__proto__,__v_isRef,__isVue`);
452
- const builtInSymbols = new Set(
453
- /*#__PURE__*/
454
- Object.getOwnPropertyNames(Symbol)
455
- // ios10.x Object.getOwnPropertyNames(Symbol) can enumerate 'arguments' and 'caller'
456
- // but accessing them on Symbol leads to TypeError because Symbol is a strict mode
457
- // function
458
- .filter(key => key !== 'arguments' && key !== 'caller')
459
- .map(key => Symbol[key])
460
- .filter(isSymbol));
461
- const get = /*#__PURE__*/ createGetter();
462
- const shallowGet = /*#__PURE__*/ createGetter(false, true);
463
- const readonlyGet = /*#__PURE__*/ createGetter(true);
464
- const shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);
465
- const arrayInstrumentations = /*#__PURE__*/ createArrayInstrumentations();
466
- function createArrayInstrumentations() {
467
- const instrumentations = {};
468
- ['includes', 'indexOf', 'lastIndexOf'].forEach(key => {
469
- instrumentations[key] = function (...args) {
470
- const arr = toRaw(this);
471
- for (let i = 0, l = this.length; i < l; i++) {
472
- track(arr, "get" /* TrackOpTypes.GET */, i + '');
473
- }
474
- // we run the method using the original args first (which may be reactive)
475
- const res = arr[key](...args);
476
- if (res === -1 || res === false) {
477
- // if that didn't work, run it again using raw values.
478
- return arr[key](...args.map(toRaw));
479
- }
480
- else {
481
- return res;
482
- }
483
- };
484
- });
485
- ['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {
486
- instrumentations[key] = function (...args) {
487
- pauseTracking();
488
- const res = toRaw(this)[key].apply(this, args);
489
- resetTracking();
490
- return res;
491
- };
492
- });
493
- return instrumentations;
494
- }
495
- function createGetter(isReadonly = false, shallow = false) {
496
- return function get(target, key, receiver) {
497
- if (key === "__v_isReactive" /* ReactiveFlags.IS_REACTIVE */) {
498
- return !isReadonly;
499
- }
500
- else if (key === "__v_isReadonly" /* ReactiveFlags.IS_READONLY */) {
501
- return isReadonly;
502
- }
503
- else if (key === "__v_isShallow" /* ReactiveFlags.IS_SHALLOW */) {
504
- return shallow;
505
- }
506
- else if (key === "__v_raw" /* ReactiveFlags.RAW */ &&
507
- receiver ===
508
- (isReadonly
509
- ? shallow
510
- ? shallowReadonlyMap
511
- : readonlyMap
512
- : shallow
513
- ? shallowReactiveMap
514
- : reactiveMap).get(target)) {
515
- return target;
516
- }
517
- const targetIsArray = isArray(target);
518
- if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {
519
- return Reflect.get(arrayInstrumentations, key, receiver);
520
- }
521
- const res = Reflect.get(target, key, receiver);
522
- if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
523
- return res;
524
- }
525
- if (!isReadonly) {
526
- track(target, "get" /* TrackOpTypes.GET */, key);
527
- }
528
- if (shallow) {
529
- return res;
530
- }
531
- if (isRef(res)) {
532
- // ref unwrapping - skip unwrap for Array + integer key.
533
- return targetIsArray && isIntegerKey(key) ? res : res.value;
534
- }
535
- if (isObject(res)) {
536
- // Convert returned value into a proxy as well. we do the isObject check
537
- // here to avoid invalid value warning. Also need to lazy access readonly
538
- // and reactive here to avoid circular dependency.
539
- return isReadonly ? readonly(res) : reactive(res);
540
- }
541
- return res;
542
- };
543
- }
544
- const set = /*#__PURE__*/ createSetter();
545
- const shallowSet = /*#__PURE__*/ createSetter(true);
546
- function createSetter(shallow = false) {
547
- return function set(target, key, value, receiver) {
548
- let oldValue = target[key];
549
- if (isReadonly(oldValue) && isRef(oldValue) && !isRef(value)) {
550
- return false;
551
- }
552
- if (!shallow) {
553
- if (!isShallow(value) && !isReadonly(value)) {
554
- oldValue = toRaw(oldValue);
555
- value = toRaw(value);
556
- }
557
- if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
558
- oldValue.value = value;
559
- return true;
560
- }
561
- }
562
- const hadKey = isArray(target) && isIntegerKey(key)
563
- ? Number(key) < target.length
564
- : hasOwn(target, key);
565
- const result = Reflect.set(target, key, value, receiver);
566
- // don't trigger if target is something up in the prototype chain of original
567
- if (target === toRaw(receiver)) {
568
- if (!hadKey) {
569
- trigger(target, "add" /* TriggerOpTypes.ADD */, key, value);
570
- }
571
- else if (hasChanged(value, oldValue)) {
572
- trigger(target, "set" /* TriggerOpTypes.SET */, key, value, oldValue);
573
- }
574
- }
575
- return result;
576
- };
577
- }
578
- function deleteProperty(target, key) {
579
- const hadKey = hasOwn(target, key);
580
- const oldValue = target[key];
581
- const result = Reflect.deleteProperty(target, key);
582
- if (result && hadKey) {
583
- trigger(target, "delete" /* TriggerOpTypes.DELETE */, key, undefined, oldValue);
584
- }
585
- return result;
586
- }
587
- function has(target, key) {
588
- const result = Reflect.has(target, key);
589
- if (!isSymbol(key) || !builtInSymbols.has(key)) {
590
- track(target, "has" /* TrackOpTypes.HAS */, key);
591
- }
592
- return result;
593
- }
594
- function ownKeys(target) {
595
- track(target, "iterate" /* TrackOpTypes.ITERATE */, isArray(target) ? 'length' : ITERATE_KEY);
596
- return Reflect.ownKeys(target);
597
- }
598
- const mutableHandlers = {
599
- get,
600
- set,
601
- deleteProperty,
602
- has,
603
- ownKeys
604
- };
605
- const readonlyHandlers = {
606
- get: readonlyGet,
607
- set(target, key) {
608
- {
609
- warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
610
- }
611
- return true;
612
- },
613
- deleteProperty(target, key) {
614
- {
615
- warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
616
- }
617
- return true;
618
- }
619
- };
620
- const shallowReactiveHandlers = /*#__PURE__*/ extend({}, mutableHandlers, {
621
- get: shallowGet,
622
- set: shallowSet
623
- });
624
- // Props handlers are special in the sense that it should not unwrap top-level
625
- // refs (in order to allow refs to be explicitly passed down), but should
626
- // retain the reactivity of the normal readonly object.
627
- const shallowReadonlyHandlers = /*#__PURE__*/ extend({}, readonlyHandlers, {
628
- get: shallowReadonlyGet
453
+ const isNonTrackableKeys = /*#__PURE__*/ makeMap(`__proto__,__v_isRef,__isVue`);
454
+ const builtInSymbols = new Set(
455
+ /*#__PURE__*/
456
+ Object.getOwnPropertyNames(Symbol)
457
+ // ios10.x Object.getOwnPropertyNames(Symbol) can enumerate 'arguments' and 'caller'
458
+ // but accessing them on Symbol leads to TypeError because Symbol is a strict mode
459
+ // function
460
+ .filter(key => key !== 'arguments' && key !== 'caller')
461
+ .map(key => Symbol[key])
462
+ .filter(isSymbol));
463
+ const get = /*#__PURE__*/ createGetter();
464
+ const shallowGet = /*#__PURE__*/ createGetter(false, true);
465
+ const readonlyGet = /*#__PURE__*/ createGetter(true);
466
+ const shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);
467
+ const arrayInstrumentations = /*#__PURE__*/ createArrayInstrumentations();
468
+ function createArrayInstrumentations() {
469
+ const instrumentations = {};
470
+ ['includes', 'indexOf', 'lastIndexOf'].forEach(key => {
471
+ instrumentations[key] = function (...args) {
472
+ const arr = toRaw(this);
473
+ for (let i = 0, l = this.length; i < l; i++) {
474
+ track(arr, "get" /* TrackOpTypes.GET */, i + '');
475
+ }
476
+ // we run the method using the original args first (which may be reactive)
477
+ const res = arr[key](...args);
478
+ if (res === -1 || res === false) {
479
+ // if that didn't work, run it again using raw values.
480
+ return arr[key](...args.map(toRaw));
481
+ }
482
+ else {
483
+ return res;
484
+ }
485
+ };
486
+ });
487
+ ['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {
488
+ instrumentations[key] = function (...args) {
489
+ pauseTracking();
490
+ const res = toRaw(this)[key].apply(this, args);
491
+ resetTracking();
492
+ return res;
493
+ };
494
+ });
495
+ return instrumentations;
496
+ }
497
+ function createGetter(isReadonly = false, shallow = false) {
498
+ return function get(target, key, receiver) {
499
+ if (key === "__v_isReactive" /* ReactiveFlags.IS_REACTIVE */) {
500
+ return !isReadonly;
501
+ }
502
+ else if (key === "__v_isReadonly" /* ReactiveFlags.IS_READONLY */) {
503
+ return isReadonly;
504
+ }
505
+ else if (key === "__v_isShallow" /* ReactiveFlags.IS_SHALLOW */) {
506
+ return shallow;
507
+ }
508
+ else if (key === "__v_raw" /* ReactiveFlags.RAW */ &&
509
+ receiver ===
510
+ (isReadonly
511
+ ? shallow
512
+ ? shallowReadonlyMap
513
+ : readonlyMap
514
+ : shallow
515
+ ? shallowReactiveMap
516
+ : reactiveMap).get(target)) {
517
+ return target;
518
+ }
519
+ const targetIsArray = isArray(target);
520
+ if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {
521
+ return Reflect.get(arrayInstrumentations, key, receiver);
522
+ }
523
+ const res = Reflect.get(target, key, receiver);
524
+ if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
525
+ return res;
526
+ }
527
+ if (!isReadonly) {
528
+ track(target, "get" /* TrackOpTypes.GET */, key);
529
+ }
530
+ if (shallow) {
531
+ return res;
532
+ }
533
+ if (isRef(res)) {
534
+ // ref unwrapping - skip unwrap for Array + integer key.
535
+ return targetIsArray && isIntegerKey(key) ? res : res.value;
536
+ }
537
+ if (isObject(res)) {
538
+ // Convert returned value into a proxy as well. we do the isObject check
539
+ // here to avoid invalid value warning. Also need to lazy access readonly
540
+ // and reactive here to avoid circular dependency.
541
+ return isReadonly ? readonly(res) : reactive(res);
542
+ }
543
+ return res;
544
+ };
545
+ }
546
+ const set = /*#__PURE__*/ createSetter();
547
+ const shallowSet = /*#__PURE__*/ createSetter(true);
548
+ function createSetter(shallow = false) {
549
+ return function set(target, key, value, receiver) {
550
+ let oldValue = target[key];
551
+ if (isReadonly(oldValue) && isRef(oldValue) && !isRef(value)) {
552
+ return false;
553
+ }
554
+ if (!shallow) {
555
+ if (!isShallow(value) && !isReadonly(value)) {
556
+ oldValue = toRaw(oldValue);
557
+ value = toRaw(value);
558
+ }
559
+ if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
560
+ oldValue.value = value;
561
+ return true;
562
+ }
563
+ }
564
+ const hadKey = isArray(target) && isIntegerKey(key)
565
+ ? Number(key) < target.length
566
+ : hasOwn(target, key);
567
+ const result = Reflect.set(target, key, value, receiver);
568
+ // don't trigger if target is something up in the prototype chain of original
569
+ if (target === toRaw(receiver)) {
570
+ if (!hadKey) {
571
+ trigger(target, "add" /* TriggerOpTypes.ADD */, key, value);
572
+ }
573
+ else if (hasChanged(value, oldValue)) {
574
+ trigger(target, "set" /* TriggerOpTypes.SET */, key, value, oldValue);
575
+ }
576
+ }
577
+ return result;
578
+ };
579
+ }
580
+ function deleteProperty(target, key) {
581
+ const hadKey = hasOwn(target, key);
582
+ const oldValue = target[key];
583
+ const result = Reflect.deleteProperty(target, key);
584
+ if (result && hadKey) {
585
+ trigger(target, "delete" /* TriggerOpTypes.DELETE */, key, undefined, oldValue);
586
+ }
587
+ return result;
588
+ }
589
+ function has(target, key) {
590
+ const result = Reflect.has(target, key);
591
+ if (!isSymbol(key) || !builtInSymbols.has(key)) {
592
+ track(target, "has" /* TrackOpTypes.HAS */, key);
593
+ }
594
+ return result;
595
+ }
596
+ function ownKeys(target) {
597
+ track(target, "iterate" /* TrackOpTypes.ITERATE */, isArray(target) ? 'length' : ITERATE_KEY);
598
+ return Reflect.ownKeys(target);
599
+ }
600
+ const mutableHandlers = {
601
+ get,
602
+ set,
603
+ deleteProperty,
604
+ has,
605
+ ownKeys
606
+ };
607
+ const readonlyHandlers = {
608
+ get: readonlyGet,
609
+ set(target, key) {
610
+ {
611
+ warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
612
+ }
613
+ return true;
614
+ },
615
+ deleteProperty(target, key) {
616
+ {
617
+ warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
618
+ }
619
+ return true;
620
+ }
621
+ };
622
+ const shallowReactiveHandlers = /*#__PURE__*/ extend({}, mutableHandlers, {
623
+ get: shallowGet,
624
+ set: shallowSet
625
+ });
626
+ // Props handlers are special in the sense that it should not unwrap top-level
627
+ // refs (in order to allow refs to be explicitly passed down), but should
628
+ // retain the reactivity of the normal readonly object.
629
+ const shallowReadonlyHandlers = /*#__PURE__*/ extend({}, readonlyHandlers, {
630
+ get: shallowReadonlyGet
629
631
  });
630
632
 
631
- const toShallow = (value) => value;
632
- const getProto = (v) => Reflect.getPrototypeOf(v);
633
- function get$1(target, key, isReadonly = false, isShallow = false) {
634
- // #1772: readonly(reactive(Map)) should return readonly + reactive version
635
- // of the value
636
- target = target["__v_raw" /* ReactiveFlags.RAW */];
637
- const rawTarget = toRaw(target);
638
- const rawKey = toRaw(key);
639
- if (!isReadonly) {
640
- if (key !== rawKey) {
641
- track(rawTarget, "get" /* TrackOpTypes.GET */, key);
642
- }
643
- track(rawTarget, "get" /* TrackOpTypes.GET */, rawKey);
644
- }
645
- const { has } = getProto(rawTarget);
646
- const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
647
- if (has.call(rawTarget, key)) {
648
- return wrap(target.get(key));
649
- }
650
- else if (has.call(rawTarget, rawKey)) {
651
- return wrap(target.get(rawKey));
652
- }
653
- else if (target !== rawTarget) {
654
- // #3602 readonly(reactive(Map))
655
- // ensure that the nested reactive `Map` can do tracking for itself
656
- target.get(key);
657
- }
658
- }
659
- function has$1(key, isReadonly = false) {
660
- const target = this["__v_raw" /* ReactiveFlags.RAW */];
661
- const rawTarget = toRaw(target);
662
- const rawKey = toRaw(key);
663
- if (!isReadonly) {
664
- if (key !== rawKey) {
665
- track(rawTarget, "has" /* TrackOpTypes.HAS */, key);
666
- }
667
- track(rawTarget, "has" /* TrackOpTypes.HAS */, rawKey);
668
- }
669
- return key === rawKey
670
- ? target.has(key)
671
- : target.has(key) || target.has(rawKey);
672
- }
673
- function size(target, isReadonly = false) {
674
- target = target["__v_raw" /* ReactiveFlags.RAW */];
675
- !isReadonly && track(toRaw(target), "iterate" /* TrackOpTypes.ITERATE */, ITERATE_KEY);
676
- return Reflect.get(target, 'size', target);
677
- }
678
- function add(value) {
679
- value = toRaw(value);
680
- const target = toRaw(this);
681
- const proto = getProto(target);
682
- const hadKey = proto.has.call(target, value);
683
- if (!hadKey) {
684
- target.add(value);
685
- trigger(target, "add" /* TriggerOpTypes.ADD */, value, value);
686
- }
687
- return this;
688
- }
689
- function set$1(key, value) {
690
- value = toRaw(value);
691
- const target = toRaw(this);
692
- const { has, get } = getProto(target);
693
- let hadKey = has.call(target, key);
694
- if (!hadKey) {
695
- key = toRaw(key);
696
- hadKey = has.call(target, key);
697
- }
698
- else {
699
- checkIdentityKeys(target, has, key);
700
- }
701
- const oldValue = get.call(target, key);
702
- target.set(key, value);
703
- if (!hadKey) {
704
- trigger(target, "add" /* TriggerOpTypes.ADD */, key, value);
705
- }
706
- else if (hasChanged(value, oldValue)) {
707
- trigger(target, "set" /* TriggerOpTypes.SET */, key, value, oldValue);
708
- }
709
- return this;
710
- }
711
- function deleteEntry(key) {
712
- const target = toRaw(this);
713
- const { has, get } = getProto(target);
714
- let hadKey = has.call(target, key);
715
- if (!hadKey) {
716
- key = toRaw(key);
717
- hadKey = has.call(target, key);
718
- }
719
- else {
720
- checkIdentityKeys(target, has, key);
721
- }
722
- const oldValue = get ? get.call(target, key) : undefined;
723
- // forward the operation before queueing reactions
724
- const result = target.delete(key);
725
- if (hadKey) {
726
- trigger(target, "delete" /* TriggerOpTypes.DELETE */, key, undefined, oldValue);
727
- }
728
- return result;
729
- }
730
- function clear() {
731
- const target = toRaw(this);
732
- const hadItems = target.size !== 0;
733
- const oldTarget = isMap(target)
734
- ? new Map(target)
735
- : new Set(target)
736
- ;
737
- // forward the operation before queueing reactions
738
- const result = target.clear();
739
- if (hadItems) {
740
- trigger(target, "clear" /* TriggerOpTypes.CLEAR */, undefined, undefined, oldTarget);
741
- }
742
- return result;
743
- }
744
- function createForEach(isReadonly, isShallow) {
745
- return function forEach(callback, thisArg) {
746
- const observed = this;
747
- const target = observed["__v_raw" /* ReactiveFlags.RAW */];
748
- const rawTarget = toRaw(target);
749
- const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
750
- !isReadonly && track(rawTarget, "iterate" /* TrackOpTypes.ITERATE */, ITERATE_KEY);
751
- return target.forEach((value, key) => {
752
- // important: make sure the callback is
753
- // 1. invoked with the reactive map as `this` and 3rd arg
754
- // 2. the value received should be a corresponding reactive/readonly.
755
- return callback.call(thisArg, wrap(value), wrap(key), observed);
756
- });
757
- };
758
- }
759
- function createIterableMethod(method, isReadonly, isShallow) {
760
- return function (...args) {
761
- const target = this["__v_raw" /* ReactiveFlags.RAW */];
762
- const rawTarget = toRaw(target);
763
- const targetIsMap = isMap(rawTarget);
764
- const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);
765
- const isKeyOnly = method === 'keys' && targetIsMap;
766
- const innerIterator = target[method](...args);
767
- const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
768
- !isReadonly &&
769
- track(rawTarget, "iterate" /* TrackOpTypes.ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
770
- // return a wrapped iterator which returns observed versions of the
771
- // values emitted from the real iterator
772
- return {
773
- // iterator protocol
774
- next() {
775
- const { value, done } = innerIterator.next();
776
- return done
777
- ? { value, done }
778
- : {
779
- value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
780
- done
781
- };
782
- },
783
- // iterable protocol
784
- [Symbol.iterator]() {
785
- return this;
786
- }
787
- };
788
- };
789
- }
790
- function createReadonlyMethod(type) {
791
- return function (...args) {
792
- {
793
- const key = args[0] ? `on key "${args[0]}" ` : ``;
794
- console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
795
- }
796
- return type === "delete" /* TriggerOpTypes.DELETE */ ? false : this;
797
- };
798
- }
799
- function createInstrumentations() {
800
- const mutableInstrumentations = {
801
- get(key) {
802
- return get$1(this, key);
803
- },
804
- get size() {
805
- return size(this);
806
- },
807
- has: has$1,
808
- add,
809
- set: set$1,
810
- delete: deleteEntry,
811
- clear,
812
- forEach: createForEach(false, false)
813
- };
814
- const shallowInstrumentations = {
815
- get(key) {
816
- return get$1(this, key, false, true);
817
- },
818
- get size() {
819
- return size(this);
820
- },
821
- has: has$1,
822
- add,
823
- set: set$1,
824
- delete: deleteEntry,
825
- clear,
826
- forEach: createForEach(false, true)
827
- };
828
- const readonlyInstrumentations = {
829
- get(key) {
830
- return get$1(this, key, true);
831
- },
832
- get size() {
833
- return size(this, true);
834
- },
835
- has(key) {
836
- return has$1.call(this, key, true);
837
- },
838
- add: createReadonlyMethod("add" /* TriggerOpTypes.ADD */),
839
- set: createReadonlyMethod("set" /* TriggerOpTypes.SET */),
840
- delete: createReadonlyMethod("delete" /* TriggerOpTypes.DELETE */),
841
- clear: createReadonlyMethod("clear" /* TriggerOpTypes.CLEAR */),
842
- forEach: createForEach(true, false)
843
- };
844
- const shallowReadonlyInstrumentations = {
845
- get(key) {
846
- return get$1(this, key, true, true);
847
- },
848
- get size() {
849
- return size(this, true);
850
- },
851
- has(key) {
852
- return has$1.call(this, key, true);
853
- },
854
- add: createReadonlyMethod("add" /* TriggerOpTypes.ADD */),
855
- set: createReadonlyMethod("set" /* TriggerOpTypes.SET */),
856
- delete: createReadonlyMethod("delete" /* TriggerOpTypes.DELETE */),
857
- clear: createReadonlyMethod("clear" /* TriggerOpTypes.CLEAR */),
858
- forEach: createForEach(true, true)
859
- };
860
- const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];
861
- iteratorMethods.forEach(method => {
862
- mutableInstrumentations[method] = createIterableMethod(method, false, false);
863
- readonlyInstrumentations[method] = createIterableMethod(method, true, false);
864
- shallowInstrumentations[method] = createIterableMethod(method, false, true);
865
- shallowReadonlyInstrumentations[method] = createIterableMethod(method, true, true);
866
- });
867
- return [
868
- mutableInstrumentations,
869
- readonlyInstrumentations,
870
- shallowInstrumentations,
871
- shallowReadonlyInstrumentations
872
- ];
873
- }
874
- const [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* #__PURE__*/ createInstrumentations();
875
- function createInstrumentationGetter(isReadonly, shallow) {
876
- const instrumentations = shallow
877
- ? isReadonly
878
- ? shallowReadonlyInstrumentations
879
- : shallowInstrumentations
880
- : isReadonly
881
- ? readonlyInstrumentations
882
- : mutableInstrumentations;
883
- return (target, key, receiver) => {
884
- if (key === "__v_isReactive" /* ReactiveFlags.IS_REACTIVE */) {
885
- return !isReadonly;
886
- }
887
- else if (key === "__v_isReadonly" /* ReactiveFlags.IS_READONLY */) {
888
- return isReadonly;
889
- }
890
- else if (key === "__v_raw" /* ReactiveFlags.RAW */) {
891
- return target;
892
- }
893
- return Reflect.get(hasOwn(instrumentations, key) && key in target
894
- ? instrumentations
895
- : target, key, receiver);
896
- };
897
- }
898
- const mutableCollectionHandlers = {
899
- get: /*#__PURE__*/ createInstrumentationGetter(false, false)
900
- };
901
- const shallowCollectionHandlers = {
902
- get: /*#__PURE__*/ createInstrumentationGetter(false, true)
903
- };
904
- const readonlyCollectionHandlers = {
905
- get: /*#__PURE__*/ createInstrumentationGetter(true, false)
906
- };
907
- const shallowReadonlyCollectionHandlers = {
908
- get: /*#__PURE__*/ createInstrumentationGetter(true, true)
909
- };
910
- function checkIdentityKeys(target, has, key) {
911
- const rawKey = toRaw(key);
912
- if (rawKey !== key && has.call(target, rawKey)) {
913
- const type = toRawType(target);
914
- console.warn(`Reactive ${type} contains both the raw and reactive ` +
915
- `versions of the same object${type === `Map` ? ` as keys` : ``}, ` +
916
- `which can lead to inconsistencies. ` +
917
- `Avoid differentiating between the raw and reactive versions ` +
918
- `of an object and only use the reactive version if possible.`);
919
- }
633
+ const toShallow = (value) => value;
634
+ const getProto = (v) => Reflect.getPrototypeOf(v);
635
+ function get$1(target, key, isReadonly = false, isShallow = false) {
636
+ // #1772: readonly(reactive(Map)) should return readonly + reactive version
637
+ // of the value
638
+ target = target["__v_raw" /* ReactiveFlags.RAW */];
639
+ const rawTarget = toRaw(target);
640
+ const rawKey = toRaw(key);
641
+ if (!isReadonly) {
642
+ if (key !== rawKey) {
643
+ track(rawTarget, "get" /* TrackOpTypes.GET */, key);
644
+ }
645
+ track(rawTarget, "get" /* TrackOpTypes.GET */, rawKey);
646
+ }
647
+ const { has } = getProto(rawTarget);
648
+ const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
649
+ if (has.call(rawTarget, key)) {
650
+ return wrap(target.get(key));
651
+ }
652
+ else if (has.call(rawTarget, rawKey)) {
653
+ return wrap(target.get(rawKey));
654
+ }
655
+ else if (target !== rawTarget) {
656
+ // #3602 readonly(reactive(Map))
657
+ // ensure that the nested reactive `Map` can do tracking for itself
658
+ target.get(key);
659
+ }
660
+ }
661
+ function has$1(key, isReadonly = false) {
662
+ const target = this["__v_raw" /* ReactiveFlags.RAW */];
663
+ const rawTarget = toRaw(target);
664
+ const rawKey = toRaw(key);
665
+ if (!isReadonly) {
666
+ if (key !== rawKey) {
667
+ track(rawTarget, "has" /* TrackOpTypes.HAS */, key);
668
+ }
669
+ track(rawTarget, "has" /* TrackOpTypes.HAS */, rawKey);
670
+ }
671
+ return key === rawKey
672
+ ? target.has(key)
673
+ : target.has(key) || target.has(rawKey);
674
+ }
675
+ function size(target, isReadonly = false) {
676
+ target = target["__v_raw" /* ReactiveFlags.RAW */];
677
+ !isReadonly && track(toRaw(target), "iterate" /* TrackOpTypes.ITERATE */, ITERATE_KEY);
678
+ return Reflect.get(target, 'size', target);
679
+ }
680
+ function add(value) {
681
+ value = toRaw(value);
682
+ const target = toRaw(this);
683
+ const proto = getProto(target);
684
+ const hadKey = proto.has.call(target, value);
685
+ if (!hadKey) {
686
+ target.add(value);
687
+ trigger(target, "add" /* TriggerOpTypes.ADD */, value, value);
688
+ }
689
+ return this;
690
+ }
691
+ function set$1(key, value) {
692
+ value = toRaw(value);
693
+ const target = toRaw(this);
694
+ const { has, get } = getProto(target);
695
+ let hadKey = has.call(target, key);
696
+ if (!hadKey) {
697
+ key = toRaw(key);
698
+ hadKey = has.call(target, key);
699
+ }
700
+ else {
701
+ checkIdentityKeys(target, has, key);
702
+ }
703
+ const oldValue = get.call(target, key);
704
+ target.set(key, value);
705
+ if (!hadKey) {
706
+ trigger(target, "add" /* TriggerOpTypes.ADD */, key, value);
707
+ }
708
+ else if (hasChanged(value, oldValue)) {
709
+ trigger(target, "set" /* TriggerOpTypes.SET */, key, value, oldValue);
710
+ }
711
+ return this;
712
+ }
713
+ function deleteEntry(key) {
714
+ const target = toRaw(this);
715
+ const { has, get } = getProto(target);
716
+ let hadKey = has.call(target, key);
717
+ if (!hadKey) {
718
+ key = toRaw(key);
719
+ hadKey = has.call(target, key);
720
+ }
721
+ else {
722
+ checkIdentityKeys(target, has, key);
723
+ }
724
+ const oldValue = get ? get.call(target, key) : undefined;
725
+ // forward the operation before queueing reactions
726
+ const result = target.delete(key);
727
+ if (hadKey) {
728
+ trigger(target, "delete" /* TriggerOpTypes.DELETE */, key, undefined, oldValue);
729
+ }
730
+ return result;
731
+ }
732
+ function clear() {
733
+ const target = toRaw(this);
734
+ const hadItems = target.size !== 0;
735
+ const oldTarget = isMap(target)
736
+ ? new Map(target)
737
+ : new Set(target)
738
+ ;
739
+ // forward the operation before queueing reactions
740
+ const result = target.clear();
741
+ if (hadItems) {
742
+ trigger(target, "clear" /* TriggerOpTypes.CLEAR */, undefined, undefined, oldTarget);
743
+ }
744
+ return result;
745
+ }
746
+ function createForEach(isReadonly, isShallow) {
747
+ return function forEach(callback, thisArg) {
748
+ const observed = this;
749
+ const target = observed["__v_raw" /* ReactiveFlags.RAW */];
750
+ const rawTarget = toRaw(target);
751
+ const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
752
+ !isReadonly && track(rawTarget, "iterate" /* TrackOpTypes.ITERATE */, ITERATE_KEY);
753
+ return target.forEach((value, key) => {
754
+ // important: make sure the callback is
755
+ // 1. invoked with the reactive map as `this` and 3rd arg
756
+ // 2. the value received should be a corresponding reactive/readonly.
757
+ return callback.call(thisArg, wrap(value), wrap(key), observed);
758
+ });
759
+ };
760
+ }
761
+ function createIterableMethod(method, isReadonly, isShallow) {
762
+ return function (...args) {
763
+ const target = this["__v_raw" /* ReactiveFlags.RAW */];
764
+ const rawTarget = toRaw(target);
765
+ const targetIsMap = isMap(rawTarget);
766
+ const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);
767
+ const isKeyOnly = method === 'keys' && targetIsMap;
768
+ const innerIterator = target[method](...args);
769
+ const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
770
+ !isReadonly &&
771
+ track(rawTarget, "iterate" /* TrackOpTypes.ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
772
+ // return a wrapped iterator which returns observed versions of the
773
+ // values emitted from the real iterator
774
+ return {
775
+ // iterator protocol
776
+ next() {
777
+ const { value, done } = innerIterator.next();
778
+ return done
779
+ ? { value, done }
780
+ : {
781
+ value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
782
+ done
783
+ };
784
+ },
785
+ // iterable protocol
786
+ [Symbol.iterator]() {
787
+ return this;
788
+ }
789
+ };
790
+ };
791
+ }
792
+ function createReadonlyMethod(type) {
793
+ return function (...args) {
794
+ {
795
+ const key = args[0] ? `on key "${args[0]}" ` : ``;
796
+ console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
797
+ }
798
+ return type === "delete" /* TriggerOpTypes.DELETE */ ? false : this;
799
+ };
800
+ }
801
+ function createInstrumentations() {
802
+ const mutableInstrumentations = {
803
+ get(key) {
804
+ return get$1(this, key);
805
+ },
806
+ get size() {
807
+ return size(this);
808
+ },
809
+ has: has$1,
810
+ add,
811
+ set: set$1,
812
+ delete: deleteEntry,
813
+ clear,
814
+ forEach: createForEach(false, false)
815
+ };
816
+ const shallowInstrumentations = {
817
+ get(key) {
818
+ return get$1(this, key, false, true);
819
+ },
820
+ get size() {
821
+ return size(this);
822
+ },
823
+ has: has$1,
824
+ add,
825
+ set: set$1,
826
+ delete: deleteEntry,
827
+ clear,
828
+ forEach: createForEach(false, true)
829
+ };
830
+ const readonlyInstrumentations = {
831
+ get(key) {
832
+ return get$1(this, key, true);
833
+ },
834
+ get size() {
835
+ return size(this, true);
836
+ },
837
+ has(key) {
838
+ return has$1.call(this, key, true);
839
+ },
840
+ add: createReadonlyMethod("add" /* TriggerOpTypes.ADD */),
841
+ set: createReadonlyMethod("set" /* TriggerOpTypes.SET */),
842
+ delete: createReadonlyMethod("delete" /* TriggerOpTypes.DELETE */),
843
+ clear: createReadonlyMethod("clear" /* TriggerOpTypes.CLEAR */),
844
+ forEach: createForEach(true, false)
845
+ };
846
+ const shallowReadonlyInstrumentations = {
847
+ get(key) {
848
+ return get$1(this, key, true, true);
849
+ },
850
+ get size() {
851
+ return size(this, true);
852
+ },
853
+ has(key) {
854
+ return has$1.call(this, key, true);
855
+ },
856
+ add: createReadonlyMethod("add" /* TriggerOpTypes.ADD */),
857
+ set: createReadonlyMethod("set" /* TriggerOpTypes.SET */),
858
+ delete: createReadonlyMethod("delete" /* TriggerOpTypes.DELETE */),
859
+ clear: createReadonlyMethod("clear" /* TriggerOpTypes.CLEAR */),
860
+ forEach: createForEach(true, true)
861
+ };
862
+ const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];
863
+ iteratorMethods.forEach(method => {
864
+ mutableInstrumentations[method] = createIterableMethod(method, false, false);
865
+ readonlyInstrumentations[method] = createIterableMethod(method, true, false);
866
+ shallowInstrumentations[method] = createIterableMethod(method, false, true);
867
+ shallowReadonlyInstrumentations[method] = createIterableMethod(method, true, true);
868
+ });
869
+ return [
870
+ mutableInstrumentations,
871
+ readonlyInstrumentations,
872
+ shallowInstrumentations,
873
+ shallowReadonlyInstrumentations
874
+ ];
875
+ }
876
+ const [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* #__PURE__*/ createInstrumentations();
877
+ function createInstrumentationGetter(isReadonly, shallow) {
878
+ const instrumentations = shallow
879
+ ? isReadonly
880
+ ? shallowReadonlyInstrumentations
881
+ : shallowInstrumentations
882
+ : isReadonly
883
+ ? readonlyInstrumentations
884
+ : mutableInstrumentations;
885
+ return (target, key, receiver) => {
886
+ if (key === "__v_isReactive" /* ReactiveFlags.IS_REACTIVE */) {
887
+ return !isReadonly;
888
+ }
889
+ else if (key === "__v_isReadonly" /* ReactiveFlags.IS_READONLY */) {
890
+ return isReadonly;
891
+ }
892
+ else if (key === "__v_raw" /* ReactiveFlags.RAW */) {
893
+ return target;
894
+ }
895
+ return Reflect.get(hasOwn(instrumentations, key) && key in target
896
+ ? instrumentations
897
+ : target, key, receiver);
898
+ };
899
+ }
900
+ const mutableCollectionHandlers = {
901
+ get: /*#__PURE__*/ createInstrumentationGetter(false, false)
902
+ };
903
+ const shallowCollectionHandlers = {
904
+ get: /*#__PURE__*/ createInstrumentationGetter(false, true)
905
+ };
906
+ const readonlyCollectionHandlers = {
907
+ get: /*#__PURE__*/ createInstrumentationGetter(true, false)
908
+ };
909
+ const shallowReadonlyCollectionHandlers = {
910
+ get: /*#__PURE__*/ createInstrumentationGetter(true, true)
911
+ };
912
+ function checkIdentityKeys(target, has, key) {
913
+ const rawKey = toRaw(key);
914
+ if (rawKey !== key && has.call(target, rawKey)) {
915
+ const type = toRawType(target);
916
+ console.warn(`Reactive ${type} contains both the raw and reactive ` +
917
+ `versions of the same object${type === `Map` ? ` as keys` : ``}, ` +
918
+ `which can lead to inconsistencies. ` +
919
+ `Avoid differentiating between the raw and reactive versions ` +
920
+ `of an object and only use the reactive version if possible.`);
921
+ }
920
922
  }
921
923
 
922
- const reactiveMap = new WeakMap();
923
- const shallowReactiveMap = new WeakMap();
924
- const readonlyMap = new WeakMap();
925
- const shallowReadonlyMap = new WeakMap();
926
- function targetTypeMap(rawType) {
927
- switch (rawType) {
928
- case 'Object':
929
- case 'Array':
930
- return 1 /* TargetType.COMMON */;
931
- case 'Map':
932
- case 'Set':
933
- case 'WeakMap':
934
- case 'WeakSet':
935
- return 2 /* TargetType.COLLECTION */;
936
- default:
937
- return 0 /* TargetType.INVALID */;
938
- }
939
- }
940
- function getTargetType(value) {
941
- return value["__v_skip" /* ReactiveFlags.SKIP */] || !Object.isExtensible(value)
942
- ? 0 /* TargetType.INVALID */
943
- : targetTypeMap(toRawType(value));
944
- }
945
- function reactive(target) {
946
- // if trying to observe a readonly proxy, return the readonly version.
947
- if (isReadonly(target)) {
948
- return target;
949
- }
950
- return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
951
- }
952
- /**
953
- * Return a shallowly-reactive copy of the original object, where only the root
954
- * level properties are reactive. It also does not auto-unwrap refs (even at the
955
- * root level).
956
- */
957
- function shallowReactive(target) {
958
- return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap);
959
- }
960
- /**
961
- * Creates a readonly copy of the original object. Note the returned copy is not
962
- * made reactive, but `readonly` can be called on an already reactive object.
963
- */
964
- function readonly(target) {
965
- return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
966
- }
967
- /**
968
- * Returns a reactive-copy of the original object, where only the root level
969
- * properties are readonly, and does NOT unwrap refs nor recursively convert
970
- * returned properties.
971
- * This is used for creating the props proxy object for stateful components.
972
- */
973
- function shallowReadonly(target) {
974
- return createReactiveObject(target, true, shallowReadonlyHandlers, shallowReadonlyCollectionHandlers, shallowReadonlyMap);
975
- }
976
- function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) {
977
- if (!isObject(target)) {
978
- {
979
- console.warn(`value cannot be made reactive: ${String(target)}`);
980
- }
981
- return target;
982
- }
983
- // target is already a Proxy, return it.
984
- // exception: calling readonly() on a reactive object
985
- if (target["__v_raw" /* ReactiveFlags.RAW */] &&
986
- !(isReadonly && target["__v_isReactive" /* ReactiveFlags.IS_REACTIVE */])) {
987
- return target;
988
- }
989
- // target already has corresponding Proxy
990
- const existingProxy = proxyMap.get(target);
991
- if (existingProxy) {
992
- return existingProxy;
993
- }
994
- // only specific value types can be observed.
995
- const targetType = getTargetType(target);
996
- if (targetType === 0 /* TargetType.INVALID */) {
997
- return target;
998
- }
999
- const proxy = new Proxy(target, targetType === 2 /* TargetType.COLLECTION */ ? collectionHandlers : baseHandlers);
1000
- proxyMap.set(target, proxy);
1001
- return proxy;
1002
- }
1003
- function isReactive(value) {
1004
- if (isReadonly(value)) {
1005
- return isReactive(value["__v_raw" /* ReactiveFlags.RAW */]);
1006
- }
1007
- return !!(value && value["__v_isReactive" /* ReactiveFlags.IS_REACTIVE */]);
1008
- }
1009
- function isReadonly(value) {
1010
- return !!(value && value["__v_isReadonly" /* ReactiveFlags.IS_READONLY */]);
1011
- }
1012
- function isShallow(value) {
1013
- return !!(value && value["__v_isShallow" /* ReactiveFlags.IS_SHALLOW */]);
1014
- }
1015
- function isProxy(value) {
1016
- return isReactive(value) || isReadonly(value);
1017
- }
1018
- function toRaw(observed) {
1019
- const raw = observed && observed["__v_raw" /* ReactiveFlags.RAW */];
1020
- return raw ? toRaw(raw) : observed;
1021
- }
1022
- function markRaw(value) {
1023
- def(value, "__v_skip" /* ReactiveFlags.SKIP */, true);
1024
- return value;
1025
- }
1026
- const toReactive = (value) => isObject(value) ? reactive(value) : value;
924
+ const reactiveMap = new WeakMap();
925
+ const shallowReactiveMap = new WeakMap();
926
+ const readonlyMap = new WeakMap();
927
+ const shallowReadonlyMap = new WeakMap();
928
+ function targetTypeMap(rawType) {
929
+ switch (rawType) {
930
+ case 'Object':
931
+ case 'Array':
932
+ return 1 /* TargetType.COMMON */;
933
+ case 'Map':
934
+ case 'Set':
935
+ case 'WeakMap':
936
+ case 'WeakSet':
937
+ return 2 /* TargetType.COLLECTION */;
938
+ default:
939
+ return 0 /* TargetType.INVALID */;
940
+ }
941
+ }
942
+ function getTargetType(value) {
943
+ return value["__v_skip" /* ReactiveFlags.SKIP */] || !Object.isExtensible(value)
944
+ ? 0 /* TargetType.INVALID */
945
+ : targetTypeMap(toRawType(value));
946
+ }
947
+ function reactive(target) {
948
+ // if trying to observe a readonly proxy, return the readonly version.
949
+ if (isReadonly(target)) {
950
+ return target;
951
+ }
952
+ return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
953
+ }
954
+ /**
955
+ * Return a shallowly-reactive copy of the original object, where only the root
956
+ * level properties are reactive. It also does not auto-unwrap refs (even at the
957
+ * root level).
958
+ */
959
+ function shallowReactive(target) {
960
+ return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap);
961
+ }
962
+ /**
963
+ * Creates a readonly copy of the original object. Note the returned copy is not
964
+ * made reactive, but `readonly` can be called on an already reactive object.
965
+ */
966
+ function readonly(target) {
967
+ return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
968
+ }
969
+ /**
970
+ * Returns a reactive-copy of the original object, where only the root level
971
+ * properties are readonly, and does NOT unwrap refs nor recursively convert
972
+ * returned properties.
973
+ * This is used for creating the props proxy object for stateful components.
974
+ */
975
+ function shallowReadonly(target) {
976
+ return createReactiveObject(target, true, shallowReadonlyHandlers, shallowReadonlyCollectionHandlers, shallowReadonlyMap);
977
+ }
978
+ function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) {
979
+ if (!isObject(target)) {
980
+ {
981
+ console.warn(`value cannot be made reactive: ${String(target)}`);
982
+ }
983
+ return target;
984
+ }
985
+ // target is already a Proxy, return it.
986
+ // exception: calling readonly() on a reactive object
987
+ if (target["__v_raw" /* ReactiveFlags.RAW */] &&
988
+ !(isReadonly && target["__v_isReactive" /* ReactiveFlags.IS_REACTIVE */])) {
989
+ return target;
990
+ }
991
+ // target already has corresponding Proxy
992
+ const existingProxy = proxyMap.get(target);
993
+ if (existingProxy) {
994
+ return existingProxy;
995
+ }
996
+ // only specific value types can be observed.
997
+ const targetType = getTargetType(target);
998
+ if (targetType === 0 /* TargetType.INVALID */) {
999
+ return target;
1000
+ }
1001
+ const proxy = new Proxy(target, targetType === 2 /* TargetType.COLLECTION */ ? collectionHandlers : baseHandlers);
1002
+ proxyMap.set(target, proxy);
1003
+ return proxy;
1004
+ }
1005
+ function isReactive(value) {
1006
+ if (isReadonly(value)) {
1007
+ return isReactive(value["__v_raw" /* ReactiveFlags.RAW */]);
1008
+ }
1009
+ return !!(value && value["__v_isReactive" /* ReactiveFlags.IS_REACTIVE */]);
1010
+ }
1011
+ function isReadonly(value) {
1012
+ return !!(value && value["__v_isReadonly" /* ReactiveFlags.IS_READONLY */]);
1013
+ }
1014
+ function isShallow(value) {
1015
+ return !!(value && value["__v_isShallow" /* ReactiveFlags.IS_SHALLOW */]);
1016
+ }
1017
+ function isProxy(value) {
1018
+ return isReactive(value) || isReadonly(value);
1019
+ }
1020
+ function toRaw(observed) {
1021
+ const raw = observed && observed["__v_raw" /* ReactiveFlags.RAW */];
1022
+ return raw ? toRaw(raw) : observed;
1023
+ }
1024
+ function markRaw(value) {
1025
+ def(value, "__v_skip" /* ReactiveFlags.SKIP */, true);
1026
+ return value;
1027
+ }
1028
+ const toReactive = (value) => isObject(value) ? reactive(value) : value;
1027
1029
  const toReadonly = (value) => isObject(value) ? readonly(value) : value;
1028
1030
 
1029
- function trackRefValue(ref) {
1030
- if (shouldTrack && activeEffect) {
1031
- ref = toRaw(ref);
1032
- {
1033
- trackEffects(ref.dep || (ref.dep = createDep()), {
1034
- target: ref,
1035
- type: "get" /* TrackOpTypes.GET */,
1036
- key: 'value'
1037
- });
1038
- }
1039
- }
1040
- }
1041
- function triggerRefValue(ref, newVal) {
1042
- ref = toRaw(ref);
1043
- if (ref.dep) {
1044
- {
1045
- triggerEffects(ref.dep, {
1046
- target: ref,
1047
- type: "set" /* TriggerOpTypes.SET */,
1048
- key: 'value',
1049
- newValue: newVal
1050
- });
1051
- }
1052
- }
1053
- }
1054
- function isRef(r) {
1055
- return !!(r && r.__v_isRef === true);
1056
- }
1057
- function ref(value) {
1058
- return createRef(value, false);
1059
- }
1060
- function shallowRef(value) {
1061
- return createRef(value, true);
1062
- }
1063
- function createRef(rawValue, shallow) {
1064
- if (isRef(rawValue)) {
1065
- return rawValue;
1066
- }
1067
- return new RefImpl(rawValue, shallow);
1068
- }
1069
- class RefImpl {
1070
- constructor(value, __v_isShallow) {
1071
- this.__v_isShallow = __v_isShallow;
1072
- this.dep = undefined;
1073
- this.__v_isRef = true;
1074
- this._rawValue = __v_isShallow ? value : toRaw(value);
1075
- this._value = __v_isShallow ? value : toReactive(value);
1076
- }
1077
- get value() {
1078
- trackRefValue(this);
1079
- return this._value;
1080
- }
1081
- set value(newVal) {
1082
- const useDirectValue = this.__v_isShallow || isShallow(newVal) || isReadonly(newVal);
1083
- newVal = useDirectValue ? newVal : toRaw(newVal);
1084
- if (hasChanged(newVal, this._rawValue)) {
1085
- this._rawValue = newVal;
1086
- this._value = useDirectValue ? newVal : toReactive(newVal);
1087
- triggerRefValue(this, newVal);
1088
- }
1089
- }
1090
- }
1091
- function triggerRef(ref) {
1092
- triggerRefValue(ref, ref.value );
1093
- }
1094
- function unref(ref) {
1095
- return isRef(ref) ? ref.value : ref;
1096
- }
1097
- const shallowUnwrapHandlers = {
1098
- get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
1099
- set: (target, key, value, receiver) => {
1100
- const oldValue = target[key];
1101
- if (isRef(oldValue) && !isRef(value)) {
1102
- oldValue.value = value;
1103
- return true;
1104
- }
1105
- else {
1106
- return Reflect.set(target, key, value, receiver);
1107
- }
1108
- }
1109
- };
1110
- function proxyRefs(objectWithRefs) {
1111
- return isReactive(objectWithRefs)
1112
- ? objectWithRefs
1113
- : new Proxy(objectWithRefs, shallowUnwrapHandlers);
1114
- }
1115
- class CustomRefImpl {
1116
- constructor(factory) {
1117
- this.dep = undefined;
1118
- this.__v_isRef = true;
1119
- const { get, set } = factory(() => trackRefValue(this), () => triggerRefValue(this));
1120
- this._get = get;
1121
- this._set = set;
1122
- }
1123
- get value() {
1124
- return this._get();
1125
- }
1126
- set value(newVal) {
1127
- this._set(newVal);
1128
- }
1129
- }
1130
- function customRef(factory) {
1131
- return new CustomRefImpl(factory);
1132
- }
1133
- function toRefs(object) {
1134
- if (!isProxy(object)) {
1135
- console.warn(`toRefs() expects a reactive object but received a plain one.`);
1136
- }
1137
- const ret = isArray(object) ? new Array(object.length) : {};
1138
- for (const key in object) {
1139
- ret[key] = toRef(object, key);
1140
- }
1141
- return ret;
1142
- }
1143
- class ObjectRefImpl {
1144
- constructor(_object, _key, _defaultValue) {
1145
- this._object = _object;
1146
- this._key = _key;
1147
- this._defaultValue = _defaultValue;
1148
- this.__v_isRef = true;
1149
- }
1150
- get value() {
1151
- const val = this._object[this._key];
1152
- return val === undefined ? this._defaultValue : val;
1153
- }
1154
- set value(newVal) {
1155
- this._object[this._key] = newVal;
1156
- }
1157
- }
1158
- function toRef(object, key, defaultValue) {
1159
- const val = object[key];
1160
- return isRef(val)
1161
- ? val
1162
- : new ObjectRefImpl(object, key, defaultValue);
1031
+ function trackRefValue(ref) {
1032
+ if (shouldTrack && activeEffect) {
1033
+ ref = toRaw(ref);
1034
+ {
1035
+ trackEffects(ref.dep || (ref.dep = createDep()), {
1036
+ target: ref,
1037
+ type: "get" /* TrackOpTypes.GET */,
1038
+ key: 'value'
1039
+ });
1040
+ }
1041
+ }
1042
+ }
1043
+ function triggerRefValue(ref, newVal) {
1044
+ ref = toRaw(ref);
1045
+ if (ref.dep) {
1046
+ {
1047
+ triggerEffects(ref.dep, {
1048
+ target: ref,
1049
+ type: "set" /* TriggerOpTypes.SET */,
1050
+ key: 'value',
1051
+ newValue: newVal
1052
+ });
1053
+ }
1054
+ }
1055
+ }
1056
+ function isRef(r) {
1057
+ return !!(r && r.__v_isRef === true);
1058
+ }
1059
+ function ref(value) {
1060
+ return createRef(value, false);
1061
+ }
1062
+ function shallowRef(value) {
1063
+ return createRef(value, true);
1064
+ }
1065
+ function createRef(rawValue, shallow) {
1066
+ if (isRef(rawValue)) {
1067
+ return rawValue;
1068
+ }
1069
+ return new RefImpl(rawValue, shallow);
1070
+ }
1071
+ class RefImpl {
1072
+ constructor(value, __v_isShallow) {
1073
+ this.__v_isShallow = __v_isShallow;
1074
+ this.dep = undefined;
1075
+ this.__v_isRef = true;
1076
+ this._rawValue = __v_isShallow ? value : toRaw(value);
1077
+ this._value = __v_isShallow ? value : toReactive(value);
1078
+ }
1079
+ get value() {
1080
+ trackRefValue(this);
1081
+ return this._value;
1082
+ }
1083
+ set value(newVal) {
1084
+ const useDirectValue = this.__v_isShallow || isShallow(newVal) || isReadonly(newVal);
1085
+ newVal = useDirectValue ? newVal : toRaw(newVal);
1086
+ if (hasChanged(newVal, this._rawValue)) {
1087
+ this._rawValue = newVal;
1088
+ this._value = useDirectValue ? newVal : toReactive(newVal);
1089
+ triggerRefValue(this, newVal);
1090
+ }
1091
+ }
1092
+ }
1093
+ function triggerRef(ref) {
1094
+ triggerRefValue(ref, ref.value );
1095
+ }
1096
+ function unref(ref) {
1097
+ return isRef(ref) ? ref.value : ref;
1098
+ }
1099
+ const shallowUnwrapHandlers = {
1100
+ get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
1101
+ set: (target, key, value, receiver) => {
1102
+ const oldValue = target[key];
1103
+ if (isRef(oldValue) && !isRef(value)) {
1104
+ oldValue.value = value;
1105
+ return true;
1106
+ }
1107
+ else {
1108
+ return Reflect.set(target, key, value, receiver);
1109
+ }
1110
+ }
1111
+ };
1112
+ function proxyRefs(objectWithRefs) {
1113
+ return isReactive(objectWithRefs)
1114
+ ? objectWithRefs
1115
+ : new Proxy(objectWithRefs, shallowUnwrapHandlers);
1116
+ }
1117
+ class CustomRefImpl {
1118
+ constructor(factory) {
1119
+ this.dep = undefined;
1120
+ this.__v_isRef = true;
1121
+ const { get, set } = factory(() => trackRefValue(this), () => triggerRefValue(this));
1122
+ this._get = get;
1123
+ this._set = set;
1124
+ }
1125
+ get value() {
1126
+ return this._get();
1127
+ }
1128
+ set value(newVal) {
1129
+ this._set(newVal);
1130
+ }
1131
+ }
1132
+ function customRef(factory) {
1133
+ return new CustomRefImpl(factory);
1134
+ }
1135
+ function toRefs(object) {
1136
+ if (!isProxy(object)) {
1137
+ console.warn(`toRefs() expects a reactive object but received a plain one.`);
1138
+ }
1139
+ const ret = isArray(object) ? new Array(object.length) : {};
1140
+ for (const key in object) {
1141
+ ret[key] = toRef(object, key);
1142
+ }
1143
+ return ret;
1144
+ }
1145
+ class ObjectRefImpl {
1146
+ constructor(_object, _key, _defaultValue) {
1147
+ this._object = _object;
1148
+ this._key = _key;
1149
+ this._defaultValue = _defaultValue;
1150
+ this.__v_isRef = true;
1151
+ }
1152
+ get value() {
1153
+ const val = this._object[this._key];
1154
+ return val === undefined ? this._defaultValue : val;
1155
+ }
1156
+ set value(newVal) {
1157
+ this._object[this._key] = newVal;
1158
+ }
1159
+ }
1160
+ function toRef(object, key, defaultValue) {
1161
+ const val = object[key];
1162
+ return isRef(val)
1163
+ ? val
1164
+ : new ObjectRefImpl(object, key, defaultValue);
1163
1165
  }
1164
1166
 
1165
- var _a;
1166
- class ComputedRefImpl {
1167
- constructor(getter, _setter, isReadonly, isSSR) {
1168
- this._setter = _setter;
1169
- this.dep = undefined;
1170
- this.__v_isRef = true;
1171
- this[_a] = false;
1172
- this._dirty = true;
1173
- this.effect = new ReactiveEffect(getter, () => {
1174
- if (!this._dirty) {
1175
- this._dirty = true;
1176
- triggerRefValue(this);
1177
- }
1178
- });
1179
- this.effect.computed = this;
1180
- this.effect.active = this._cacheable = !isSSR;
1181
- this["__v_isReadonly" /* ReactiveFlags.IS_READONLY */] = isReadonly;
1182
- }
1183
- get value() {
1184
- // the computed ref may get wrapped by other proxies e.g. readonly() #3376
1185
- const self = toRaw(this);
1186
- trackRefValue(self);
1187
- if (self._dirty || !self._cacheable) {
1188
- self._dirty = false;
1189
- self._value = self.effect.run();
1190
- }
1191
- return self._value;
1192
- }
1193
- set value(newValue) {
1194
- this._setter(newValue);
1195
- }
1196
- }
1197
- _a = "__v_isReadonly" /* ReactiveFlags.IS_READONLY */;
1198
- function computed(getterOrOptions, debugOptions, isSSR = false) {
1199
- let getter;
1200
- let setter;
1201
- const onlyGetter = isFunction(getterOrOptions);
1202
- if (onlyGetter) {
1203
- getter = getterOrOptions;
1204
- setter = () => {
1205
- console.warn('Write operation failed: computed value is readonly');
1206
- }
1207
- ;
1208
- }
1209
- else {
1210
- getter = getterOrOptions.get;
1211
- setter = getterOrOptions.set;
1212
- }
1213
- const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);
1214
- if (debugOptions && !isSSR) {
1215
- cRef.effect.onTrack = debugOptions.onTrack;
1216
- cRef.effect.onTrigger = debugOptions.onTrigger;
1217
- }
1218
- return cRef;
1167
+ var _a;
1168
+ class ComputedRefImpl {
1169
+ constructor(getter, _setter, isReadonly, isSSR) {
1170
+ this._setter = _setter;
1171
+ this.dep = undefined;
1172
+ this.__v_isRef = true;
1173
+ this[_a] = false;
1174
+ this._dirty = true;
1175
+ this.effect = new ReactiveEffect(getter, () => {
1176
+ if (!this._dirty) {
1177
+ this._dirty = true;
1178
+ triggerRefValue(this);
1179
+ }
1180
+ });
1181
+ this.effect.computed = this;
1182
+ this.effect.active = this._cacheable = !isSSR;
1183
+ this["__v_isReadonly" /* ReactiveFlags.IS_READONLY */] = isReadonly;
1184
+ }
1185
+ get value() {
1186
+ // the computed ref may get wrapped by other proxies e.g. readonly() #3376
1187
+ const self = toRaw(this);
1188
+ trackRefValue(self);
1189
+ if (self._dirty || !self._cacheable) {
1190
+ self._dirty = false;
1191
+ self._value = self.effect.run();
1192
+ }
1193
+ return self._value;
1194
+ }
1195
+ set value(newValue) {
1196
+ this._setter(newValue);
1197
+ }
1198
+ }
1199
+ _a = "__v_isReadonly" /* ReactiveFlags.IS_READONLY */;
1200
+ function computed(getterOrOptions, debugOptions, isSSR = false) {
1201
+ let getter;
1202
+ let setter;
1203
+ const onlyGetter = isFunction(getterOrOptions);
1204
+ if (onlyGetter) {
1205
+ getter = getterOrOptions;
1206
+ setter = () => {
1207
+ console.warn('Write operation failed: computed value is readonly');
1208
+ }
1209
+ ;
1210
+ }
1211
+ else {
1212
+ getter = getterOrOptions.get;
1213
+ setter = getterOrOptions.set;
1214
+ }
1215
+ const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);
1216
+ if (debugOptions && !isSSR) {
1217
+ cRef.effect.onTrack = debugOptions.onTrack;
1218
+ cRef.effect.onTrigger = debugOptions.onTrigger;
1219
+ }
1220
+ return cRef;
1219
1221
  }
1220
1222
 
1221
- var _a$1;
1222
- const tick = /*#__PURE__*/ Promise.resolve();
1223
- const queue = [];
1224
- let queued = false;
1225
- const scheduler = (fn) => {
1226
- queue.push(fn);
1227
- if (!queued) {
1228
- queued = true;
1229
- tick.then(flush);
1230
- }
1231
- };
1232
- const flush = () => {
1233
- for (let i = 0; i < queue.length; i++) {
1234
- queue[i]();
1235
- }
1236
- queue.length = 0;
1237
- queued = false;
1238
- };
1239
- class DeferredComputedRefImpl {
1240
- constructor(getter) {
1241
- this.dep = undefined;
1242
- this._dirty = true;
1243
- this.__v_isRef = true;
1244
- this[_a$1] = true;
1245
- let compareTarget;
1246
- let hasCompareTarget = false;
1247
- let scheduled = false;
1248
- this.effect = new ReactiveEffect(getter, (computedTrigger) => {
1249
- if (this.dep) {
1250
- if (computedTrigger) {
1251
- compareTarget = this._value;
1252
- hasCompareTarget = true;
1253
- }
1254
- else if (!scheduled) {
1255
- const valueToCompare = hasCompareTarget ? compareTarget : this._value;
1256
- scheduled = true;
1257
- hasCompareTarget = false;
1258
- scheduler(() => {
1259
- if (this.effect.active && this._get() !== valueToCompare) {
1260
- triggerRefValue(this);
1261
- }
1262
- scheduled = false;
1263
- });
1264
- }
1265
- // chained upstream computeds are notified synchronously to ensure
1266
- // value invalidation in case of sync access; normal effects are
1267
- // deferred to be triggered in scheduler.
1268
- for (const e of this.dep) {
1269
- if (e.computed instanceof DeferredComputedRefImpl) {
1270
- e.scheduler(true /* computedTrigger */);
1271
- }
1272
- }
1273
- }
1274
- this._dirty = true;
1275
- });
1276
- this.effect.computed = this;
1277
- }
1278
- _get() {
1279
- if (this._dirty) {
1280
- this._dirty = false;
1281
- return (this._value = this.effect.run());
1282
- }
1283
- return this._value;
1284
- }
1285
- get value() {
1286
- trackRefValue(this);
1287
- // the computed ref may get wrapped by other proxies e.g. readonly() #3376
1288
- return toRaw(this)._get();
1289
- }
1290
- }
1291
- _a$1 = "__v_isReadonly" /* ReactiveFlags.IS_READONLY */;
1292
- function deferredComputed(getter) {
1293
- return new DeferredComputedRefImpl(getter);
1223
+ var _a$1;
1224
+ const tick = /*#__PURE__*/ Promise.resolve();
1225
+ const queue = [];
1226
+ let queued = false;
1227
+ const scheduler = (fn) => {
1228
+ queue.push(fn);
1229
+ if (!queued) {
1230
+ queued = true;
1231
+ tick.then(flush);
1232
+ }
1233
+ };
1234
+ const flush = () => {
1235
+ for (let i = 0; i < queue.length; i++) {
1236
+ queue[i]();
1237
+ }
1238
+ queue.length = 0;
1239
+ queued = false;
1240
+ };
1241
+ class DeferredComputedRefImpl {
1242
+ constructor(getter) {
1243
+ this.dep = undefined;
1244
+ this._dirty = true;
1245
+ this.__v_isRef = true;
1246
+ this[_a$1] = true;
1247
+ let compareTarget;
1248
+ let hasCompareTarget = false;
1249
+ let scheduled = false;
1250
+ this.effect = new ReactiveEffect(getter, (computedTrigger) => {
1251
+ if (this.dep) {
1252
+ if (computedTrigger) {
1253
+ compareTarget = this._value;
1254
+ hasCompareTarget = true;
1255
+ }
1256
+ else if (!scheduled) {
1257
+ const valueToCompare = hasCompareTarget ? compareTarget : this._value;
1258
+ scheduled = true;
1259
+ hasCompareTarget = false;
1260
+ scheduler(() => {
1261
+ if (this.effect.active && this._get() !== valueToCompare) {
1262
+ triggerRefValue(this);
1263
+ }
1264
+ scheduled = false;
1265
+ });
1266
+ }
1267
+ // chained upstream computeds are notified synchronously to ensure
1268
+ // value invalidation in case of sync access; normal effects are
1269
+ // deferred to be triggered in scheduler.
1270
+ for (const e of this.dep) {
1271
+ if (e.computed instanceof DeferredComputedRefImpl) {
1272
+ e.scheduler(true /* computedTrigger */);
1273
+ }
1274
+ }
1275
+ }
1276
+ this._dirty = true;
1277
+ });
1278
+ this.effect.computed = this;
1279
+ }
1280
+ _get() {
1281
+ if (this._dirty) {
1282
+ this._dirty = false;
1283
+ return (this._value = this.effect.run());
1284
+ }
1285
+ return this._value;
1286
+ }
1287
+ get value() {
1288
+ trackRefValue(this);
1289
+ // the computed ref may get wrapped by other proxies e.g. readonly() #3376
1290
+ return toRaw(this)._get();
1291
+ }
1292
+ }
1293
+ _a$1 = "__v_isReadonly" /* ReactiveFlags.IS_READONLY */;
1294
+ function deferredComputed(getter) {
1295
+ return new DeferredComputedRefImpl(getter);
1294
1296
  }
1295
1297
 
1296
1298
  export { EffectScope, ITERATE_KEY, ReactiveEffect, computed, customRef, deferredComputed, effect, effectScope, enableTracking, getCurrentScope, isProxy, isReactive, isReadonly, isRef, isShallow, markRaw, onScopeDispose, pauseTracking, proxyRefs, reactive, readonly, ref, resetTracking, shallowReactive, shallowReadonly, shallowRef, stop, toRaw, toRef, toRefs, track, trigger, triggerRef, unref };