wevu 6.7.2 → 6.7.4

package/dist/ref-BeA_Is-2.mjs

@@ -0,0 +1,804 @@
+import { t as _defineProperty } from "./defineProperty-JH0tR899.mjs";
+//#region src/scheduler.ts
+const resolvedPromise = Promise.resolve();
+const jobQueue = /* @__PURE__ */ new Set();
+let isFlushing = false;
+let isFlushPending = false;
+function flushJobs() {
+	isFlushPending = false;
+	isFlushing = true;
+	try {
+		jobQueue.forEach((job) => job());
+	} finally {
+		jobQueue.clear();
+		isFlushing = false;
+	}
+}
+function queueJob(job) {
+	jobQueue.add(job);
+	if (!isFlushing && !isFlushPending) {
+		isFlushPending = true;
+		resolvedPromise.then(flushJobs);
+	}
+}
+function nextTick(fn) {
+	return fn ? resolvedPromise.then(fn) : resolvedPromise;
+}
+//#endregion
+//#region src/reactivity/core.ts
+const targetMap = /* @__PURE__ */ new WeakMap();
+let activeEffect = null;
+const effectStack = [];
+let batchDepth = 0;
+const batchedEffects = /* @__PURE__ */ new Set();
+function startBatch() {
+	batchDepth++;
+}
+function flushBatchedEffects() {
+	while (batchedEffects.size) {
+		const effects = Array.from(batchedEffects);
+		batchedEffects.clear();
+		for (const ef of effects) ef();
+	}
+}
+function endBatch() {
+	if (batchDepth === 0) return;
+	batchDepth--;
+	if (batchDepth === 0) flushBatchedEffects();
+}
+function batch(fn) {
+	startBatch();
+	try {
+		return fn();
+	} finally {
+		endBatch();
+	}
+}
+function cleanupEffect(effect) {
+	const { deps } = effect;
+	for (let i = 0; i < deps.length; i++) deps[i].delete(effect);
+	deps.length = 0;
+}
+function stop(runner) {
+	var _runner$onStop;
+	if (!runner.active) return;
+	runner.active = false;
+	cleanupEffect(runner);
+	(_runner$onStop = runner.onStop) === null || _runner$onStop === void 0 || _runner$onStop.call(runner);
+}
+let activeEffectScope;
+var EffectScopeImpl = class {
+	constructor(detached = false) {
+		this.detached = detached;
+		_defineProperty(this, "active", true);
+		_defineProperty(this, "effects", []);
+		_defineProperty(this, "cleanups", []);
+		_defineProperty(this, "parent", void 0);
+		_defineProperty(this, "scopes", void 0);
+		if (!detached && activeEffectScope) {
+			var _activeEffectScope;
+			this.parent = activeEffectScope;
+			((_activeEffectScope = activeEffectScope).scopes || (_activeEffectScope.scopes = [])).push(this);
+		}
+	}
+	run(fn) {
+		if (!this.active) return;
+		const prev = activeEffectScope;
+		activeEffectScope = this;
+		try {
+			return fn();
+		} finally {
+			activeEffectScope = prev;
+		}
+	}
+	stop() {
+		var _this$parent;
+		if (!this.active) return;
+		this.active = false;
+		for (const effect of this.effects) stop(effect);
+		this.effects.length = 0;
+		for (const cleanup of this.cleanups) cleanup();
+		this.cleanups.length = 0;
+		if (this.scopes) {
+			for (const scope of this.scopes) scope.stop();
+			this.scopes.length = 0;
+		}
+		if ((_this$parent = this.parent) === null || _this$parent === void 0 ? void 0 : _this$parent.scopes) {
+			const index = this.parent.scopes.indexOf(this);
+			if (index >= 0) this.parent.scopes.splice(index, 1);
+		}
+		this.parent = void 0;
+	}
+};
+function effectScope(detached = false) {
+	return new EffectScopeImpl(detached);
+}
+function getCurrentScope() {
+	return activeEffectScope;
+}
+function onScopeDispose(fn) {
+	if (activeEffectScope === null || activeEffectScope === void 0 ? void 0 : activeEffectScope.active) activeEffectScope.cleanups.push(fn);
+}
+function recordEffectScope(effect) {
+	if (activeEffectScope === null || activeEffectScope === void 0 ? void 0 : activeEffectScope.active) activeEffectScope.effects.push(effect);
+}
+function createReactiveEffect(fn, options = {}) {
+	const effect = function reactiveEffect() {
+		if (!effect.active) return fn();
+		if (effect._running) return fn();
+		cleanupEffect(effect);
+		try {
+			effect._running = true;
+			effectStack.push(effect);
+			activeEffect = effect;
+			return fn();
+		} finally {
+			var _effectStack;
+			effectStack.pop();
+			activeEffect = (_effectStack = effectStack[effectStack.length - 1]) !== null && _effectStack !== void 0 ? _effectStack : null;
+			effect._running = false;
+		}
+	};
+	effect.deps = [];
+	effect.scheduler = options.scheduler;
+	effect.onStop = options.onStop;
+	effect.active = true;
+	effect._running = false;
+	effect._fn = fn;
+	return effect;
+}
+function effect(fn, options = {}) {
+	const _effect = createReactiveEffect(fn, options);
+	recordEffectScope(_effect);
+	if (!options.lazy) _effect();
+	return _effect;
+}
+function track(target, key) {
+	if (!activeEffect) return;
+	let depsMap = targetMap.get(target);
+	if (!depsMap) {
+		depsMap = /* @__PURE__ */ new Map();
+		targetMap.set(target, depsMap);
+	}
+	let dep = depsMap.get(key);
+	if (!dep) {
+		dep = /* @__PURE__ */ new Set();
+		depsMap.set(key, dep);
+	}
+	if (!dep.has(activeEffect)) {
+		dep.add(activeEffect);
+		activeEffect.deps.push(dep);
+	}
+}
+function scheduleEffect(ef) {
+	if (ef.scheduler) {
+		ef.scheduler();
+		return;
+	}
+	if (batchDepth > 0) {
+		batchedEffects.add(ef);
+		return;
+	}
+	ef();
+}
+function trigger(target, key) {
+	const depsMap = targetMap.get(target);
+	if (!depsMap) return;
+	const effects = depsMap.get(key);
+	if (!effects) return;
+	const effectsToRun = /* @__PURE__ */ new Set();
+	effects.forEach((ef) => {
+		if (ef !== activeEffect) effectsToRun.add(ef);
+	});
+	effectsToRun.forEach(scheduleEffect);
+}
+function trackEffects(dep) {
+	if (!activeEffect) return;
+	if (!dep.has(activeEffect)) {
+		dep.add(activeEffect);
+		activeEffect.deps.push(dep);
+	}
+}
+function triggerEffects(dep) {
+	new Set(dep).forEach(scheduleEffect);
+}
+//#endregion
+//#region src/reactivity/reactive/mutation.ts
+const mutationRecorders = /* @__PURE__ */ new Set();
+function addMutationRecorder(recorder) {
+	mutationRecorders.add(recorder);
+}
+function removeMutationRecorder(recorder) {
+	mutationRecorders.delete(recorder);
+}
+//#endregion
+//#region src/reactivity/reactive/patchState.ts
+const rawRootMap = /* @__PURE__ */ new WeakMap();
+const rawVersionMap = /* @__PURE__ */ new WeakMap();
+const rawParentMap = /* @__PURE__ */ new WeakMap();
+const rawParentsMap = /* @__PURE__ */ new WeakMap();
+const rawMultiParentSet = /* @__PURE__ */ new WeakSet();
+const rawPathMap = /* @__PURE__ */ new WeakMap();
+const rootPatchNodesMap = /* @__PURE__ */ new WeakMap();
+function getRootPatchNodes(root) {
+	let nodes = rootPatchNodesMap.get(root);
+	if (!nodes) {
+		nodes = /* @__PURE__ */ new Set();
+		rootPatchNodesMap.set(root, nodes);
+	}
+	return nodes;
+}
+function indexPatchNode(root, node) {
+	getRootPatchNodes(root).add(node);
+}
+function bumpRawVersion(target) {
+	var _rawVersionMap$get;
+	rawVersionMap.set(target, ((_rawVersionMap$get = rawVersionMap.get(target)) !== null && _rawVersionMap$get !== void 0 ? _rawVersionMap$get : 0) + 1);
+}
+function getRawVersion(target) {
+	var _rawVersionMap$get2;
+	return (_rawVersionMap$get2 = rawVersionMap.get(target)) !== null && _rawVersionMap$get2 !== void 0 ? _rawVersionMap$get2 : 0;
+}
+function bumpAncestorVersions(target) {
+	const visited = /* @__PURE__ */ new Set();
+	const stack = [target];
+	for (let i = 0; i < 2e3 && stack.length; i++) {
+		const current = stack.pop();
+		const parents = rawParentsMap.get(current);
+		if (!parents) continue;
+		for (const parent of parents.keys()) {
+			if (visited.has(parent)) continue;
+			visited.add(parent);
+			bumpRawVersion(parent);
+			stack.push(parent);
+		}
+	}
+}
+function refreshPathUniqueness(child) {
+	const parents = rawParentsMap.get(child);
+	if (!parents) {
+		rawMultiParentSet.delete(child);
+		rawParentMap.delete(child);
+		return;
+	}
+	let uniqueParent;
+	let uniqueKey;
+	let total = 0;
+	for (const [parent, keys] of parents) {
+		for (const k of keys) {
+			total += 1;
+			if (total > 1) break;
+			uniqueParent = parent;
+			uniqueKey = k;
+		}
+		if (total > 1) break;
+	}
+	if (total === 1 && uniqueParent && uniqueKey) {
+		rawMultiParentSet.delete(child);
+		rawParentMap.set(child, {
+			parent: uniqueParent,
+			key: uniqueKey
+		});
+		return;
+	}
+	rawMultiParentSet.add(child);
+	rawParentMap.delete(child);
+}
+function recordParentLink(child, parent, key) {
+	if (typeof key !== "string") {
+		rawMultiParentSet.add(child);
+		rawParentMap.delete(child);
+		return;
+	}
+	if (mutationRecorders.size) {
+		var _rawRootMap$get;
+		const root = (_rawRootMap$get = rawRootMap.get(parent)) !== null && _rawRootMap$get !== void 0 ? _rawRootMap$get : parent;
+		indexPatchNode(root, parent);
+		indexPatchNode(root, child);
+	}
+	let parents = rawParentsMap.get(child);
+	if (!parents) {
+		parents = /* @__PURE__ */ new Map();
+		rawParentsMap.set(child, parents);
+	}
+	let keys = parents.get(parent);
+	if (!keys) {
+		keys = /* @__PURE__ */ new Set();
+		parents.set(parent, keys);
+	}
+	keys.add(key);
+	refreshPathUniqueness(child);
+}
+function removeParentLink(child, parent, key) {
+	const parents = rawParentsMap.get(child);
+	if (!parents) return;
+	const keys = parents.get(parent);
+	if (!keys) return;
+	keys.delete(key);
+	if (!keys.size) parents.delete(parent);
+	if (!parents.size) rawParentsMap.delete(child);
+	refreshPathUniqueness(child);
+}
+function resolvePathToTarget(root, target) {
+	if (target === root) return [];
+	if (rawMultiParentSet.has(target)) return;
+	const segments = [];
+	let current = target;
+	for (let i = 0; i < 2e3; i++) {
+		if (current === root) return segments.reverse();
+		if (rawMultiParentSet.has(current)) return;
+		const info = rawParentMap.get(current);
+		if (!info) return;
+		if (typeof info.key !== "string") return;
+		segments.push(info.key);
+		current = info.parent;
+	}
+}
+//#endregion
+//#region src/reactivity/reactive/shared.ts
+let ReactiveFlags = /* @__PURE__ */ function(ReactiveFlags) {
+	ReactiveFlags["IS_REACTIVE"] = "__r_isReactive";
+	ReactiveFlags["RAW"] = "__r_raw";
+	ReactiveFlags["SKIP"] = "__r_skip";
+	return ReactiveFlags;
+}({});
+function isObject(value) {
+	return typeof value === "object" && value !== null;
+}
+const VERSION_KEY = Symbol("wevu.version");
+function isArrayIndexKey(key) {
+	if (!key) return false;
+	const code0 = key.charCodeAt(0);
+	if (code0 < 48 || code0 > 57) return false;
+	const n = Number(key);
+	return Number.isInteger(n) && n >= 0 && String(n) === key;
+}
+function toRaw(observed) {
+	var _ReactiveFlags$RAW;
+	return (_ReactiveFlags$RAW = observed === null || observed === void 0 ? void 0 : observed[ReactiveFlags.RAW]) !== null && _ReactiveFlags$RAW !== void 0 ? _ReactiveFlags$RAW : observed;
+}
+//#endregion
+//#region src/reactivity/reactive/state.ts
+const reactiveMap = /* @__PURE__ */ new WeakMap();
+const rawMap = /* @__PURE__ */ new WeakMap();
+const shallowReactiveMap = /* @__PURE__ */ new WeakMap();
+//#endregion
+//#region src/reactivity/reactive/patch.ts
+/**
+* 预链接响应式树结构，供运行时差量路径追踪使用。
+* @internal
+*/
+function prelinkReactiveTree(root, options) {
+	const rootRaw = toRaw(root);
+	rawPathMap.set(rootRaw, "");
+	indexPatchNode(rootRaw, rootRaw);
+	const shouldIncludeTopKey = options === null || options === void 0 ? void 0 : options.shouldIncludeTopKey;
+	const maxDepth = typeof (options === null || options === void 0 ? void 0 : options.maxDepth) === "number" ? Math.max(0, Math.floor(options.maxDepth)) : Number.POSITIVE_INFINITY;
+	const maxKeys = typeof (options === null || options === void 0 ? void 0 : options.maxKeys) === "number" ? Math.max(0, Math.floor(options.maxKeys)) : Number.POSITIVE_INFINITY;
+	const visited = /* @__PURE__ */ new WeakSet();
+	const stack = [{
+		current: rootRaw,
+		path: "",
+		depth: 0
+	}];
+	let indexed = 0;
+	while (stack.length) {
+		const node = stack.pop();
+		if (visited.has(node.current)) continue;
+		visited.add(node.current);
+		rawPathMap.set(node.current, node.path);
+		indexPatchNode(rootRaw, node.current);
+		indexed += 1;
+		if (indexed >= maxKeys) continue;
+		if (node.depth >= maxDepth) continue;
+		if (Array.isArray(node.current)) continue;
+		const entries = Object.entries(node.current);
+		for (const [key, value] of entries) {
+			if (node.path === "" && shouldIncludeTopKey && !shouldIncludeTopKey(key)) continue;
+			if (!isObject(value)) continue;
+			if (value[ReactiveFlags.SKIP]) continue;
+			const childRaw = toRaw(value);
+			if (!rawRootMap.has(childRaw)) rawRootMap.set(childRaw, rootRaw);
+			recordParentLink(childRaw, node.current, key);
+			if (!rawMultiParentSet.has(childRaw)) {
+				const childPath = node.path ? `${node.path}.${key}` : key;
+				rawPathMap.set(childRaw, childPath);
+			}
+			indexPatchNode(rootRaw, childRaw);
+			stack.push({
+				current: childRaw,
+				path: node.path ? `${node.path}.${key}` : key,
+				depth: node.depth + 1
+			});
+		}
+	}
+}
+/**
+* 清理预链接阶段建立的路径与父子索引。
+* @internal
+*/
+function clearPatchIndices(root) {
+	const rootRaw = toRaw(root);
+	const nodes = rootPatchNodesMap.get(rootRaw);
+	if (!nodes) {
+		rawPathMap.delete(rootRaw);
+		return;
+	}
+	for (const node of nodes) {
+		rawParentMap.delete(node);
+		rawParentsMap.delete(node);
+		rawPathMap.delete(node);
+		rawMultiParentSet.delete(node);
+		rawRootMap.delete(node);
+		rawVersionMap.delete(node);
+	}
+	rootPatchNodesMap.delete(rootRaw);
+}
+/**
+* 让 effect 订阅整个对象的“版本号”，无需深度遍历即可对任何字段变化做出响应。
+* @internal
+*/
+function touchReactive(target) {
+	track(toRaw(target), VERSION_KEY);
+}
+//#endregion
+//#region src/reactivity/reactive/shallow.ts
+const shallowHandlers = {
+	get(target, key, receiver) {
+		if (key === ReactiveFlags.IS_REACTIVE) return true;
+		if (key === ReactiveFlags.RAW) return target;
+		const res = Reflect.get(target, key, receiver);
+		track(target, key);
+		return res;
+	},
+	set(target, key, value, receiver) {
+		const oldValue = Reflect.get(target, key, receiver);
+		const result = Reflect.set(target, key, value, receiver);
+		if (!Object.is(oldValue, value)) {
+			trigger(target, key);
+			trigger(target, VERSION_KEY);
+			bumpRawVersion(target);
+		}
+		return result;
+	},
+	deleteProperty(target, key) {
+		const hadKey = Object.prototype.hasOwnProperty.call(target, key);
+		const result = Reflect.deleteProperty(target, key);
+		if (hadKey && result) {
+			trigger(target, key);
+			trigger(target, VERSION_KEY);
+			bumpRawVersion(target);
+		}
+		return result;
+	},
+	ownKeys(target) {
+		track(target, Symbol.iterator);
+		track(target, VERSION_KEY);
+		return Reflect.ownKeys(target);
+	}
+};
+/**
+* 创建一个浅层响应式代理：仅跟踪第一层属性变更，不深度递归嵌套对象。
+*
+* @param target 待转换的对象
+* @returns 浅层响应式代理
+*
+* @example
+* ```ts
+* const state = shallowReactive({ nested: { count: 0 } })
+*
+* state.nested.count++ // 不会触发 effect（嵌套对象未深度代理）
+* state.nested = { count: 1 } // 会触发 effect（顶层属性变更）
+* ```
+*/
+function shallowReactive(target) {
+	if (!isObject(target)) return target;
+	const existingProxy = shallowReactiveMap.get(target);
+	if (existingProxy) return existingProxy;
+	if (target[ReactiveFlags.IS_REACTIVE]) return target;
+	const proxy = new Proxy(target, shallowHandlers);
+	shallowReactiveMap.set(target, proxy);
+	rawMap.set(proxy, target);
+	if (!rawVersionMap.has(target)) rawVersionMap.set(target, 0);
+	return proxy;
+}
+/**
+* 判断一个值是否为 shallowReactive 创建的浅层响应式对象
+*/
+function isShallowReactive(value) {
+	const raw = toRaw(value);
+	return shallowReactiveMap.has(raw);
+}
+//#endregion
+//#region src/reactivity/reactive.ts
+/**
+* 读取响应式版本号（框架内部调试能力）。
+* @internal
+*/
+function getReactiveVersion(target) {
+	return getRawVersion(toRaw(target));
+}
+function emitMutation(target, key, op) {
+	var _rawRootMap$get;
+	if (!mutationRecorders.size) return;
+	if (typeof key !== "string") return;
+	if (key.startsWith("__r_")) return;
+	const root = (_rawRootMap$get = rawRootMap.get(target)) !== null && _rawRootMap$get !== void 0 ? _rawRootMap$get : target;
+	const kind = Array.isArray(target) && (key === "length" || isArrayIndexKey(key)) ? "array" : "property";
+	const baseSegments = resolvePathToTarget(root, target);
+	if (!baseSegments) {
+		const fallback = /* @__PURE__ */ new Set();
+		const parents = rawParentsMap.get(target);
+		if (parents) for (const [parent, keys] of parents) {
+			var _resolvePathToTarget;
+			const parentPath = rawPathMap.get(parent);
+			const topFromParentPath = parentPath ? parentPath.split(".", 1)[0] : void 0;
+			const topFromResolve = !topFromParentPath ? (_resolvePathToTarget = resolvePathToTarget(root, parent)) === null || _resolvePathToTarget === void 0 ? void 0 : _resolvePathToTarget[0] : void 0;
+			for (const k of keys) {
+				var _ref;
+				if (typeof k !== "string") continue;
+				fallback.add((_ref = topFromParentPath !== null && topFromParentPath !== void 0 ? topFromParentPath : topFromResolve) !== null && _ref !== void 0 ? _ref : k);
+			}
+		}
+		else fallback.add(key);
+		for (const recorder of mutationRecorders) recorder({
+			root,
+			kind,
+			op,
+			path: void 0,
+			fallbackTopKeys: fallback.size ? Array.from(fallback) : void 0
+		});
+		return;
+	}
+	const arrayIndexPos = baseSegments.findIndex((seg) => isArrayIndexKey(seg));
+	if (arrayIndexPos !== -1) {
+		const path = baseSegments.slice(0, arrayIndexPos).join(".") || void 0;
+		for (const recorder of mutationRecorders) recorder({
+			root,
+			kind: "array",
+			op,
+			path
+		});
+		return;
+	}
+	const basePath = baseSegments.length ? baseSegments.join(".") : "";
+	const path = kind === "array" ? basePath || void 0 : basePath ? `${basePath}.${key}` : key;
+	for (const recorder of mutationRecorders) recorder({
+		root,
+		kind,
+		op,
+		path
+	});
+}
+const mutableHandlers = {
+	get(target, key, receiver) {
+		if (key === ReactiveFlags.IS_REACTIVE) return true;
+		if (key === ReactiveFlags.RAW) return target;
+		const res = Reflect.get(target, key, receiver);
+		track(target, key);
+		if (isObject(res)) {
+			var _rawRootMap$get2, _ReactiveFlags$RAW;
+			if (res[ReactiveFlags.SKIP]) return res;
+			const parentRoot = (_rawRootMap$get2 = rawRootMap.get(target)) !== null && _rawRootMap$get2 !== void 0 ? _rawRootMap$get2 : target;
+			const childRaw = (_ReactiveFlags$RAW = res === null || res === void 0 ? void 0 : res[ReactiveFlags.RAW]) !== null && _ReactiveFlags$RAW !== void 0 ? _ReactiveFlags$RAW : res;
+			if (!rawRootMap.has(childRaw)) rawRootMap.set(childRaw, parentRoot);
+			recordParentLink(childRaw, target, key);
+			const parentPath = rawPathMap.get(target);
+			if (mutationRecorders.size && typeof key === "string" && parentPath != null && !rawMultiParentSet.has(childRaw)) {
+				const nextPath = parentPath ? `${parentPath}.${key}` : key;
+				rawPathMap.set(childRaw, nextPath);
+			}
+			return reactive(res);
+		}
+		return res;
+	},
+	set(target, key, value, receiver) {
+		const isArr = Array.isArray(target);
+		const oldLength = isArr ? target.length : 0;
+		const oldValue = Reflect.get(target, key, receiver);
+		const result = Reflect.set(target, key, value, receiver);
+		if (!Object.is(oldValue, value)) {
+			var _ReactiveFlags$RAW2;
+			const oldRaw = isObject(oldValue) ? (_ReactiveFlags$RAW2 = oldValue === null || oldValue === void 0 ? void 0 : oldValue[ReactiveFlags.RAW]) !== null && _ReactiveFlags$RAW2 !== void 0 ? _ReactiveFlags$RAW2 : oldValue : void 0;
+			if (oldRaw) removeParentLink(oldRaw, target, key);
+			if (isObject(value) && !value[ReactiveFlags.SKIP]) {
+				var _rawRootMap$get3, _ReactiveFlags$RAW3;
+				const root = (_rawRootMap$get3 = rawRootMap.get(target)) !== null && _rawRootMap$get3 !== void 0 ? _rawRootMap$get3 : target;
+				const childRaw = (_ReactiveFlags$RAW3 = value === null || value === void 0 ? void 0 : value[ReactiveFlags.RAW]) !== null && _ReactiveFlags$RAW3 !== void 0 ? _ReactiveFlags$RAW3 : value;
+				if (!rawRootMap.has(childRaw)) rawRootMap.set(childRaw, root);
+				recordParentLink(childRaw, target, key);
+				const parentPath = rawPathMap.get(target);
+				if (mutationRecorders.size && typeof key === "string" && parentPath != null && !rawMultiParentSet.has(childRaw)) {
+					const nextPath = parentPath ? `${parentPath}.${key}` : key;
+					rawPathMap.set(childRaw, nextPath);
+				}
+			}
+			trigger(target, key);
+			if (isArr && typeof key === "string" && isArrayIndexKey(key) && Number(key) >= oldLength) trigger(target, "length");
+			trigger(target, VERSION_KEY);
+			bumpRawVersion(target);
+			bumpAncestorVersions(target);
+			const root = rawRootMap.get(target);
+			if (root && root !== target) {
+				trigger(root, VERSION_KEY);
+				bumpRawVersion(root);
+			}
+			emitMutation(target, key, "set");
+		}
+		return result;
+	},
+	deleteProperty(target, key) {
+		const hadKey = Object.prototype.hasOwnProperty.call(target, key);
+		const oldValue = hadKey ? target[key] : void 0;
+		const result = Reflect.deleteProperty(target, key);
+		if (hadKey && result) {
+			var _ReactiveFlags$RAW4;
+			const oldRaw = isObject(oldValue) ? (_ReactiveFlags$RAW4 = oldValue === null || oldValue === void 0 ? void 0 : oldValue[ReactiveFlags.RAW]) !== null && _ReactiveFlags$RAW4 !== void 0 ? _ReactiveFlags$RAW4 : oldValue : void 0;
+			if (oldRaw) removeParentLink(oldRaw, target, key);
+			trigger(target, key);
+			trigger(target, VERSION_KEY);
+			bumpRawVersion(target);
+			bumpAncestorVersions(target);
+			const root = rawRootMap.get(target);
+			if (root && root !== target) {
+				trigger(root, VERSION_KEY);
+				bumpRawVersion(root);
+			}
+			emitMutation(target, key, "delete");
+		}
+		return result;
+	},
+	ownKeys(target) {
+		track(target, Symbol.iterator);
+		track(target, VERSION_KEY);
+		return Reflect.ownKeys(target);
+	}
+};
+function reactive(target) {
+	if (!isObject(target)) return target;
+	const existingProxy = reactiveMap.get(target);
+	if (existingProxy) return existingProxy;
+	if (target[ReactiveFlags.IS_REACTIVE]) return target;
+	const proxy = new Proxy(target, mutableHandlers);
+	reactiveMap.set(target, proxy);
+	rawMap.set(proxy, target);
+	if (!rawVersionMap.has(target)) rawVersionMap.set(target, 0);
+	if (!rawRootMap.has(target)) rawRootMap.set(target, target);
+	return proxy;
+}
+function isReactive(value) {
+	return Boolean(value && value[ReactiveFlags.IS_REACTIVE]);
+}
+function convertToReactive(value) {
+	return isObject(value) ? reactive(value) : value;
+}
+/**
+* 标记对象为“原始”状态，后续不会被转换为响应式，返回原对象本身。
+*
+* @param value 需要标记的对象
+* @returns 带有跳过标记的原对象
+*
+* @example
+* ```ts
+* const foo = markRaw({
+*   nested: {}
+* })
+*
+* const state = reactive({
+*   foo
+* })
+*
+* state.foo // 不是响应式对象
+* ```
+*/
+function markRaw(value) {
+	if (!isObject(value)) return value;
+	Object.defineProperty(value, ReactiveFlags.SKIP, {
+		value: true,
+		configurable: true,
+		enumerable: false,
+		writable: true
+	});
+	return value;
+}
+/**
+* 判断某个值是否被标记为原始（即不应转换为响应式）。
+*
+* @param value 待检测的值
+* @returns 若含有跳过标记则返回 true
+*/
+function isRaw(value) {
+	return isObject(value) && ReactiveFlags.SKIP in value;
+}
+//#endregion
+//#region src/reactivity/ref.ts
+const RefFlag = "__v_isRef";
+function markAsRef(target) {
+	try {
+		Object.defineProperty(target, RefFlag, {
+			value: true,
+			configurable: true
+		});
+	} catch (_unused) {
+		target[RefFlag] = true;
+	}
+	return target;
+}
+function isRef(value) {
+	return Boolean(value && typeof value === "object" && value["__v_isRef"] === true);
+}
+var RefImpl = class {
+	constructor(value) {
+		_defineProperty(this, "_value", void 0);
+		_defineProperty(this, "_rawValue", void 0);
+		_defineProperty(this, "dep", void 0);
+		markAsRef(this);
+		this._rawValue = value;
+		this._value = convertToReactive(value);
+	}
+	get value() {
+		if (!this.dep) this.dep = /* @__PURE__ */ new Set();
+		trackEffects(this.dep);
+		return this._value;
+	}
+	set value(newValue) {
+		if (!Object.is(newValue, this._rawValue)) {
+			this._rawValue = newValue;
+			this._value = convertToReactive(newValue);
+			if (this.dep) triggerEffects(this.dep);
+		}
+	}
+};
+function ref(value) {
+	if (isRef(value)) return value;
+	return markRaw(new RefImpl(value));
+}
+function unref(value) {
+	return isRef(value) ? value.value : value;
+}
+function toValue(source) {
+	return typeof source === "function" ? source() : unref(source);
+}
+var CustomRefImpl = class {
+	constructor(factory, defaultValue) {
+		_defineProperty(this, "_getValue", void 0);
+		_defineProperty(this, "_setValue", void 0);
+		_defineProperty(this, "dep", void 0);
+		markAsRef(this);
+		const fallbackValue = defaultValue;
+		const track = () => {
+			if (!this.dep) this.dep = /* @__PURE__ */ new Set();
+			trackEffects(this.dep);
+		};
+		const trigger = () => {
+			if (this.dep) triggerEffects(this.dep);
+		};
+		const withFallback = (value) => value === void 0 && fallbackValue !== void 0 ? fallbackValue : value;
+		if (typeof factory === "function") {
+			const handlers = factory(track, trigger);
+			this._getValue = () => withFallback(handlers.get());
+			this._setValue = (value) => handlers.set(value);
+			return;
+		}
+		const handlers = factory;
+		this._getValue = () => {
+			track();
+			return withFallback(handlers.get());
+		};
+		this._setValue = (value) => {
+			handlers.set(value);
+			trigger();
+		};
+	}
+	get value() {
+		return this._getValue();
+	}
+	set value(newValue) {
+		this._setValue(newValue);
+	}
+};
+function customRef(factory, defaultValue) {
+	return markRaw(new CustomRefImpl(factory, defaultValue));
+}
+//#endregion
+export { track as A, effect as C, onScopeDispose as D, getCurrentScope as E, triggerEffects as M, nextTick as N, startBatch as O, queueJob as P, batch as S, endBatch as T, ReactiveFlags as _, toValue as a, addMutationRecorder as b, isRaw as c, reactive as d, isShallowReactive as f, touchReactive as g, prelinkReactiveTree as h, ref as i, trigger as j, stop as k, isReactive as l, clearPatchIndices as m, isRef as n, unref as o, shallowReactive as p, markAsRef as r, getReactiveVersion as s, customRef as t, markRaw as u, isObject as v, effectScope as w, removeMutationRecorder as x, toRaw as y };