@viewfly/core 2.1.0 → 3.0.0-alpha.0

package/dist/index.js

@@ -0,0 +1,2940 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("reflect-metadata");
+//#region src/di/forward-ref.ts
+var ForwardRef = class {
+	constructor(forwardRefFn) {
+		this.forwardRefFn = forwardRefFn;
+	}
+	getRef() {
+		return this.forwardRefFn();
+	}
+};
+/**
+* 引用后声明的类的工具函数
+* @param fn
+*/
+function forwardRef(fn) {
+	return new ForwardRef(fn);
+}
+//#endregion
+//#region src/di/utils/annotations.ts
+/**
+* 用于保存 class 的元数据
+*/
+var Annotations = class {
+	classes = /* @__PURE__ */ new Map();
+	props = /* @__PURE__ */ new Map();
+	params = /* @__PURE__ */ new Map();
+	setClassMetadata(token, params) {
+		this.classes.set(token, params);
+	}
+	getClassMetadata(token) {
+		return this.classes.get(token);
+	}
+	pushParamMetadata(token, params) {
+		if (this.params.has(token)) this.params.get(token).push(params);
+		else this.params.set(token, [params]);
+	}
+	getParamMetadata(token) {
+		return this.params.get(token);
+	}
+	getPropMetadataKeys() {
+		return Array.from(this.props.keys());
+	}
+	pushPropMetadata(token, params) {
+		if (this.props.has(token)) this.props.get(token).push(params);
+		else this.props.set(token, [params]);
+	}
+	getPropMetadata(token) {
+		return this.props.get(token);
+	}
+};
+//#endregion
+//#region src/di/utils/decorators.ts
+/**
+* 创建参数装饰器的工厂函数
+*/
+function makeParamDecorator(token, metadata) {
+	return function(target, propertyKey, parameterIndex) {
+		getAnnotations(target).pushParamMetadata(token, {
+			propertyKey,
+			parameterIndex,
+			metadata
+		});
+	};
+}
+/**
+* 创建属性装饰器的工厂函数
+*/
+function makePropertyDecorator(token, injectToken, contextCallback) {
+	return function(target, propertyKey) {
+		getAnnotations(target.constructor).pushPropMetadata(token, {
+			injectToken: injectToken || Reflect.getMetadata("design:type", target, propertyKey),
+			propertyKey,
+			contextCallback
+		});
+	};
+}
+/**
+* 创建类装饰器的工厂函数
+*/
+function makeClassDecorator(token, metadata) {
+	return function(target) {
+		getAnnotations(target).setClassMetadata(token, {
+			paramTypes: Reflect.getMetadata("design:paramtypes", target),
+			metadata
+		});
+	};
+}
+/**
+* 获取类注解的工具函数
+*/
+function getAnnotations(target) {
+	const key = "__annotations__";
+	if (!target.hasOwnProperty(key)) target[key] = new Annotations();
+	return target[key];
+}
+//#endregion
+//#region src/di/injectable.ts
+var Scope = class {
+	constructor(name) {
+		this.name = name;
+	}
+	toString() {
+		return this.name || "[anonymous provide scope]";
+	}
+};
+/**
+* 可注入类的装饰器
+*/
+var Injectable = function InjectableDecorator(options) {
+	if (this instanceof InjectableDecorator) this.provideIn = options?.provideIn || null;
+	else return makeClassDecorator(Injectable, new Injectable(options));
+};
+//#endregion
+//#region src/di/injection-token.ts
+/**
+* 生成自定义依赖注入 token 的类
+*/
+var InjectionToken = class {
+	constructor(description) {
+		this.description = description;
+	}
+	toString() {
+		return this.description || "[anonymous injection token]";
+	}
+};
+//#endregion
+//#region src/di/injector.ts
+/**
+* 查找规则
+*/
+var InjectFlags = /* @__PURE__ */ function(InjectFlags) {
+	/** 默认查找规则 */
+	InjectFlags["Default"] = "Default";
+	/** 锁定当前容器 */
+	InjectFlags["Self"] = "Self";
+	/** 跳过当前容器 */
+	InjectFlags["SkipSelf"] = "SkipSelf";
+	/** 可选查找 */
+	InjectFlags["Optional"] = "Optional";
+	return InjectFlags;
+}({});
+/**
+* DI 容器抽象基类
+*/
+var Injector = class {};
+//#endregion
+//#region src/di/metadata.ts
+/**
+* 构造函数参数装饰器，用于改变注入 token
+*/
+var Inject = function InjectDecorator(token) {
+	if (this instanceof Inject) this.token = token;
+	else return makeParamDecorator(Inject, new Inject(token));
+};
+var Self = function SelfDecorator() {
+	if (!(this instanceof Self)) return makeParamDecorator(Self, new Self());
+};
+var SkipSelf = function SkipSelfDecorator() {
+	if (!(this instanceof SkipSelf)) return makeParamDecorator(SkipSelf, new SkipSelf());
+};
+var Optional = function OptionalDecorator() {
+	if (!(this instanceof Optional)) return makeParamDecorator(Optional, new Optional());
+};
+var Prop = function PropDecorator(token, notFoundValue, flags) {
+	if (!(this instanceof Prop)) return makePropertyDecorator(Prop, token, function(instance, propertyName, token, injector) {
+		instance[propertyName] = injector.get(token instanceof ForwardRef ? token.getRef() : token, notFoundValue, flags);
+	});
+};
+//#endregion
+//#region src/di/utils/stringify.ts
+function stringify(token) {
+	if (typeof token === "string") return token;
+	if (Array.isArray(token)) return "[" + token.map(stringify).join(", ") + "]";
+	if (token == null) return "" + token;
+	if (token.name) return `${token.name}`;
+	if (token.token) return `${token.token}`;
+	const res = token.toString();
+	if (res == null) return "" + res;
+	const newLineIndex = res.indexOf("\n");
+	return newLineIndex === -1 ? res : res.substring(0, newLineIndex);
+}
+//#endregion
+//#region src/_utils/make-error.ts
+function makeError(name) {
+	return function viewflyError(message) {
+		const error = new Error(message);
+		error.name = `[ViewflyError: ${name}]`;
+		error.stack = error.stack.replace(/\n.*?(?=\n)/, "");
+		return error;
+	};
+}
+//#endregion
+//#region src/di/null-injector.ts
+var THROW_IF_NOT_FOUND = { __debug_value__: "THROW_IF_NOT_FOUND" };
+var nullInjectorErrorFn = (token) => {
+	return makeError("NullInjector")(`No provide for \`${stringify(token)}\`!`);
+};
+var NullInjector = class {
+	parentInjector = null;
+	get(token, notFoundValue = THROW_IF_NOT_FOUND, _) {
+		if (notFoundValue === THROW_IF_NOT_FOUND) throw nullInjectorErrorFn(token);
+		return notFoundValue;
+	}
+};
+//#endregion
+//#region src/di/reflective-provider.ts
+/**
+* 标准化 provide，并返回统一数据结构
+* @param provider
+*/
+function normalizeProvider(provider) {
+	if (provider.useValue) return normalizeValueProviderFactory(provider);
+	if (provider.useClass) return normalizeClassProviderFactory(provider);
+	if (provider.useExisting) return normalizeExistingProviderFactory(provider);
+	if (provider.useFactory) return normalizeFactoryProviderFactory(provider);
+	if (provider.provide) {
+		if (provider.provide instanceof InjectionToken) return normalizeValueProviderFactory(provider);
+		return normalizeConstructorProviderFactory(provider);
+	}
+	return normalizeTypeProviderFactory(provider);
+}
+function normalizeValueProviderFactory(provider) {
+	return {
+		provide: provider.provide,
+		scope: null,
+		generateFactory() {
+			return function() {
+				return provider.useValue;
+			};
+		},
+		deps: []
+	};
+}
+function normalizeClassProviderFactory(provider) {
+	let deps;
+	let provideIn = null;
+	if (provider.deps) deps = normalizeDeps(provider.provide, provider.deps);
+	else {
+		const resolvedClass = resolveClassParams(provider.useClass);
+		provideIn = resolvedClass.scope;
+		deps = normalizeDeps(provider.provide, resolvedClass.deps);
+	}
+	return {
+		provide: provider.provide,
+		scope: provideIn,
+		deps,
+		generateFactory(injector, cacheFn) {
+			return function(...args) {
+				const instance = new provider.useClass(...args);
+				cacheFn(provider.provide, instance);
+				getAnnotations(provider.useClass).getPropMetadataKeys().forEach((key) => {
+					getAnnotations(provider.useClass).getPropMetadata(key).forEach((item) => {
+						item.contextCallback(instance, item.propertyKey, item.injectToken, injector);
+					});
+				});
+				return instance;
+			};
+		}
+	};
+}
+function normalizeExistingProviderFactory(provider) {
+	return {
+		provide: provider.provide,
+		scope: null,
+		generateFactory(injector) {
+			return function() {
+				return injector.get(provider.useExisting);
+			};
+		},
+		deps: []
+	};
+}
+function normalizeFactoryProviderFactory(provider) {
+	return {
+		provide: provider.provide,
+		scope: null,
+		generateFactory() {
+			return function(...args) {
+				return provider.useFactory(...args);
+			};
+		},
+		deps: normalizeDeps(provider.provide, provider.deps || [])
+	};
+}
+function normalizeConstructorProviderFactory(provider) {
+	return normalizeClassProviderFactory({
+		...provider,
+		useClass: provider.provide
+	});
+}
+function normalizeTypeProviderFactory(provider) {
+	return normalizeClassProviderFactory({
+		provide: provider,
+		useClass: provider
+	});
+}
+function resolveClassParams(construct) {
+	const annotations = getAnnotations(construct);
+	const metadata = annotations.getClassMetadata(Injectable);
+	if (typeof metadata === "undefined") throw new Error(`Class \`${stringify(construct)}\` is not injectable!`);
+	const deps = (metadata.paramTypes || []).map((i) => [i]);
+	[
+		Inject,
+		Self,
+		SkipSelf,
+		Optional
+	].forEach((key) => {
+		(annotations.getParamMetadata(key) || []).forEach((item) => {
+			deps[item.parameterIndex].push(item.metadata);
+		});
+	});
+	return {
+		scope: metadata.metadata.provideIn,
+		deps
+	};
+}
+function normalizeDeps(provide, deps) {
+	return deps.map((dep, index) => {
+		const r = {
+			injectKey: null,
+			optional: false,
+			visibility: null
+		};
+		if (!Array.isArray(dep)) r.injectKey = dep;
+		else for (let i = 0; i < dep.length; i++) {
+			const item = dep[i];
+			if (item instanceof Inject) r.injectKey = item.token;
+			else if (item instanceof Self || item instanceof SkipSelf) r.visibility = item;
+			else if (item instanceof Optional) r.optional = true;
+			else r.injectKey = item;
+		}
+		if (typeof r.injectKey === "undefined") throw new Error(`The ${index} th dependent parameter type of \`${stringify(provide)}\` was not obtained, if the dependency is declared later, you can refer to it using \`constructor(@Inject(forwardRef(() => [Type|InjectionToken])) paramName: [Type]) {}\``);
+		return r;
+	});
+}
+//#endregion
+//#region src/di/reflective-injector.ts
+var reflectiveInjectorErrorFn = (token) => {
+	return makeError("ReflectiveInjector")(`No provide for \`${stringify(token)}\`!`);
+};
+var provideScopeError = (token) => {
+	return makeError("ProvideScope")(`Can not found provide scope \`${stringify(token)}\`!`);
+};
+/**
+* 反射注入器
+*/
+var ReflectiveInjector = class {
+	normalizedProviders;
+	recordValues = /* @__PURE__ */ new Map();
+	constructor(parentInjector, staticProviders, scope) {
+		this.parentInjector = parentInjector;
+		this.scope = scope;
+		this.normalizedProviders = staticProviders.map((provide) => {
+			return normalizeProvider(provide);
+		});
+	}
+	/**
+	* 用于获取当前注入器上下文内的实例、对象或数据
+	* @param token 访问 token
+	* @param notFoundValue 如未查找到的返回值
+	* @param flags 查询规则
+	*/
+	get(token, notFoundValue = THROW_IF_NOT_FOUND, flags) {
+		flags = flags || InjectFlags.Default;
+		if (flags === InjectFlags.SkipSelf) {
+			if (this.parentInjector) return this.parentInjector.get(token, notFoundValue);
+			if (notFoundValue !== THROW_IF_NOT_FOUND) return notFoundValue;
+			throw reflectiveInjectorErrorFn(token);
+		}
+		if (this.recordValues.has(token)) return this.recordValues.get(token);
+		for (let i = 0; i < this.normalizedProviders.length; i++) {
+			const normalizedProvider = this.normalizedProviders[i];
+			if (normalizedProvider.provide === token) return this.getValue(token, normalizedProvider);
+		}
+		if (!(token instanceof InjectionToken)) {
+			const scope = getAnnotations(token).getClassMetadata(Injectable)?.metadata.provideIn;
+			if (scope) {
+				const normalizedProvider = normalizeProvider(token);
+				if (this.scope === scope) {
+					this.normalizedProviders.push(normalizedProvider);
+					return this.getValue(token, normalizedProvider);
+				}
+				const parentInjector = this.parentInjector;
+				if (!parentInjector || parentInjector instanceof NullInjector) {
+					if (normalizedProvider.scope === "root") {
+						this.normalizedProviders.push(normalizedProvider);
+						return this.getValue(token, normalizedProvider);
+					}
+					if (notFoundValue !== THROW_IF_NOT_FOUND) return notFoundValue;
+					throw provideScopeError(normalizedProvider.scope);
+				}
+			}
+		}
+		if (flags === InjectFlags.Self) {
+			if (notFoundValue === THROW_IF_NOT_FOUND) throw reflectiveInjectorErrorFn(token);
+			return notFoundValue;
+		}
+		if (this.parentInjector) return this.parentInjector.get(token, notFoundValue, flags === InjectFlags.Optional ? InjectFlags.Optional : InjectFlags.Default);
+		if (notFoundValue === THROW_IF_NOT_FOUND) throw reflectiveInjectorErrorFn(token);
+		return notFoundValue;
+	}
+	getValue(token, normalizedProvider) {
+		const { generateFactory, deps } = normalizedProvider;
+		const params = this.resolveDeps(deps);
+		let value = this.recordValues.get(token);
+		if (value) return value;
+		value = generateFactory(this, (token, value) => {
+			this.recordValues.set(token, value);
+		})(...params);
+		this.recordValues.set(token, value);
+		return value;
+	}
+	/**
+	* 解决并获取依赖参数
+	* @param deps 依赖规则
+	* @private
+	*/
+	resolveDeps(deps) {
+		return deps.map((dep) => {
+			let reflectiveValue;
+			const tryValue = {};
+			const injectToken = dep.injectKey instanceof ForwardRef ? dep.injectKey.getRef() : dep.injectKey;
+			if (dep.visibility instanceof Self) reflectiveValue = this.get(injectToken, tryValue, InjectFlags.Self);
+			else if (dep.visibility instanceof SkipSelf) if (this.parentInjector) reflectiveValue = this.parentInjector.get(injectToken, tryValue);
+			else {
+				if (dep.optional) return null;
+				throw reflectiveInjectorErrorFn(injectToken);
+			}
+			else reflectiveValue = this.get(injectToken, tryValue);
+			if (reflectiveValue === tryValue) {
+				if (dep.optional) return null;
+				throw reflectiveInjectorErrorFn(injectToken);
+			}
+			return reflectiveValue;
+		});
+	}
+};
+//#endregion
+//#region src/di/type.ts
+var Type = Function;
+//#endregion
+//#region src/base/lifecycle.ts
+/**
+* 当组件挂载后调用回调函数
+* @param callback 回调函数
+* @returns 一个函数，用于停止监听
+* @example
+* ```tsx
+* function App() {
+*   onMounted(() => {
+*     console.log('App mounted!')
+*     return () => {
+*       console.log('destroy prev mount!')
+*     }
+*   })
+*   return () => <div>...</div>
+* }
+* ```
+*/
+function onMounted(callback) {
+	const component = getSetupContext();
+	if (!component.mountCallbacks) component.mountCallbacks = [];
+	component.mountCallbacks.push(callback);
+}
+/**
+* 当组件视图更新后调用回调函数
+* @param callback 回调函数
+* @returns 一个函数，用于停止监听
+* @example
+* ```tsx
+* function App() {
+*   onUpdated(() => {
+*     console.log('App updated!')
+*     return () => {
+*       console.log('destroy prev update!')
+*     }
+*   })
+*   return () => <div>...</div>
+* }
+* ```
+*/
+function onUpdated(callback) {
+	const component = getSetupContext();
+	if (!component.updatedCallbacks) component.updatedCallbacks = [];
+	component.updatedCallbacks.push(callback);
+	return () => {
+		const index = component.updatedCallbacks.indexOf(callback);
+		if (index > -1) component.updatedCallbacks.splice(index, 1);
+	};
+}
+/**
+* 当组件销毁后调用回调函数
+* @param callback 回调函数
+* @returns 一个函数，用于停止监听
+* @example
+* ```tsx
+* function App() {
+*   onUnmounted(() => {
+*     console.log('App unmounted!')
+*   })
+*   return () => <div>...</div>
+* }
+* ```
+*/
+function onUnmounted(callback) {
+	const component = getSetupContext();
+	if (!component.unmountedCallbacks) component.unmountedCallbacks = [];
+	component.unmountedCallbacks.push(callback);
+}
+//#endregion
+//#region src/reactive/_help.ts
+var toStr$1 = Object.prototype.toString;
+function getStringType$1(v) {
+	return toStr$1.call(v);
+}
+function isArray$1(v) {
+	return Array.isArray(v);
+}
+var hasOwnProperty$1 = Object.prototype.hasOwnProperty;
+function hasOwn$1(target, key) {
+	return hasOwnProperty$1.call(target, key);
+}
+//#endregion
+//#region src/base/dep.ts
+var Dep = class {
+	destroyCallbacks = [];
+	constructor(effect) {
+		this.effect = effect;
+	}
+	destroy() {
+		this.destroyCallbacks.forEach((callback) => callback());
+		this.destroyCallbacks = [];
+	}
+};
+var deps$1 = [];
+function getDepContext() {
+	return deps$1.at(-1);
+}
+function pushDepContext(dep) {
+	deps$1.push(dep);
+}
+function popDepContext() {
+	deps$1.pop();
+}
+//#endregion
+//#region src/reactive/effect.ts
+var subscribers$1 = /* @__PURE__ */ new WeakMap();
+function getSubscriber$1(target) {
+	let subscriber = subscribers$1.get(target);
+	if (!subscriber) {
+		subscriber = /* @__PURE__ */ new Map();
+		subscribers$1.set(target, subscriber);
+	}
+	return subscriber;
+}
+var TrackOpTypes = /* @__PURE__ */ function(TrackOpTypes) {
+	TrackOpTypes["Get"] = "Get";
+	TrackOpTypes["Has"] = "Has";
+	TrackOpTypes["Iterate"] = "Iterate";
+	return TrackOpTypes;
+}({});
+var TriggerOpTypes = /* @__PURE__ */ function(TriggerOpTypes) {
+	TriggerOpTypes["Set"] = "Set";
+	TriggerOpTypes["Add"] = "Add";
+	TriggerOpTypes["Delete"] = "Delete";
+	TriggerOpTypes["Clear"] = "Clear";
+	return TriggerOpTypes;
+}({});
+var unKnownKey$1 = Symbol("unKnownKey");
+function track(target, type, key = unKnownKey$1) {
+	const dep = getDepContext();
+	if (dep) {
+		const subscriber = getSubscriber$1(target);
+		let record = subscriber.get(type);
+		if (!record) {
+			record = /* @__PURE__ */ new Map();
+			subscriber.set(type, record);
+		}
+		let effects = record.get(key);
+		if (!effects) {
+			effects = new Set([dep]);
+			record.set(key, effects);
+			dep.destroyCallbacks.push(() => {
+				effects.delete(dep);
+			});
+		} else if (!effects.has(dep)) {
+			dep.destroyCallbacks.push(() => {
+				effects.delete(dep);
+			});
+			effects.add(dep);
+		}
+	}
+}
+function runEffect$1(key, record) {
+	if (!record) return;
+	const effects = record.get(key);
+	if (effects) [...effects].forEach((i) => i.effect());
+}
+function trigger(target, type, key = unKnownKey$1) {
+	const subscriber = getSubscriber$1(target);
+	if (subscriber) switch (type) {
+		case TriggerOpTypes.Set:
+			if (isArray$1(target)) runEffect$1(unKnownKey$1, subscriber.get(TrackOpTypes.Iterate));
+			runEffect$1(key, subscriber.get(TrackOpTypes.Get));
+			runEffect$1(key, subscriber.get(TrackOpTypes.Has));
+			break;
+		case TriggerOpTypes.Add:
+		case TriggerOpTypes.Clear:
+		case TriggerOpTypes.Delete:
+			runEffect$1(unKnownKey$1, subscriber.get(TrackOpTypes.Iterate));
+			runEffect$1(key, subscriber.get(TrackOpTypes.Has));
+			runEffect$1(key, subscriber.get(TrackOpTypes.Get));
+			break;
+	}
+}
+//#endregion
+//#region src/reactive/iterable-iterator.ts
+function createIterableIterator$1(wrapper) {
+	return {
+		*entries() {
+			const target = toRaw(this);
+			track(target, TrackOpTypes.Iterate);
+			for (const [key, value] of target.entries()) yield [wrapper(key), wrapper(value)];
+		},
+		*keys() {
+			const target = toRaw(this);
+			track(target, TrackOpTypes.Iterate);
+			for (const item of target.keys()) yield wrapper(item);
+		},
+		*values() {
+			const target = toRaw(this);
+			track(target, TrackOpTypes.Iterate);
+			for (const item of target.values()) yield wrapper(item);
+		}
+	};
+}
+//#endregion
+//#region src/reactive/array-handlers.ts
+function applyPredicateMethod$1(self, methodName, predicate, wrapper, thisArg) {
+	const target = toRaw(self);
+	track(target, TrackOpTypes.Iterate);
+	return target[methodName]((value, index, array) => {
+		return predicate.call(target, wrapper(value), index, array);
+	}, thisArg);
+}
+function applySearchMethod$1(self, methodName, args) {
+	const target = toRaw(self);
+	track(target, TrackOpTypes.Iterate);
+	return target[methodName](...args.map(toRaw));
+}
+function createArrayHandlers$1(wrapper) {
+	return {
+		concat(...items) {
+			const target = toRaw(this);
+			trigger(target, TriggerOpTypes.Add);
+			return target.concat(...items);
+		},
+		every(predicate, thisArg) {
+			return applyPredicateMethod$1(this, "every", predicate, wrapper, thisArg);
+		},
+		filter(predicate, thisArg) {
+			return applyPredicateMethod$1(this, "filter", predicate, wrapper, thisArg);
+		},
+		find(predicate, thisArg) {
+			return applyPredicateMethod$1(this, "find", predicate, wrapper, thisArg);
+		},
+		findIndex(predicate, thisArg) {
+			return applyPredicateMethod$1(this, "findIndex", predicate, wrapper, thisArg);
+		},
+		findLast(predicate, thisArg) {
+			return applyPredicateMethod$1(this, "findLast", predicate, wrapper, thisArg);
+		},
+		findLastIndex(predicate, thisArg) {
+			return applyPredicateMethod$1(this, "findLastIndex", predicate, wrapper, thisArg);
+		},
+		forEach(callbackfn, thisArg) {
+			return applyPredicateMethod$1(this, "forEach", callbackfn, wrapper, thisArg);
+		},
+		includes(...args) {
+			return applySearchMethod$1(this, "includes", args);
+		},
+		indexOf(...args) {
+			return applySearchMethod$1(this, "indexOf", args);
+		},
+		join(separator) {
+			const target = toRaw(this);
+			track(target, TrackOpTypes.Iterate);
+			return target.join(separator);
+		},
+		lastIndexOf(...args) {
+			return applySearchMethod$1(this, "lastIndexOf", args);
+		},
+		map(callbackFn, thisArg) {
+			return applyPredicateMethod$1(this, "map", callbackFn, wrapper, thisArg);
+		},
+		pop() {
+			const target = toRaw(this);
+			trigger(target, TriggerOpTypes.Delete);
+			return target.pop();
+		},
+		push(...items) {
+			const target = toRaw(this);
+			trigger(target, TriggerOpTypes.Add);
+			return target.push(...items);
+		},
+		reduce(callbackFn, ...args) {
+			const target = toRaw(this);
+			track(target, TrackOpTypes.Iterate);
+			return target.reduce((p, c, i, a) => {
+				if (args.length > 0) return callbackFn(p, wrapper(c), i, a);
+				return callbackFn(wrapper(p), wrapper(c), i, a);
+			}, ...args);
+		},
+		reduceRight(callbackFn, ...args) {
+			const target = toRaw(this);
+			track(target, TrackOpTypes.Iterate);
+			return target.reduceRight((p, c, i, a) => {
+				if (args.length > 0) return callbackFn(p, wrapper(c), i, a);
+				return callbackFn(wrapper(p), wrapper(c), i, a);
+			}, ...args);
+		},
+		shift() {
+			const target = toRaw(this);
+			trigger(target, TriggerOpTypes.Delete);
+			return target.shift();
+		},
+		some(predicate, thisArg) {
+			return applyPredicateMethod$1(this, "some", predicate, wrapper, thisArg);
+		},
+		splice(start, deleteCount) {
+			const target = toRaw(this);
+			trigger(target, TriggerOpTypes.Set);
+			trigger(target, TriggerOpTypes.Add);
+			trigger(target, TriggerOpTypes.Delete);
+			return target.splice(start, deleteCount).map((i) => wrapper(i));
+		},
+		toReversed() {
+			const target = toRaw(this);
+			track(target, TrackOpTypes.Iterate);
+			return target.toReversed();
+		},
+		toSorted(compareFn) {
+			const target = toRaw(this);
+			track(target, TrackOpTypes.Iterate);
+			return target.toSorted(compareFn);
+		},
+		toSpliced(start, deleteCount, ...items) {
+			const target = toRaw(this);
+			track(target, TrackOpTypes.Iterate);
+			return target.toSpliced(start, deleteCount, ...items);
+		},
+		unshift(...items) {
+			const target = toRaw(this);
+			trigger(target, TriggerOpTypes.Add);
+			return target.unshift(...items);
+		},
+		[Symbol.iterator]() {
+			return this.values();
+		},
+		...createIterableIterator$1(wrapper)
+	};
+}
+//#endregion
+//#region src/reactive/map-handlers.ts
+function createMapHandlers$1(wrapper) {
+	return {
+		get(key) {
+			const target = toRaw(this);
+			track(target, TrackOpTypes.Get, key);
+			return wrapper(target.get(key));
+		},
+		set(key, value) {
+			const target = toRaw(this);
+			key = toRaw(key);
+			value = toRaw(value);
+			const has = target.has(key);
+			const r = target.set(key, value);
+			trigger(target, has ? TriggerOpTypes.Set : TriggerOpTypes.Add, key);
+			return r;
+		},
+		has(key) {
+			const target = toRaw(this);
+			key = toRaw(key);
+			track(target, TrackOpTypes.Has, key);
+			return target.has(key);
+		},
+		delete(key) {
+			const target = toRaw(this);
+			key = toRaw(key);
+			const r = target.delete(key);
+			trigger(target, TriggerOpTypes.Delete, key);
+			return r;
+		},
+		forEach(callbackFn, thisArg) {
+			const target = toRaw(this);
+			track(target, TrackOpTypes.Iterate, void 0);
+			target.forEach((v, k, m) => {
+				callbackFn.call(this, wrapper(v), wrapper(k), m);
+			}, thisArg);
+		},
+		clear() {
+			const target = toRaw(this);
+			target.clear();
+			trigger(target, TriggerOpTypes.Clear, void 0);
+		},
+		[Symbol.iterator]() {
+			return this.entries();
+		},
+		...createIterableIterator$1(wrapper)
+	};
+}
+//#endregion
+//#region src/reactive/set-handlers.ts
+function createSetHandlers$1(wrapper) {
+	return {
+		add(value) {
+			const target = toRaw(this);
+			value = toRaw(value);
+			if (!target.has(value)) {
+				target.add(value);
+				trigger(target, TriggerOpTypes.Add, void 0);
+			}
+			return this;
+		},
+		delete(value) {
+			const target = toRaw(this);
+			value = toRaw(value);
+			const has = target.has(value);
+			const b = target.delete(value);
+			if (!has) trigger(target, TriggerOpTypes.Delete, void 0);
+			return b;
+		},
+		has(key) {
+			const target = toRaw(this);
+			key = toRaw(key);
+			track(target, TrackOpTypes.Has, key);
+			return target.has(key);
+		},
+		forEach(callbackFn, thisArg) {
+			const target = toRaw(this);
+			track(target, TrackOpTypes.Iterate, void 0);
+			target.forEach((v, k, m) => {
+				callbackFn.call(this, wrapper(v), wrapper(k), m);
+			}, thisArg);
+		},
+		clear() {
+			const target = toRaw(this);
+			if (target.size !== 0) {
+				target.clear();
+				trigger(target, TriggerOpTypes.Clear, void 0);
+			}
+		},
+		[Symbol.iterator]() {
+			return this.values();
+		},
+		...createIterableIterator$1(wrapper)
+	};
+}
+//#endregion
+//#region src/reactive/reactive.ts
+var reactiveErrorFn$1 = makeError("reactive");
+var rawToProxyCache = /* @__PURE__ */ new WeakMap();
+var proxyToRawCache = /* @__PURE__ */ new WeakMap();
+/**
+* 将响应式对象转换为原始对象
+* @param value 响应式对象
+* @returns 原始对象
+* @example
+* ```tsx
+* const obj = reactive({
+*   name: 'John',
+*   age: 18
+* })
+* console.log(toRaw(obj))
+* ```
+*/
+function toRaw(value) {
+	if (proxyToRawCache.has(value)) return proxyToRawCache.get(value);
+	return value;
+}
+/**
+* 检查对象是否是响应式对象
+* @param value 要检查的对象
+* @returns 是否是响应式对象
+* @example
+* ```tsx
+* const obj = reactive({
+*   name: 'John',
+*   age: 18
+* })
+* console.log(isReactive(obj))
+* ```
+*/
+function isReactive(value) {
+	return proxyToRawCache.has(value);
+}
+var fromInternalWrite$1 = false;
+/**
+* 内部写入，用于避免类型为只读的响应式对象写入报错
+* @param fn 要执行的函数
+* @internal
+*/
+function internalWrite(fn) {
+	fromInternalWrite$1 = true;
+	fn();
+	fromInternalWrite$1 = false;
+}
+var ObjectReactiveHandler = class {
+	isShallow;
+	isReadonly;
+	constructor(config) {
+		this.isReadonly = config.readonly;
+		this.isShallow = config.shallow;
+	}
+	set(target, p, newValue, receiver) {
+		if (this.isReadonly && !fromInternalWrite$1) throw reactiveErrorFn$1("Object is readonly!");
+		const rawValue = toRaw(newValue);
+		const oldValue = target[p];
+		const v = this.isShallow ? newValue : rawValue;
+		if (oldValue === rawValue) return Reflect.set(target, p, v, receiver);
+		const b = Reflect.set(target, p, v, receiver);
+		fromInternalWrite$1 = false;
+		if (hasOwn$1(target, p)) trigger(target, TriggerOpTypes.Set, p);
+		else trigger(target, TriggerOpTypes.Add, p);
+		return b;
+	}
+	get(target, p, receiver) {
+		track(target, TrackOpTypes.Get, p);
+		const value = Reflect.get(target, p, receiver);
+		if (this.isShallow) return value;
+		return reactive(value);
+	}
+	deleteProperty(target, p) {
+		const b = Reflect.deleteProperty(target, p);
+		trigger(target, TriggerOpTypes.Delete, p);
+		return b;
+	}
+	ownKeys(target) {
+		track(target, TrackOpTypes.Iterate);
+		return Reflect.ownKeys(target);
+	}
+};
+function noReactive$1(v) {
+	return v;
+}
+var ArrayReactiveHandler = class extends ObjectReactiveHandler {
+	interceptors = createArrayHandlers$1(this.isShallow ? noReactive$1 : reactive);
+	constructor(config) {
+		super(config);
+	}
+	get(target, p, receiver) {
+		if (Reflect.has(this.interceptors, p) && p in target) return this.interceptors[p];
+		return super.get(target, p, receiver);
+	}
+};
+var MapReactiveHandler = class extends ObjectReactiveHandler {
+	interceptors = createMapHandlers$1(this.isShallow ? noReactive$1 : reactive);
+	constructor(config) {
+		super(config);
+	}
+	get(target, p, receiver) {
+		if (Reflect.has(this.interceptors, p) && p in target) return this.interceptors[p];
+		if (p === "size") {
+			track(target, TrackOpTypes.Iterate, p);
+			return Reflect.get(target, p);
+		}
+		return super.get(target, p, receiver);
+	}
+};
+var SetReactiveHandler = class extends ObjectReactiveHandler {
+	interceptors = createSetHandlers$1(this.isShallow ? noReactive$1 : reactive);
+	constructor(config) {
+		super(config);
+	}
+	get(target, p, receiver) {
+		if (Reflect.has(this.interceptors, p) && p in target) return this.interceptors[p];
+		if (p === "size") {
+			track(target, TrackOpTypes.Iterate, p);
+			return Reflect.get(target, p);
+		}
+		return super.get(target, p, receiver);
+	}
+};
+var defaultObjectReactiveHandler = new ObjectReactiveHandler({
+	readonly: false,
+	shallow: false
+});
+var defaultArrayReactiveHandler = new ArrayReactiveHandler({
+	readonly: false,
+	shallow: false
+});
+var defaultMapReactiveHandler = new MapReactiveHandler({
+	readonly: false,
+	shallow: false
+});
+var defaultSetReactiveHandler = new SetReactiveHandler({
+	readonly: false,
+	shallow: false
+});
+var readonlyProxyHandler = new ObjectReactiveHandler({
+	shallow: true,
+	readonly: true
+});
+function createShallowReadonlyProxy(value) {
+	return new Proxy(value, readonlyProxyHandler);
+}
+/**
+* 创建一个响应式对象
+* @param raw 原始对象
+* @returns 响应式对象
+* @example
+* ```tsx
+* const obj = reactive({
+*   name: 'John',
+*   age: 18,
+*   children: [
+*     {
+*       name: 'Jane',
+*       age: 16
+*     }
+*   ]
+* })
+* console.log(obj.name)
+* console.log(obj.children[0].name)
+* ```
+*/
+function reactive(raw) {
+	if (isReactive(raw)) return raw;
+	let proxy = rawToProxyCache.get(raw);
+	if (proxy) return proxy;
+	switch (getStringType$1(raw)) {
+		case "[object Object]":
+			proxy = new Proxy(raw, defaultObjectReactiveHandler);
+			break;
+		case "[object Array]":
+			proxy = new Proxy(raw, defaultArrayReactiveHandler);
+			break;
+		case "[object Set]":
+		case "[object WeakSet]":
+			proxy = new Proxy(raw, defaultSetReactiveHandler);
+			break;
+		case "[object Map]":
+		case "[object WeakMap]":
+			proxy = new Proxy(raw, defaultMapReactiveHandler);
+			break;
+		default: return raw;
+	}
+	rawToProxyCache.set(raw, proxy);
+	proxyToRawCache.set(proxy, raw);
+	return proxy;
+}
+//#endregion
+//#region src/base/_utils.ts
+function hasChange(newProps, oldProps) {
+	const newKeys = Object.keys(oldProps);
+	const oldKeys = Object.keys(newProps);
+	if (oldKeys.length !== newKeys.length) return true;
+	const len = oldKeys.length;
+	for (let i = 0; i < len; i++) {
+		const key = newKeys[i];
+		if (newProps[key] !== oldProps[key]) return true;
+	}
+	return false;
+}
+function comparePropsWithCallbacks(oldProps, newProps, onDeleted, onAdded, onUpdated) {
+	for (const key in oldProps) if (!(key in newProps)) onDeleted(key, oldProps[key]);
+	for (const key in newProps) if (!(key in oldProps)) onAdded(key, newProps[key]);
+	else if (oldProps[key] !== newProps[key]) onUpdated(key, newProps[key], oldProps[key]);
+}
+function classToString(config) {
+	if (typeof config === "string") return config;
+	if (!config) return "";
+	if (Array.isArray(config)) {
+		const classes = [];
+		for (const i of config) {
+			const v = classToString(i);
+			if (v) classes.push(v);
+		}
+		return classes.join(" ");
+	}
+	if (typeof config === "object") {
+		if (config.toString !== Object.prototype.toString && !config.toString.toString().includes("[native code]")) return config.toString();
+		const classes = [];
+		for (const key in config) if ({}.hasOwnProperty.call(config, key) && config[key]) classes.push(key);
+		return classes.join(" ");
+	}
+	return "";
+}
+function styleToObject(style) {
+	if (typeof style !== "string") return style || {};
+	const obj = {};
+	style.split(";").map((s) => s.split(":")).forEach((v) => {
+		if (!v[0] || !v[1]) return;
+		obj[v[0].trim()] = v[1].trim();
+	});
+	return obj;
+}
+var TextAtomType = Symbol("Text");
+var ElementAtomType = Symbol("Element");
+var ComponentAtomType = Symbol("Component");
+//#endregion
+//#region src/base/ref.ts
+var refErrorFn$1 = makeError("Ref");
+/**
+* 创建一个动态 ref，当 ref 的绑定的元素或组件初始化后，会调用副作用函数，并把元素或组件的实例作为参数传入。
+* @param effect 用于接收实例的副作用函数，该函数还可以返回一个清理副作用的函数，当元素或组件销毁时调用
+* @returns 一个函数，用于清理副作用
+* @example
+* ```tsx
+* function App() {
+*   const ref = createDynamicRef<HTMLDivElement>((node) => {
+*     console.log(node)
+*     return () => {
+*       console.log('destroy')
+*     }
+*   })
+*   return () => {
+*     return <div ref={ref}>test</div>
+*   }
+* }
+* ```
+*/
+function createDynamicRef(effect) {
+	return effect;
+}
+/**
+* 创建一个引用对象，并添加到 JSX 节点上属性上，当组件渲染后，即可通过 .value 获取到绑定节点的实例
+* - 当绑定到虚拟 DOM 元素节点上时，value 为当前节点的 DOM 元素
+* - 当绑定到组件节点上时，value 为组件函数返回的对象
+* @example
+* ```tsx
+* function App() {
+*   const ref = createRef<HTMLDivElement>()
+*   onMounted(() => {
+*      console.log(ref.value)
+*   })
+*   return () => {
+*     return <div ref={ref}>...</div>
+*   }
+* }
+* ```
+*/
+function createRef() {
+	return createShallowReadonlyProxy({ value: null });
+}
+function applyRefs(ref, value, refEffects) {
+	if (!ref) return;
+	const refs = toRefs(ref);
+	const length = refs.length;
+	for (let i = 0; i < length; i++) bindRefs(refs[i], value, refEffects);
+}
+function updateRefs(ref, value, refEffects) {
+	if (!ref) {
+		refEffects.forEach((fn, oldRef) => {
+			refEffects.delete(oldRef);
+			if (typeof fn === "function") fn();
+		});
+		return;
+	}
+	const newRefs = toRefs(ref);
+	refEffects.forEach((fn, oldRef) => {
+		if (newRefs.includes(oldRef)) return;
+		refEffects.delete(oldRef);
+		if (typeof fn === "function") fn();
+	});
+	const len = newRefs.length;
+	for (let i = 0; i < len; i++) {
+		const newRef = newRefs[i];
+		if (refEffects.has(newRef)) continue;
+		bindRefs(newRef, value, refEffects);
+	}
+}
+function toRefs(ref) {
+	return Array.isArray(ref) ? ref : [ref];
+}
+function bindRefs(ref, value, refEffects) {
+	const type = typeof ref;
+	if (type === "function") {
+		const fn = ref(value);
+		refEffects.set(ref, fn);
+	} else if (type === "object") {
+		internalWrite(() => {
+			ref.value = value;
+		});
+		refEffects.set(ref, () => {
+			internalWrite(() => {
+				ref.value = null;
+			});
+		});
+	} else throw refErrorFn$1("ref must be a function or `Ref<T>` object!");
+}
+//#endregion
+//#region src/base/component.ts
+var componentSetupStack$1 = [];
+var componentErrorFn$1 = makeError("component");
+function getSetupContext(need = true) {
+	const current = componentSetupStack$1[componentSetupStack$1.length - 1];
+	if (!current && need) throw componentErrorFn$1("cannot be called outside the component!");
+	return current;
+}
+/**
+* Viewfly 组件管理类，用于管理组件的生命周期，上下文等
+*/
+var Component = class {
+	get dirty() {
+		return this._dirty;
+	}
+	get changed() {
+		return this._changed;
+	}
+	constructor(parentComponent, type, props, key) {
+		this.parentComponent = parentComponent;
+		this.type = type;
+		this.props = props;
+		this.key = key;
+		this.instance = null;
+		this.changedSubComponents = /* @__PURE__ */ new Set();
+		this.viewMetadata = null;
+		this.unmountedCallbacks = null;
+		this.mountCallbacks = null;
+		this.updatedCallbacks = null;
+		this.updatedDestroyCallbacks = null;
+		this._dirty = true;
+		this._changed = false;
+		this.isFirstRendering = true;
+		this.rawProps = props;
+		this.props = createShallowReadonlyProxy({ ...props });
+		this.refEffects = /* @__PURE__ */ new Map();
+		this.listener = new Dep(() => {
+			this.markAsDirtied();
+		});
+	}
+	markAsDirtied() {
+		this._dirty = true;
+		this.markAsChanged();
+	}
+	markAsChanged(changedComponent) {
+		if (changedComponent) this.changedSubComponents.add(changedComponent);
+		if (this._changed) return;
+		this._changed = true;
+		if (this.parentComponent) this.parentComponent.markAsChanged(this);
+	}
+	render(update) {
+		componentSetupStack$1.push(this);
+		const render = this.type(this.props);
+		const isRenderFn = typeof render === "function";
+		this.instance = isRenderFn ? { $render: render } : render;
+		onMounted(() => {
+			applyRefs(this.props.ref, this.instance, this.refEffects);
+			return () => {
+				this.refEffects.forEach((fn) => {
+					if (typeof fn === "function") fn();
+				});
+			};
+		});
+		componentSetupStack$1.pop();
+		pushDepContext(this.listener);
+		const template = this.instance.$render();
+		popDepContext();
+		update(template, this.instance.$portalHost);
+		this.rendered();
+	}
+	updateProps(newProps) {
+		const oldProps = this.rawProps;
+		this.rawProps = newProps;
+		const newRefs = newProps.ref;
+		comparePropsWithCallbacks(oldProps, newProps, (key) => {
+			internalWrite(() => {
+				Reflect.deleteProperty(oldProps, key);
+			});
+		}, (key, value) => {
+			internalWrite(() => {
+				this.props[key] = value;
+			});
+		}, (key, value) => {
+			internalWrite(() => {
+				this.props[key] = value;
+			});
+		});
+		updateRefs(newRefs, this.instance, this.refEffects);
+	}
+	rerender() {
+		this.listener.destroy();
+		pushDepContext(this.listener);
+		const template = this.instance.$render();
+		popDepContext();
+		return template;
+	}
+	destroy() {
+		this.listener.destroy();
+		if (this.updatedDestroyCallbacks) this.updatedDestroyCallbacks.forEach((fn) => {
+			fn();
+		});
+		if (this.unmountedCallbacks) this.unmountedCallbacks.forEach((fn) => {
+			fn();
+		});
+		this.parentComponent = this.updatedDestroyCallbacks = this.mountCallbacks = this.updatedCallbacks = this.unmountedCallbacks = null;
+	}
+	rendered() {
+		this.changedSubComponents.clear();
+		const is = this.isFirstRendering;
+		this.isFirstRendering = false;
+		this._dirty = this._changed = false;
+		this.invokeUpdatedHooks();
+		if (is) this.invokeMountHooks();
+		if (this.changed) Promise.resolve().then(() => {
+			if (this.parentComponent) this.parentComponent.markAsChanged(this);
+		});
+	}
+	invokeMountHooks() {
+		const unmountedCallbacks = [];
+		if (this.mountCallbacks) {
+			const len = this.mountCallbacks.length;
+			for (let i = 0; i < len; ++i) {
+				const fn = this.mountCallbacks[i];
+				const destroyFn = fn();
+				if (typeof destroyFn === "function") unmountedCallbacks.push(destroyFn);
+			}
+		}
+		if (unmountedCallbacks.length) if (this.unmountedCallbacks) this.unmountedCallbacks.push(...unmountedCallbacks);
+		else this.unmountedCallbacks = unmountedCallbacks;
+		this.mountCallbacks = null;
+	}
+	invokeUpdatedHooks() {
+		if (this.updatedCallbacks) {
+			if (this.updatedDestroyCallbacks) this.updatedDestroyCallbacks.forEach((fn) => {
+				fn();
+			});
+			const updatedDestroyCallbacks = [];
+			const len = this.updatedCallbacks.length;
+			for (let i = 0; i < len; ++i) {
+				const fn = this.updatedCallbacks[i];
+				const destroyFn = fn();
+				if (typeof destroyFn === "function") updatedDestroyCallbacks.push(destroyFn);
+			}
+			this.updatedDestroyCallbacks = updatedDestroyCallbacks.length ? updatedDestroyCallbacks : null;
+		}
+	}
+};
+/**
+* 获取当前组件实例
+* @returns 当前组件实例
+* @example
+* ```tsx
+* function App() {
+*   const instance = getCurrentInstance()
+*   console.log(instance)
+*   return () => <div>...</div>
+* }
+* ```
+*/
+function getCurrentInstance() {
+	return getSetupContext();
+}
+/**
+* 注册组件销毁回调函数
+* @param fn 要注册的回调函数
+* @internal
+*/
+function registryComponentDestroyCallback(fn) {
+	const component = getSetupContext(false);
+	if (component) {
+		if (!component.unmountedCallbacks) component.unmountedCallbacks = [];
+		component.unmountedCallbacks.push(fn);
+	}
+}
+//#endregion
+//#region src/base/jsx-element.ts
+function Fragment(props) {
+	return () => {
+		return props.children;
+	};
+}
+function jsx(type, props, key) {
+	return JSXNodeFactory.createNode(type, props, key);
+}
+var jsxs = jsx;
+var JSXNodeFactory = { createNode(type, props, key) {
+	return {
+		type,
+		props,
+		key
+	};
+} };
+/**
+* 给组件的视图元素节点添加自定义属性标记
+* @param marks
+* @param setup
+* @example
+* ```tsx
+* const App = withMark('mark', function(props) {
+*   return () => {
+*     return <div>...</div>
+*   }
+* })
+* ```
+*/
+function withMark(marks, setup) {
+	if (!marks) return setup;
+	return function(props) {
+		const componentRenderFn = setup(props);
+		if (typeof componentRenderFn === "function") return function() {
+			return applyMark(marks, componentRenderFn);
+		};
+		const oldRender = componentRenderFn.$render;
+		componentRenderFn.$render = function() {
+			return applyMark(marks, () => {
+				return oldRender.call(componentRenderFn);
+			});
+		};
+		return componentRenderFn;
+	};
+}
+/**
+* 内部使用
+* @internal
+* @param mark
+* @param render
+*/
+function applyMark(mark, render) {
+	const oldCreateNote = JSXNodeFactory.createNode;
+	const spaces = Array.isArray(mark) ? mark : [mark];
+	JSXNodeFactory.createNode = function(name, props, key) {
+		for (const scopedId of spaces) props[scopedId] = "";
+		return oldCreateNote.apply(JSXNodeFactory, [
+			name,
+			props,
+			key
+		]);
+	};
+	const vDom = render();
+	JSXNodeFactory.createNode = oldCreateNote;
+	return vDom;
+}
+/**
+* 将子节点渲染到指定节点
+* @param props
+* @example
+* ```tsx
+* function App() {
+*   const modal = document.getElementById('modal')!
+*   return () => {
+*     return (
+*       <div>
+*         <Portal host={modal}>
+*           这里的内容将渲染到 modal 节点
+*         </Portal>
+*       </div>
+*     )
+*   }
+* }
+* ```
+*/
+function Portal(props) {
+	return {
+		$portalHost: props.host,
+		$render() {
+			return props.children;
+		}
+	};
+}
+//#endregion
+//#region dist/index.esm.js
+function makeError$1(name) {
+	return function viewflyError(message) {
+		const error = new Error(message);
+		error.name = `[ViewflyError: ${name}]`;
+		error.stack = error.stack.replace(/\n.*?(?=\n)/, "");
+		return error;
+	};
+}
+var toStr = Object.prototype.toString;
+function getStringType(v) {
+	return toStr.call(v);
+}
+function isArray(v) {
+	return Array.isArray(v);
+}
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwn(target, key) {
+	return hasOwnProperty.call(target, key);
+}
+var Dep$1 = class {
+	destroyCallbacks = [];
+	constructor(effect) {
+		this.effect = effect;
+	}
+	destroy() {
+		this.destroyCallbacks.forEach((callback) => callback());
+		this.destroyCallbacks = [];
+	}
+};
+var deps = [];
+function getDepContext$1() {
+	return deps.at(-1);
+}
+function pushDepContext$1(dep) {
+	deps.push(dep);
+}
+function popDepContext$1() {
+	deps.pop();
+}
+var subscribers = /* @__PURE__ */ new WeakMap();
+function getSubscriber(target) {
+	let subscriber = subscribers.get(target);
+	if (!subscriber) {
+		subscriber = /* @__PURE__ */ new Map();
+		subscribers.set(target, subscriber);
+	}
+	return subscriber;
+}
+var TrackOpTypes$1 = /* @__PURE__ */ function(TrackOpTypes) {
+	TrackOpTypes["Get"] = "Get";
+	TrackOpTypes["Has"] = "Has";
+	TrackOpTypes["Iterate"] = "Iterate";
+	return TrackOpTypes;
+}({});
+var TriggerOpTypes$1 = /* @__PURE__ */ function(TriggerOpTypes) {
+	TriggerOpTypes["Set"] = "Set";
+	TriggerOpTypes["Add"] = "Add";
+	TriggerOpTypes["Delete"] = "Delete";
+	TriggerOpTypes["Clear"] = "Clear";
+	return TriggerOpTypes;
+}({});
+var unKnownKey = Symbol("unKnownKey");
+function track$1(target, type, key = unKnownKey) {
+	const dep = getDepContext$1();
+	if (dep) {
+		const subscriber = getSubscriber(target);
+		let record = subscriber.get(type);
+		if (!record) {
+			record = /* @__PURE__ */ new Map();
+			subscriber.set(type, record);
+		}
+		let effects = record.get(key);
+		if (!effects) {
+			effects = new Set([dep]);
+			record.set(key, effects);
+			dep.destroyCallbacks.push(() => {
+				effects.delete(dep);
+			});
+		} else if (!effects.has(dep)) {
+			dep.destroyCallbacks.push(() => {
+				effects.delete(dep);
+			});
+			effects.add(dep);
+		}
+	}
+}
+function runEffect(key, record) {
+	if (!record) return;
+	const effects = record.get(key);
+	if (effects) [...effects].forEach((i) => i.effect());
+}
+function trigger$1(target, type, key = unKnownKey) {
+	const subscriber = getSubscriber(target);
+	if (subscriber) switch (type) {
+		case TriggerOpTypes$1.Set:
+			if (isArray(target)) runEffect(unKnownKey, subscriber.get(TrackOpTypes$1.Iterate));
+			runEffect(key, subscriber.get(TrackOpTypes$1.Get));
+			runEffect(key, subscriber.get(TrackOpTypes$1.Has));
+			break;
+		case TriggerOpTypes$1.Add:
+		case TriggerOpTypes$1.Clear:
+		case TriggerOpTypes$1.Delete:
+			runEffect(unKnownKey, subscriber.get(TrackOpTypes$1.Iterate));
+			runEffect(key, subscriber.get(TrackOpTypes$1.Has));
+			runEffect(key, subscriber.get(TrackOpTypes$1.Get));
+			break;
+	}
+}
+function createIterableIterator(wrapper) {
+	return {
+		*entries() {
+			const target = toRaw$1(this);
+			track$1(target, TrackOpTypes$1.Iterate);
+			for (const [key, value] of target.entries()) yield [wrapper(key), wrapper(value)];
+		},
+		*keys() {
+			const target = toRaw$1(this);
+			track$1(target, TrackOpTypes$1.Iterate);
+			for (const item of target.keys()) yield wrapper(item);
+		},
+		*values() {
+			const target = toRaw$1(this);
+			track$1(target, TrackOpTypes$1.Iterate);
+			for (const item of target.values()) yield wrapper(item);
+		}
+	};
+}
+function applyPredicateMethod(self, methodName, predicate, wrapper, thisArg) {
+	const target = toRaw$1(self);
+	track$1(target, TrackOpTypes$1.Iterate);
+	return target[methodName]((value, index, array) => {
+		return predicate.call(target, wrapper(value), index, array);
+	}, thisArg);
+}
+function applySearchMethod(self, methodName, args) {
+	const target = toRaw$1(self);
+	track$1(target, TrackOpTypes$1.Iterate);
+	return target[methodName](...args.map(toRaw$1));
+}
+function createArrayHandlers(wrapper) {
+	return {
+		concat(...items) {
+			const target = toRaw$1(this);
+			trigger$1(target, TriggerOpTypes$1.Add);
+			return target.concat(...items);
+		},
+		every(predicate, thisArg) {
+			return applyPredicateMethod(this, "every", predicate, wrapper, thisArg);
+		},
+		filter(predicate, thisArg) {
+			return applyPredicateMethod(this, "filter", predicate, wrapper, thisArg);
+		},
+		find(predicate, thisArg) {
+			return applyPredicateMethod(this, "find", predicate, wrapper, thisArg);
+		},
+		findIndex(predicate, thisArg) {
+			return applyPredicateMethod(this, "findIndex", predicate, wrapper, thisArg);
+		},
+		findLast(predicate, thisArg) {
+			return applyPredicateMethod(this, "findLast", predicate, wrapper, thisArg);
+		},
+		findLastIndex(predicate, thisArg) {
+			return applyPredicateMethod(this, "findLastIndex", predicate, wrapper, thisArg);
+		},
+		forEach(callbackfn, thisArg) {
+			return applyPredicateMethod(this, "forEach", callbackfn, wrapper, thisArg);
+		},
+		includes(...args) {
+			return applySearchMethod(this, "includes", args);
+		},
+		indexOf(...args) {
+			return applySearchMethod(this, "indexOf", args);
+		},
+		join(separator) {
+			const target = toRaw$1(this);
+			track$1(target, TrackOpTypes$1.Iterate);
+			return target.join(separator);
+		},
+		lastIndexOf(...args) {
+			return applySearchMethod(this, "lastIndexOf", args);
+		},
+		map(callbackFn, thisArg) {
+			return applyPredicateMethod(this, "map", callbackFn, wrapper, thisArg);
+		},
+		pop() {
+			const target = toRaw$1(this);
+			trigger$1(target, TriggerOpTypes$1.Delete);
+			return target.pop();
+		},
+		push(...items) {
+			const target = toRaw$1(this);
+			trigger$1(target, TriggerOpTypes$1.Add);
+			return target.push(...items);
+		},
+		reduce(callbackFn, ...args) {
+			const target = toRaw$1(this);
+			track$1(target, TrackOpTypes$1.Iterate);
+			return target.reduce((p, c, i, a) => {
+				if (args.length > 0) return callbackFn(p, wrapper(c), i, a);
+				return callbackFn(wrapper(p), wrapper(c), i, a);
+			}, ...args);
+		},
+		reduceRight(callbackFn, ...args) {
+			const target = toRaw$1(this);
+			track$1(target, TrackOpTypes$1.Iterate);
+			return target.reduceRight((p, c, i, a) => {
+				if (args.length > 0) return callbackFn(p, wrapper(c), i, a);
+				return callbackFn(wrapper(p), wrapper(c), i, a);
+			}, ...args);
+		},
+		shift() {
+			const target = toRaw$1(this);
+			trigger$1(target, TriggerOpTypes$1.Delete);
+			return target.shift();
+		},
+		some(predicate, thisArg) {
+			return applyPredicateMethod(this, "some", predicate, wrapper, thisArg);
+		},
+		splice(start, deleteCount) {
+			const target = toRaw$1(this);
+			trigger$1(target, TriggerOpTypes$1.Set);
+			trigger$1(target, TriggerOpTypes$1.Add);
+			trigger$1(target, TriggerOpTypes$1.Delete);
+			return target.splice(start, deleteCount).map((i) => wrapper(i));
+		},
+		toReversed() {
+			const target = toRaw$1(this);
+			track$1(target, TrackOpTypes$1.Iterate);
+			return target.toReversed();
+		},
+		toSorted(compareFn) {
+			const target = toRaw$1(this);
+			track$1(target, TrackOpTypes$1.Iterate);
+			return target.toSorted(compareFn);
+		},
+		toSpliced(start, deleteCount, ...items) {
+			const target = toRaw$1(this);
+			track$1(target, TrackOpTypes$1.Iterate);
+			return target.toSpliced(start, deleteCount, ...items);
+		},
+		unshift(...items) {
+			const target = toRaw$1(this);
+			trigger$1(target, TriggerOpTypes$1.Add);
+			return target.unshift(...items);
+		},
+		[Symbol.iterator]() {
+			return this.values();
+		},
+		...createIterableIterator(wrapper)
+	};
+}
+function createMapHandlers(wrapper) {
+	return {
+		get(key) {
+			const target = toRaw$1(this);
+			track$1(target, TrackOpTypes$1.Get, key);
+			return wrapper(target.get(key));
+		},
+		set(key, value) {
+			const target = toRaw$1(this);
+			key = toRaw$1(key);
+			value = toRaw$1(value);
+			const has = target.has(key);
+			const r = target.set(key, value);
+			trigger$1(target, has ? TriggerOpTypes$1.Set : TriggerOpTypes$1.Add, key);
+			return r;
+		},
+		has(key) {
+			const target = toRaw$1(this);
+			key = toRaw$1(key);
+			track$1(target, TrackOpTypes$1.Has, key);
+			return target.has(key);
+		},
+		delete(key) {
+			const target = toRaw$1(this);
+			key = toRaw$1(key);
+			const r = target.delete(key);
+			trigger$1(target, TriggerOpTypes$1.Delete, key);
+			return r;
+		},
+		forEach(callbackFn, thisArg) {
+			const target = toRaw$1(this);
+			track$1(target, TrackOpTypes$1.Iterate, void 0);
+			target.forEach((v, k, m) => {
+				callbackFn.call(this, wrapper(v), wrapper(k), m);
+			}, thisArg);
+		},
+		clear() {
+			const target = toRaw$1(this);
+			target.clear();
+			trigger$1(target, TriggerOpTypes$1.Clear, void 0);
+		},
+		[Symbol.iterator]() {
+			return this.entries();
+		},
+		...createIterableIterator(wrapper)
+	};
+}
+function createSetHandlers(wrapper) {
+	return {
+		add(value) {
+			const target = toRaw$1(this);
+			value = toRaw$1(value);
+			if (!target.has(value)) {
+				target.add(value);
+				trigger$1(target, TriggerOpTypes$1.Add, void 0);
+			}
+			return this;
+		},
+		delete(value) {
+			const target = toRaw$1(this);
+			value = toRaw$1(value);
+			const has = target.has(value);
+			const b = target.delete(value);
+			if (!has) trigger$1(target, TriggerOpTypes$1.Delete, void 0);
+			return b;
+		},
+		has(key) {
+			const target = toRaw$1(this);
+			key = toRaw$1(key);
+			track$1(target, TrackOpTypes$1.Has, key);
+			return target.has(key);
+		},
+		forEach(callbackFn, thisArg) {
+			const target = toRaw$1(this);
+			track$1(target, TrackOpTypes$1.Iterate, void 0);
+			target.forEach((v, k, m) => {
+				callbackFn.call(this, wrapper(v), wrapper(k), m);
+			}, thisArg);
+		},
+		clear() {
+			const target = toRaw$1(this);
+			if (target.size !== 0) {
+				target.clear();
+				trigger$1(target, TriggerOpTypes$1.Clear, void 0);
+			}
+		},
+		[Symbol.iterator]() {
+			return this.values();
+		},
+		...createIterableIterator(wrapper)
+	};
+}
+var reactiveErrorFn = makeError$1("reactive");
+var rawToProxyCache$1 = /* @__PURE__ */ new WeakMap();
+var proxyToRawCache$1 = /* @__PURE__ */ new WeakMap();
+/**
+* 将响应式对象转换为原始对象
+* @param value 响应式对象
+* @returns 原始对象
+* @example
+* ```tsx
+* const obj = reactive({
+*   name: 'John',
+*   age: 18
+* })
+* console.log(toRaw(obj))
+* ```
+*/
+function toRaw$1(value) {
+	if (proxyToRawCache$1.has(value)) return proxyToRawCache$1.get(value);
+	return value;
+}
+/**
+* 检查对象是否是响应式对象
+* @param value 要检查的对象
+* @returns 是否是响应式对象
+* @example
+* ```tsx
+* const obj = reactive({
+*   name: 'John',
+*   age: 18
+* })
+* console.log(isReactive(obj))
+* ```
+*/
+function isReactive$1(value) {
+	return proxyToRawCache$1.has(value);
+}
+var fromInternalWrite = false;
+var ObjectReactiveHandler$1 = class {
+	isShallow;
+	isReadonly;
+	constructor(config) {
+		this.isReadonly = config.readonly;
+		this.isShallow = config.shallow;
+	}
+	set(target, p, newValue, receiver) {
+		if (this.isReadonly && !fromInternalWrite) throw reactiveErrorFn("Object is readonly!");
+		const rawValue = toRaw$1(newValue);
+		const oldValue = target[p];
+		const v = this.isShallow ? newValue : rawValue;
+		if (oldValue === rawValue) return Reflect.set(target, p, v, receiver);
+		const b = Reflect.set(target, p, v, receiver);
+		fromInternalWrite = false;
+		if (hasOwn(target, p)) trigger$1(target, TriggerOpTypes$1.Set, p);
+		else trigger$1(target, TriggerOpTypes$1.Add, p);
+		return b;
+	}
+	get(target, p, receiver) {
+		track$1(target, TrackOpTypes$1.Get, p);
+		const value = Reflect.get(target, p, receiver);
+		if (this.isShallow) return value;
+		return reactive$1(value);
+	}
+	deleteProperty(target, p) {
+		const b = Reflect.deleteProperty(target, p);
+		trigger$1(target, TriggerOpTypes$1.Delete, p);
+		return b;
+	}
+	ownKeys(target) {
+		track$1(target, TrackOpTypes$1.Iterate);
+		return Reflect.ownKeys(target);
+	}
+};
+function noReactive(v) {
+	return v;
+}
+var ArrayReactiveHandler$1 = class extends ObjectReactiveHandler$1 {
+	interceptors = createArrayHandlers(this.isShallow ? noReactive : reactive$1);
+	constructor(config) {
+		super(config);
+	}
+	get(target, p, receiver) {
+		if (Reflect.has(this.interceptors, p) && p in target) return this.interceptors[p];
+		return super.get(target, p, receiver);
+	}
+};
+var MapReactiveHandler$1 = class extends ObjectReactiveHandler$1 {
+	interceptors = createMapHandlers(this.isShallow ? noReactive : reactive$1);
+	constructor(config) {
+		super(config);
+	}
+	get(target, p, receiver) {
+		if (Reflect.has(this.interceptors, p) && p in target) return this.interceptors[p];
+		if (p === "size") {
+			track$1(target, TrackOpTypes$1.Iterate, p);
+			return Reflect.get(target, p);
+		}
+		return super.get(target, p, receiver);
+	}
+};
+var SetReactiveHandler$1 = class extends ObjectReactiveHandler$1 {
+	interceptors = createSetHandlers(this.isShallow ? noReactive : reactive$1);
+	constructor(config) {
+		super(config);
+	}
+	get(target, p, receiver) {
+		if (Reflect.has(this.interceptors, p) && p in target) return this.interceptors[p];
+		if (p === "size") {
+			track$1(target, TrackOpTypes$1.Iterate, p);
+			return Reflect.get(target, p);
+		}
+		return super.get(target, p, receiver);
+	}
+};
+var defaultObjectReactiveHandler$1 = new ObjectReactiveHandler$1({
+	readonly: false,
+	shallow: false
+});
+var defaultArrayReactiveHandler$1 = new ArrayReactiveHandler$1({
+	readonly: false,
+	shallow: false
+});
+var defaultMapReactiveHandler$1 = new MapReactiveHandler$1({
+	readonly: false,
+	shallow: false
+});
+var defaultSetReactiveHandler$1 = new SetReactiveHandler$1({
+	readonly: false,
+	shallow: false
+});
+new ObjectReactiveHandler$1({
+	shallow: true,
+	readonly: true
+});
+/**
+* 创建一个响应式对象
+* @param raw 原始对象
+* @returns 响应式对象
+* @example
+* ```tsx
+* const obj = reactive({
+*   name: 'John',
+*   age: 18,
+*   children: [
+*     {
+*       name: 'Jane',
+*       age: 16
+*     }
+*   ]
+* })
+* console.log(obj.name)
+* console.log(obj.children[0].name)
+* ```
+*/
+function reactive$1(raw) {
+	if (isReactive$1(raw)) return raw;
+	let proxy = rawToProxyCache$1.get(raw);
+	if (proxy) return proxy;
+	switch (getStringType(raw)) {
+		case "[object Object]":
+			proxy = new Proxy(raw, defaultObjectReactiveHandler$1);
+			break;
+		case "[object Array]":
+			proxy = new Proxy(raw, defaultArrayReactiveHandler$1);
+			break;
+		case "[object Set]":
+		case "[object WeakSet]":
+			proxy = new Proxy(raw, defaultSetReactiveHandler$1);
+			break;
+		case "[object Map]":
+		case "[object WeakMap]":
+			proxy = new Proxy(raw, defaultMapReactiveHandler$1);
+			break;
+		default: return raw;
+	}
+	rawToProxyCache$1.set(raw, proxy);
+	proxyToRawCache$1.set(proxy, raw);
+	return proxy;
+}
+makeError$1("Ref");
+var componentSetupStack = [];
+var componentErrorFn = makeError$1("component");
+function getSetupContext$1(need = true) {
+	const current = componentSetupStack[componentSetupStack.length - 1];
+	if (!current && need) throw componentErrorFn("cannot be called outside the component!");
+	return current;
+}
+/**
+* 注册组件销毁回调函数
+* @param fn 要注册的回调函数
+* @internal
+*/
+function registryComponentDestroyCallback$1(fn) {
+	const component = getSetupContext$1(false);
+	if (component) {
+		if (!component.unmountedCallbacks) component.unmountedCallbacks = [];
+		component.unmountedCallbacks.push(fn);
+	}
+}
+makeError$1("Viewfly");
+new ObjectReactiveHandler$1({
+	readonly: false,
+	shallow: true
+});
+new ArrayReactiveHandler$1({
+	readonly: false,
+	shallow: true
+});
+new MapReactiveHandler$1({
+	readonly: false,
+	shallow: true
+});
+new SetReactiveHandler$1({
+	readonly: false,
+	shallow: true
+});
+//#endregion
+//#region src/reactive/watch-effect.ts
+/**
+* 创建一个 watchEffect，立即执行 effect 函数，当依赖的值发生变化时，会再次执行 effect 函数。
+* watchEffect 会返回一个函数，用于停止监听
+* @param effect 执行的函数
+* @returns 一个函数，用于停止监听
+*/
+function watchEffect(effect) {
+	const dep = new Dep$1(function() {
+		pushDepContext$1(dep);
+		effect();
+		popDepContext$1();
+	});
+	pushDepContext$1(dep);
+	effect();
+	popDepContext$1();
+	function unWatch() {
+		dep.destroy();
+	}
+	registryComponentDestroyCallback$1(unWatch);
+	return unWatch;
+}
+//#endregion
+//#region src/reactive/watch.ts
+/**
+* 创建一个 watch，当依赖的值发生变化时，会执行 callback 函数。
+* watch 会返回一个函数，用于停止监听。
+* @param trigger 触发函数，用于获取依赖的值
+* @param callback 回调函数，当依赖的值发生变化时，会执行 callback 函数
+* @returns 一个函数，用于停止监听
+*/
+function watch(trigger, callback) {
+	const initValue = {};
+	let oldValue = initValue;
+	const unWatch = watchEffect(function() {
+		if (oldValue === initValue) {
+			oldValue = trigger();
+			return;
+		}
+		const newValue = trigger();
+		if (newValue !== oldValue) {
+			callback(newValue, oldValue);
+			oldValue = newValue;
+		}
+	});
+	registryComponentDestroyCallback(unWatch);
+	return unWatch;
+}
+//#endregion
+//#region src/base/context.ts
+var injectMap = /* @__PURE__ */ new WeakMap();
+function getInjector(start) {
+	while (start) {
+		const injector = injectMap.get(start);
+		if (injector) return injector;
+		start = start.parentComponent;
+	}
+	return new NullInjector();
+}
+/**
+* 创建一个上下文，用于在组件之间共享数据
+* @param providers 提供者，用于提供数据
+* @param scope 作用域，用于限制提供者的作用域
+* @param parentInjector 父注入器，用于自定义父注入器，默认从当前组件树中自动获取
+* @returns 一个上下文组件，组件的子元素都可以通过 inject 获取到提供者提供的数据
+* @example
+* ```tsx
+* @Injectable()
+* class ExampleService {}
+*
+* function Child(props) {
+*   const exampleService = inject(ExampleService)
+*   console.log(exampleService)
+*   return () => {
+*     return <div>{props.children}</div>
+*   }
+* }
+* function App() {
+*   const Context = createContext([
+*     ExampleService
+*   ])
+*   return () => {
+*     return <Context>
+*       <Child>test</Child>
+*     </Context>
+*   }
+* }
+* ```
+*/
+function createContext(providers, scope, parentInjector) {
+	return function context(props) {
+		const instance = getCurrentInstance();
+		const injector = new ReflectiveInjector(parentInjector || getInjector(instance), providers, scope);
+		injectMap.set(instance, injector);
+		return () => {
+			return props.children;
+		};
+	};
+}
+/**
+* 创建一个上下文提供者组件，组件的子元素都可以通过 inject 获取到提供者提供的数据
+* @param params 提供者参数
+* @returns 一个上下文提供者组件，组件的子元素都可以通过 inject 获取到提供者提供的数据
+* @example
+* ```tsx
+* const ExampleService = createContextProvider({
+*   provide: ExampleService
+* })
+* 
+* function Child() {
+*   const exampleService = inject(ExampleService)
+*   console.log(exampleService)
+*   return () => {
+*     return <div>{exampleService.name}</div>
+*   }
+* }
+* 
+* function App() {
+*   const value = new ExampleService()
+*   return () => {
+*     return <ExampleService useValue={value}>
+*       <Child/>
+*     </ExampleService>
+*   }
+* }
+*/
+function createContextProvider(params) {
+	return function contextProvider(props) {
+		let Context = createContext([{
+			provide: params.provide,
+			...props
+		}]);
+		watch(() => {
+			return props.useClass || props.useFactory || props.useValue || props.useExisting;
+		}, () => {
+			Context = createContext([{
+				provide: params.provide,
+				...props
+			}]);
+		});
+		return () => {
+			return jsx(Context, { children: props.children });
+		};
+	};
+}
+/**
+* 通过组件上下文获取 IoC 容器内数据的勾子方法
+* @param token 注入的 token
+* @param notFoundValue 未找到时的值
+* @param flags 注入标志
+* @returns 注入的值
+* @example
+* ```tsx
+* function ChildComponent() {
+*   const exampleService = inject(ExampleService)
+*   console.log(exampleService)
+*   return () => {
+*     return <div>{exampleService.name}</div>
+*   }
+* }
+*/
+function inject(token, notFoundValue = THROW_IF_NOT_FOUND, flags) {
+	return getInjector(getCurrentInstance()).get(token, notFoundValue, flags);
+}
+/**
+* 给组件添加注解
+* @param annotation
+* @param componentSetup
+* @example
+* ```ts
+* export customScope = new Scope('scopeName')
+* export const App = withAnnotation({
+*   scope: customScope,
+*   providers: [
+*     ExampleService
+*   ]
+* }, function(props: Props) {
+*   return () => {
+*     return <div>...</div>
+*   }
+* })
+* ```
+*/
+function withAnnotation(annotation, componentSetup) {
+	return function(props) {
+		const instance = getCurrentInstance();
+		const injector = new ReflectiveInjector(injectMap.get(instance) || getInjector(instance.parentComponent), [{
+			provide: Injector,
+			useFactory() {
+				return injector;
+			}
+		}, ...annotation.providers || []], annotation.scope);
+		injectMap.set(instance, injector);
+		return componentSetup(props);
+	};
+}
+//#endregion
+//#region src/base/injection-tokens.ts
+var NativeRenderer = class {};
+//#endregion
+//#region src/base/renderer.ts
+var listenerReg = /^on[A-Z]/;
+var nativeNodeRefRecord = /* @__PURE__ */ new Map();
+function createRenderer(component, nativeRenderer, namespace) {
+	let isInit = true;
+	return function render(host) {
+		if (isInit) {
+			isInit = false;
+			componentRender(nativeRenderer, component, {
+				type: ComponentAtomType,
+				index: 0,
+				nodeType: component.type,
+				jsxNode: component,
+				sibling: null,
+				child: null,
+				nativeNode: null,
+				namespace
+			}, {
+				isParent: true,
+				host,
+				rootHost: host
+			});
+		} else deepUpdateByComponentDirtyTree(nativeRenderer, component, false);
+	};
+}
+function buildView(nativeRenderer, parentComponent, atom, context) {
+	const { jsxNode, type } = atom;
+	if (type === ComponentAtomType) {
+		const component = new Component(parentComponent, jsxNode.type, jsxNode.props, jsxNode.key);
+		atom.jsxNode = component;
+		componentRender(nativeRenderer, component, atom, context);
+	} else if (type === ElementAtomType) createElement(nativeRenderer, atom, parentComponent, context);
+	else createTextNode(nativeRenderer, atom, context);
+}
+function buildElementChildren(atom, nativeRenderer, parentComponent, context) {
+	let child = atom.child;
+	while (child) {
+		buildView(nativeRenderer, parentComponent, child, context);
+		child = child.sibling;
+	}
+}
+function patchComponent(nativeRenderer, component, oldChildAtom, newAtom, context, needMove) {
+	newAtom.child = createChildChain(component.rerender(), nativeRenderer, newAtom.namespace);
+	diff(nativeRenderer, component, newAtom.child, oldChildAtom, context, needMove);
+}
+function deepUpdateByComponentDirtyTree(nativeRenderer, component, needMove) {
+	if (component.dirty) {
+		const { atom, host, isParent, rootHost } = component.viewMetadata;
+		const context = {
+			host,
+			isParent,
+			rootHost
+		};
+		const diffAtom = atom.child;
+		patchComponent(nativeRenderer, component, diffAtom, atom, context, needMove);
+		const next = atom.sibling;
+		if (next && next.jsxNode instanceof Component) {
+			const view = next.jsxNode.viewMetadata;
+			view.host = context.host;
+			view.isParent = context.isParent;
+		}
+		component.rendered();
+	} else if (component.changed) {
+		component.changedSubComponents.forEach((child) => {
+			deepUpdateByComponentDirtyTree(nativeRenderer, child, needMove);
+		});
+		component.rendered();
+	}
+}
+function diff(nativeRenderer, parentComponent, newAtom, oldAtom, context, needMove) {
+	const commits = [];
+	while (newAtom) {
+		oldAtom = createChanges(newAtom, oldAtom, commits);
+		newAtom = newAtom.sibling;
+	}
+	let dirtyDiffAtom = oldAtom;
+	while (dirtyDiffAtom) {
+		cleanView(nativeRenderer, dirtyDiffAtom, true);
+		dirtyDiffAtom = dirtyDiffAtom.sibling;
+	}
+	let offset = 0;
+	const len = commits.length;
+	for (let i = 0; i < len; i++) {
+		while (oldAtom) {
+			if (oldAtom.index <= i) {
+				offset--;
+				oldAtom = oldAtom.sibling;
+				continue;
+			}
+			break;
+		}
+		const { dirtyAtom, newAtom } = commits[i];
+		if (dirtyAtom) switch (dirtyAtom.type) {
+			case ElementAtomType:
+				updateElement(nativeRenderer, context, parentComponent, offset, needMove, newAtom, dirtyAtom);
+				break;
+			case TextAtomType:
+				updateText(nativeRenderer, context, offset, needMove, newAtom, dirtyAtom);
+				break;
+			case ComponentAtomType:
+				updateComponent(nativeRenderer, context, offset, needMove, newAtom, dirtyAtom);
+				break;
+		}
+		else {
+			buildView(nativeRenderer, parentComponent, newAtom, context);
+			offset++;
+		}
+	}
+}
+function createChanges(newAtom, oldAtom, commits) {
+	const startDiffAtom = oldAtom;
+	let prev = null;
+	while (oldAtom) {
+		if (oldAtom.type === newAtom.type && oldAtom.nodeType === newAtom.nodeType && oldAtom.key === newAtom.key) {
+			commits.push({
+				dirtyAtom: oldAtom,
+				newAtom
+			});
+			const next = oldAtom.sibling;
+			if (!prev) return next;
+			prev.sibling = next;
+			return startDiffAtom;
+		}
+		prev = oldAtom;
+		oldAtom = oldAtom.sibling;
+	}
+	commits.push({
+		dirtyAtom: null,
+		newAtom
+	});
+	return startDiffAtom;
+}
+function updateText(nativeRenderer, context, offset, needMove, newAtom, oldAtom) {
+	const nativeNode = oldAtom.nativeNode;
+	newAtom.nativeNode = nativeNode;
+	if (needMove || newAtom.index - offset !== oldAtom.index) insertNode(nativeRenderer, newAtom, context);
+	context.host = nativeNode;
+	context.isParent = false;
+}
+function updateElement(nativeRenderer, context, parentComponent, offset, needMove, newAtom, oldAtom) {
+	const nativeNode = oldAtom.nativeNode;
+	newAtom.nativeNode = nativeNode;
+	if (needMove || newAtom.index - offset !== oldAtom.index) insertNode(nativeRenderer, newAtom, context);
+	context.host = nativeNode;
+	context.isParent = false;
+	updateNativeNodeProperties(nativeRenderer, newAtom, oldAtom, parentComponent, {
+		host: nativeNode,
+		isParent: true,
+		rootHost: context.rootHost
+	});
+}
+function updateComponent(nativeRenderer, context, offset, needMove, newAtom, oldAtom) {
+	const component = oldAtom.jsxNode;
+	const portalHost = component.instance.$portalHost;
+	context = portalHost ? {
+		isParent: true,
+		host: portalHost,
+		rootHost: portalHost
+	} : context;
+	component.viewMetadata = {
+		atom: newAtom,
+		...context
+	};
+	const newProps = newAtom.jsxNode.props;
+	newAtom.jsxNode = component;
+	needMove = needMove || newAtom.index - offset !== oldAtom.index;
+	const propsIsChanged = hasChange(newProps, component.props);
+	if (propsIsChanged) component.updateProps(newProps);
+	if (propsIsChanged || component.dirty) {
+		patchComponent(nativeRenderer, component, oldAtom.child, newAtom, context, needMove);
+		const next = oldAtom.sibling;
+		if (next && next.jsxNode instanceof Component) {
+			const view = next.jsxNode.viewMetadata;
+			view.host = context.host;
+			view.isParent = context.isParent;
+		}
+	} else {
+		newAtom.child = oldAtom.child;
+		reuseComponentView(nativeRenderer, newAtom.child, context, needMove, !component.changedSubComponents.size);
+	}
+	component.rendered();
+}
+function reuseComponentView(nativeRenderer, child, context, moveView, skipSubComponentDiff) {
+	const updateContext = (atom) => {
+		const jsxNode = atom.jsxNode;
+		if (jsxNode instanceof Component) {
+			reuseComponentView(nativeRenderer, atom.child, context, moveView, skipSubComponentDiff);
+			if (!skipSubComponentDiff) deepUpdateByComponentDirtyTree(nativeRenderer, jsxNode, moveView);
+		} else {
+			if (moveView) insertNode(nativeRenderer, atom, context);
+			if (!skipSubComponentDiff) reuseElementChildrenView(nativeRenderer, atom, context);
+			context.isParent = false;
+			context.host = atom.nativeNode;
+		}
+	};
+	while (child) {
+		updateContext(child);
+		child = child.sibling;
+	}
+}
+function reuseElementChildrenView(nativeRenderer, atom, context) {
+	let child = atom.child;
+	while (child) {
+		if (child.jsxNode instanceof Component) deepUpdateByComponentDirtyTree(nativeRenderer, child.jsxNode, false);
+		else reuseElementChildrenView(nativeRenderer, child, context);
+		child = child.sibling;
+	}
+}
+function cleanElementChildren(atom, nativeRenderer) {
+	let child = atom.child;
+	nativeRenderer.cleanChildren(atom.nativeNode, atom.namespace);
+	while (child) {
+		cleanView(nativeRenderer, child, false);
+		child = child.sibling;
+	}
+}
+function cleanView(nativeRenderer, atom, needClean) {
+	if (atom.type === ComponentAtomType) {
+		const jsxNode = atom.jsxNode;
+		if (jsxNode.instance.$portalHost) needClean = true;
+		cleanChildren(atom, nativeRenderer, needClean);
+		jsxNode.destroy();
+		return;
+	}
+	if (needClean) {
+		nativeRenderer.remove(atom.nativeNode, atom.namespace);
+		needClean = false;
+	}
+	if (atom.type === ElementAtomType) {
+		const record = nativeNodeRefRecord.get(atom);
+		if (record) record.forEach((fn) => {
+			if (typeof fn === "function") fn();
+		});
+	}
+	cleanChildren(atom, nativeRenderer, needClean);
+}
+function cleanChildren(atom, nativeRenderer, needClean) {
+	let child = atom.child;
+	while (child) {
+		cleanView(nativeRenderer, child, needClean);
+		child = child.sibling;
+	}
+}
+function componentRender(nativeRenderer, component, from, context) {
+	component.render((template, portalHost) => {
+		from.child = createChildChain(template, nativeRenderer, from.namespace);
+		context = portalHost ? {
+			isParent: true,
+			host: portalHost,
+			rootHost: portalHost
+		} : context;
+		component.viewMetadata = {
+			atom: from,
+			...context
+		};
+		let child = from.child;
+		while (child) {
+			buildView(nativeRenderer, component, child, context);
+			child = child.sibling;
+		}
+	});
+}
+function createChainByJSXNode(type, jsxNode, nodeType, prevAtom, namespace, key) {
+	const atom = {
+		type,
+		index: prevAtom.index + 1,
+		jsxNode,
+		sibling: null,
+		child: null,
+		nativeNode: null,
+		namespace,
+		nodeType,
+		key
+	};
+	prevAtom.sibling = atom;
+	return atom;
+}
+function createChainByNode(jsxNode, prevAtom, nativeRenderer, elementNamespace) {
+	const type = typeof jsxNode;
+	if (jsxNode != null && type !== "boolean") {
+		if (type === "string") return createChainByJSXNode(TextAtomType, jsxNode, jsxNode, prevAtom, elementNamespace);
+		if (type === "object") {
+			if (Array.isArray(jsxNode)) return createChainByChildren(jsxNode, prevAtom, nativeRenderer, elementNamespace);
+			const nodeType = typeof jsxNode.type;
+			if (nodeType === "string") return createChainByJSXNode(ElementAtomType, jsxNode, jsxNode.type, prevAtom, nativeRenderer.getNameSpace(jsxNode.type, elementNamespace), jsxNode.key);
+			else if (nodeType === "function") return createChainByJSXNode(ComponentAtomType, jsxNode, jsxNode.type, prevAtom, elementNamespace, jsxNode.key);
+		}
+		const text = String(jsxNode);
+		return createChainByJSXNode(TextAtomType, text, text, prevAtom, elementNamespace);
+	}
+	return prevAtom;
+}
+function createChainByChildren(children, prevAtom, nativeRenderer, elementNamespace) {
+	const len = children.length;
+	for (let i = 0; i < len; i++) {
+		const item = children[i];
+		prevAtom = createChainByNode(item, prevAtom, nativeRenderer, elementNamespace);
+	}
+	return prevAtom;
+}
+function createChildChain(template, nativeRenderer, namespace) {
+	const beforeAtom = {
+		sibling: null,
+		index: -1
+	};
+	createChainByNode(template, beforeAtom, nativeRenderer, namespace);
+	return beforeAtom.sibling;
+}
+function insertNode(nativeRenderer, atom, context) {
+	if (context.isParent) if (context.host === context.rootHost) nativeRenderer.appendChild(context.host, atom.nativeNode, atom.namespace);
+	else nativeRenderer.prependChild(context.host, atom.nativeNode, atom.namespace);
+	else nativeRenderer.insertAfter(atom.nativeNode, context.host, atom.namespace);
+}
+function createElementChildren(type, children, nativeRenderer, namespace) {
+	return createChildChain(children, nativeRenderer, nativeRenderer.getNameSpace(type, namespace));
+}
+function createElement(nativeRenderer, atom, parentComponent, context) {
+	const { namespace, jsxNode } = atom;
+	const nativeNode = nativeRenderer.createElement(jsxNode.type, namespace);
+	const props = jsxNode.props;
+	let bindingRefs;
+	for (const key in props) {
+		if (key === "children") {
+			atom.child = createElementChildren(jsxNode.type, props.children, nativeRenderer, namespace);
+			continue;
+		}
+		if (key === "class") {
+			const className = classToString(props[key]);
+			if (className) nativeRenderer.setClass(nativeNode, className, namespace);
+			continue;
+		}
+		if (key === "style") {
+			const style = styleToObject(props.style);
+			for (const key in style) nativeRenderer.setStyle(nativeNode, key, style[key], namespace);
+			continue;
+		}
+		if (listenerReg.test(key)) {
+			const listener = props[key];
+			if (typeof listener === "function") nativeRenderer.listen(nativeNode, key, listener, namespace);
+			continue;
+		}
+		if (key === "ref") {
+			bindingRefs = props[key];
+			continue;
+		}
+		nativeRenderer.setProperty(nativeNode, key, props[key], namespace);
+	}
+	atom.nativeNode = nativeNode;
+	insertNode(nativeRenderer, atom, context);
+	buildElementChildren(atom, nativeRenderer, parentComponent, {
+		isParent: true,
+		host: nativeNode,
+		rootHost: context.rootHost
+	});
+	context.host = nativeNode;
+	context.isParent = false;
+	const refEffects = /* @__PURE__ */ new Map();
+	nativeNodeRefRecord.set(atom, refEffects);
+	applyRefs(bindingRefs, nativeNode, refEffects);
+}
+function createTextNode(nativeRenderer, atom, context) {
+	const nativeNode = nativeRenderer.createTextNode(atom.jsxNode, atom.namespace);
+	atom.nativeNode = nativeNode;
+	insertNode(nativeRenderer, atom, context);
+	context.host = nativeNode;
+	context.isParent = false;
+}
+function updateNativeNodeProperties(nativeRenderer, newAtom, oldAtom, parentComponent, context) {
+	const newVNode = newAtom.jsxNode;
+	const isSvg = newAtom.namespace;
+	const nativeNode = newAtom.nativeNode;
+	const oldVNode = oldAtom.jsxNode;
+	if (newVNode === oldVNode) {
+		newAtom.child = oldAtom.child;
+		reuseElementChildrenView(nativeRenderer, newAtom, context);
+		return;
+	}
+	let bindRefs;
+	let updatedChildren = false;
+	comparePropsWithCallbacks(oldVNode.props, newVNode.props, (key, oldValue) => {
+		if (key === "children") {
+			updatedChildren = true;
+			cleanElementChildren(oldAtom, nativeRenderer);
+			return;
+		}
+		if (key === "class") {
+			nativeRenderer.setClass(nativeNode, "", isSvg);
+			return;
+		}
+		if (key === "style") {
+			for (const styleName in styleToObject(oldValue)) nativeRenderer.removeStyle(nativeNode, styleName, isSvg);
+			return;
+		}
+		if (listenerReg.test(key)) {
+			if (typeof oldValue === "function") nativeRenderer.unListen(nativeNode, key, oldValue, isSvg);
+			return;
+		}
+		if (key === "ref") return;
+		nativeRenderer.removeProperty(nativeNode, key, isSvg);
+	}, (key, value) => {
+		if (key === "children") {
+			updatedChildren = true;
+			newAtom.child = createElementChildren(newVNode.type, value, nativeRenderer, isSvg);
+			buildElementChildren(newAtom, nativeRenderer, parentComponent, context);
+			return;
+		}
+		if (key === "class") {
+			nativeRenderer.setClass(nativeNode, classToString(value), isSvg);
+			return;
+		}
+		if (key === "style") {
+			const styleObj = styleToObject(value);
+			for (const styleName in styleObj) nativeRenderer.setStyle(nativeNode, styleName, styleObj[styleName], isSvg);
+			return;
+		}
+		if (listenerReg.test(key)) {
+			if (typeof value === "function") nativeRenderer.listen(nativeNode, key, value, isSvg);
+			return;
+		}
+		if (key === "ref") {
+			bindRefs = value;
+			return;
+		}
+		nativeRenderer.setProperty(nativeNode, key, value, isSvg);
+	}, (key, newValue, oldValue) => {
+		if (key === "children") {
+			updatedChildren = true;
+			newAtom.child = createElementChildren(newVNode.type, newValue, nativeRenderer, isSvg);
+			if (!newAtom.child) cleanElementChildren(oldAtom, nativeRenderer);
+			else if (!oldAtom.child) buildElementChildren(newAtom, nativeRenderer, parentComponent, context);
+			else diff(nativeRenderer, parentComponent, newAtom.child, oldAtom.child, context, false);
+			return;
+		}
+		if (key === "class") {
+			const oldClassName = classToString(oldValue);
+			const newClassName = classToString(newValue);
+			if (oldClassName !== newClassName) nativeRenderer.setClass(nativeNode, newClassName, isSvg);
+			return;
+		}
+		if (key === "style") {
+			comparePropsWithCallbacks(styleToObject(oldValue), styleToObject(newValue), (styleName) => {
+				nativeRenderer.removeStyle(nativeNode, styleName, isSvg);
+			}, (styleName, styleValue) => {
+				nativeRenderer.setStyle(nativeNode, styleName, styleValue, isSvg);
+			}, (styleName, styleValue) => {
+				nativeRenderer.setStyle(nativeNode, styleName, styleValue, isSvg);
+			});
+			return;
+		}
+		if (listenerReg.test(key)) {
+			nativeRenderer.unListen(nativeNode, key, oldValue, isSvg);
+			nativeRenderer.listen(nativeNode, key, newValue, isSvg);
+			return;
+		}
+		if (key === "ref") {
+			bindRefs = newValue;
+			return;
+		}
+		nativeRenderer.setProperty(nativeNode, key, newValue, isSvg);
+	});
+	if (!updatedChildren) newAtom.child = oldAtom.child;
+	let refEffects = nativeNodeRefRecord.get(oldAtom);
+	if (!refEffects) refEffects = /* @__PURE__ */ new Map();
+	nativeNodeRefRecord.delete(oldAtom);
+	nativeNodeRefRecord.set(newAtom, refEffects);
+	updateRefs(bindRefs, nativeNode, refEffects);
+}
+//#endregion
+//#region src/base/root.component.ts
+/**
+* Viewfly 根组件，用于实现组件状态更新事件通知
+*/
+var RootComponent = class extends Component {
+	constructor(factory, refresh) {
+		super(null, factory, {});
+		this.refresh = refresh;
+	}
+	markAsChanged(changedComponent) {
+		this._changed = true;
+		if (changedComponent) this.changedSubComponents.add(changedComponent);
+		this.refresh();
+	}
+};
+//#endregion
+//#region src/viewfly.ts
+var viewflyErrorFn = makeError("Viewfly");
+function viewfly(config) {
+	const { context, nativeRenderer, autoUpdate, root } = Object.assign({ autoUpdate: true }, config);
+	const modules = [];
+	let destroyed = false;
+	let appHost = null;
+	const rootProviders = [];
+	const rootComponent = new RootComponent(() => {
+		const rootContext = createContext(rootProviders, null, context);
+		return () => {
+			return jsx(rootContext, { children: destroyed ? null : root });
+		};
+	}, function() {
+		if (destroyed || !autoUpdate) return;
+		nextTick(() => {
+			render(appHost);
+		});
+	});
+	const render = createRenderer(rootComponent, nativeRenderer, config.elementNamespace);
+	let isStarted = false;
+	let task = null;
+	function nextTick(callback) {
+		if (task !== null) return;
+		task = Promise.resolve().then(() => {
+			task = null;
+			callback();
+		});
+	}
+	const app = {
+		provide(providers) {
+			providers = Array.isArray(providers) ? providers : [providers];
+			rootProviders.push(...providers);
+			return app;
+		},
+		use(module) {
+			if (Array.isArray(module)) modules.push(...module);
+			else modules.push(module);
+			return app;
+		},
+		mount(host) {
+			if (isStarted) throw viewflyErrorFn("application has already started.");
+			for (const module of modules) module.setup?.(app);
+			isStarted = true;
+			appHost = host;
+			render(host);
+			for (const module of modules) module.onAfterStartup?.(app);
+			if (!autoUpdate) return app;
+			return app;
+		},
+		render() {
+			if (appHost) render(appHost);
+			return app;
+		},
+		destroy() {
+			destroyed = true;
+			rootComponent.markAsDirtied();
+			app.render();
+			for (const module of modules) module.onDestroy?.();
+		}
+	};
+	return app;
+}
+//#endregion
+//#region src/reactive/computed.ts
+/**
+* 创建一个 computed，当依赖的值发生变化时，会重新计算值。
+* computed 会返回一个对象，对象的 value 属性是计算的值。
+* @param getter 计算函数，用于计算值
+* @returns 一个对象，对象的 value 属性是计算的值
+*/
+function computed(getter) {
+	return { get value() {
+		return getter();
+	} };
+}
+//#endregion
+//#region src/reactive/shallow-reactive.ts
+var defaultShallowObjectReactiveHandler = new ObjectReactiveHandler({
+	readonly: false,
+	shallow: true
+});
+var defaultShallowArrayReactiveHandler = new ArrayReactiveHandler({
+	readonly: false,
+	shallow: true
+});
+var defaultShallowMapReactiveHandler = new MapReactiveHandler({
+	readonly: false,
+	shallow: true
+});
+var defaultShallowSetReactiveHandler = new SetReactiveHandler({
+	readonly: false,
+	shallow: true
+});
+function shallowReactive(raw) {
+	if (isReactive(raw)) return raw;
+	let proxy = rawToProxyCache.get(raw);
+	if (proxy) return proxy;
+	switch (getStringType$1(raw)) {
+		case "[object Object]":
+			proxy = new Proxy(raw, defaultShallowObjectReactiveHandler);
+			break;
+		case "[object Array]":
+			proxy = new Proxy(raw, defaultShallowArrayReactiveHandler);
+			break;
+		case "[object Set]":
+		case "[object WeakSet]":
+			proxy = new Proxy(raw, defaultShallowSetReactiveHandler);
+			break;
+		case "[object Map]":
+		case "[object WeakMap]":
+			proxy = new Proxy(raw, defaultShallowMapReactiveHandler);
+			break;
+		default: return raw;
+	}
+	rawToProxyCache.set(raw, proxy);
+	proxyToRawCache.set(proxy, raw);
+	return proxy;
+}
+//#endregion
+//#region src/reactive/signal.ts
+/**
+* 组件状态管理器
+* @param state 初始状态
+* @example
+* ```tsx
+* function App() {
+*   // 初始化状态
+*   const state = createSignal(1)
+*
+*   return () => {
+*     <div>
+*       <div>当前值为：{state()}</div>
+*       <div>
+*         <button type="button" onClick={() => {
+*           // 当点击时更新状态
+*           state.set(state() + 1)
+*         }
+*         }>updateState</button>
+*       </div>
+*     </div>
+*   }
+* }
+*/
+function createSignal(state) {
+	const ref = shallowReactive({ value: state });
+	function signal() {
+		return ref.value;
+	}
+	signal.set = function(newValue) {
+		ref.value = newValue;
+	};
+	return signal;
+}
+//#endregion
+exports.ArrayReactiveHandler = ArrayReactiveHandler;
+exports.Component = Component;
+exports.Dep = Dep;
+exports.ForwardRef = ForwardRef;
+exports.Fragment = Fragment;
+exports.Inject = Inject;
+exports.InjectFlags = InjectFlags;
+exports.Injectable = Injectable;
+exports.InjectionToken = InjectionToken;
+exports.Injector = Injector;
+exports.JSXNodeFactory = JSXNodeFactory;
+exports.MapReactiveHandler = MapReactiveHandler;
+exports.NativeRenderer = NativeRenderer;
+exports.NullInjector = NullInjector;
+exports.ObjectReactiveHandler = ObjectReactiveHandler;
+exports.Optional = Optional;
+exports.Portal = Portal;
+exports.Prop = Prop;
+exports.ReflectiveInjector = ReflectiveInjector;
+exports.RootComponent = RootComponent;
+exports.Scope = Scope;
+exports.Self = Self;
+exports.SetReactiveHandler = SetReactiveHandler;
+exports.SkipSelf = SkipSelf;
+exports.THROW_IF_NOT_FOUND = THROW_IF_NOT_FOUND;
+exports.TrackOpTypes = TrackOpTypes;
+exports.TriggerOpTypes = TriggerOpTypes;
+exports.Type = Type;
+exports.applyMark = applyMark;
+exports.applyRefs = applyRefs;
+exports.comparePropsWithCallbacks = comparePropsWithCallbacks;
+exports.computed = computed;
+exports.createContext = createContext;
+exports.createContextProvider = createContextProvider;
+exports.createDynamicRef = createDynamicRef;
+exports.createRef = createRef;
+exports.createRenderer = createRenderer;
+exports.createShallowReadonlyProxy = createShallowReadonlyProxy;
+exports.createSignal = createSignal;
+exports.defaultArrayReactiveHandler = defaultArrayReactiveHandler;
+exports.defaultMapReactiveHandler = defaultMapReactiveHandler;
+exports.defaultObjectReactiveHandler = defaultObjectReactiveHandler;
+exports.defaultSetReactiveHandler = defaultSetReactiveHandler;
+exports.defaultShallowArrayReactiveHandler = defaultShallowArrayReactiveHandler;
+exports.defaultShallowMapReactiveHandler = defaultShallowMapReactiveHandler;
+exports.defaultShallowObjectReactiveHandler = defaultShallowObjectReactiveHandler;
+exports.defaultShallowSetReactiveHandler = defaultShallowSetReactiveHandler;
+exports.forwardRef = forwardRef;
+exports.getCurrentInstance = getCurrentInstance;
+exports.getDepContext = getDepContext;
+exports.getSetupContext = getSetupContext;
+exports.inject = inject;
+exports.internalWrite = internalWrite;
+exports.isReactive = isReactive;
+exports.jsx = jsx;
+exports.jsxs = jsxs;
+exports.makeError = makeError;
+exports.normalizeProvider = normalizeProvider;
+exports.onMounted = onMounted;
+exports.onUnmounted = onUnmounted;
+exports.onUpdated = onUpdated;
+exports.popDepContext = popDepContext;
+exports.proxyToRawCache = proxyToRawCache;
+exports.pushDepContext = pushDepContext;
+exports.rawToProxyCache = rawToProxyCache;
+exports.reactive = reactive;
+exports.readonlyProxyHandler = readonlyProxyHandler;
+exports.registryComponentDestroyCallback = registryComponentDestroyCallback;
+exports.shallowReactive = shallowReactive;
+exports.toRaw = toRaw;
+exports.track = track;
+exports.trigger = trigger;
+exports.updateRefs = updateRefs;
+exports.viewfly = viewfly;
+exports.watch = watch;
+exports.watchEffect = watchEffect;
+exports.withAnnotation = withAnnotation;
+exports.withMark = withMark;