@viewfly/core 2.0.0 → 2.2.0

package/dist/index.esm.js

@@ -0,0 +1,2243 @@
+import "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
+* ```tsx
+* function App() {
+*   onMount(() => {
+*     console.log('App mounted!')
+*   })
+*   return () => <div>...</div>
+* }
+* ```
+*/
+function onMounted(callback) {
+	const component = getSetupContext();
+	if (!component.mountCallbacks) component.mountCallbacks = [];
+	component.mountCallbacks.push(callback);
+}
+/**
+* 当组件视图更新后调用
+* @param callback
+* ```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
+*/
+function onUnmounted(callback) {
+	const component = getSetupContext();
+	if (!component.unmountedCallbacks) component.unmountedCallbacks = [];
+	component.unmountedCallbacks.push(callback);
+}
+//#endregion
+//#region src/base/ref.ts
+var DynamicRef = class {
+	unBindMap = /* @__PURE__ */ new Map();
+	targetCaches = /* @__PURE__ */ new Set();
+	constructor(callback) {
+		this.callback = callback;
+	}
+	bind(value) {
+		if (typeof value !== "object" || value === null) return;
+		if (this.targetCaches.has(value)) return;
+		const unBindFn = this.callback(value);
+		if (typeof unBindFn === "function") this.unBindMap.set(value, unBindFn);
+		this.targetCaches.add(value);
+	}
+	unBind(value) {
+		this.targetCaches.delete(value);
+		const unBindFn = this.unBindMap.get(value);
+		this.unBindMap.delete(value);
+		if (typeof unBindFn === "function") unBindFn();
+	}
+};
+/**
+* 用于节点渲染完成时获取 DOM 节点
+* @param callback 获取 DOM 节点的回调函数
+* @example
+* ```tsx
+* function App() {
+*   const ref = createDynamicRef(node => {
+*     function fn() {
+*       // do something...
+*     }
+*     node.addEventListener('click', fn)
+*     return () => {
+*       node.removeEventListener('click', fn)
+*     }
+*   })
+*   return () => {
+*     return <div ref={ref}>xxx</div>
+*   }
+* }
+* ```
+*/
+function createDynamicRef(callback) {
+	return new DynamicRef(callback);
+}
+var StaticRef = class extends DynamicRef {
+	get current() {
+		return this._current;
+	}
+	_current = null;
+	constructor() {
+		super((v) => {
+			this._current = v;
+			return () => {
+				this._current = null;
+			};
+		});
+	}
+};
+function createRef() {
+	return new StaticRef();
+}
+//#endregion
+//#region src/reactive/_help.ts
+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);
+}
+//#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 = [];
+function getDepContext() {
+	return deps.at(-1);
+}
+function pushDepContext(dep) {
+	deps.push(dep);
+}
+function popDepContext() {
+	deps.pop();
+}
+//#endregion
+//#region src/reactive/effect.ts
+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 = /* @__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 = Symbol("unKnownKey");
+function track(target, type, key = unKnownKey) {
+	const dep = getDepContext();
+	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(target, type, key = unKnownKey) {
+	const subscriber = getSubscriber(target);
+	if (subscriber) switch (type) {
+		case TriggerOpTypes.Set:
+			if (isArray(target)) runEffect(unKnownKey, subscriber.get(TrackOpTypes.Iterate));
+			runEffect(key, subscriber.get(TrackOpTypes.Get));
+			runEffect(key, subscriber.get(TrackOpTypes.Has));
+			break;
+		case TriggerOpTypes.Add:
+		case TriggerOpTypes.Clear:
+		case TriggerOpTypes.Delete:
+			runEffect(unKnownKey, subscriber.get(TrackOpTypes.Iterate));
+			runEffect(key, subscriber.get(TrackOpTypes.Has));
+			runEffect(key, subscriber.get(TrackOpTypes.Get));
+			break;
+	}
+}
+//#endregion
+//#region src/reactive/iterable-iterator.ts
+function createIterableIterator(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(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(self, methodName, args) {
+	const target = toRaw(self);
+	track(target, TrackOpTypes.Iterate);
+	return target[methodName](...args.map(toRaw));
+}
+function createArrayHandlers(wrapper) {
+	return {
+		concat(...items) {
+			const target = toRaw(this);
+			trigger(target, TriggerOpTypes.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(this);
+			track(target, TrackOpTypes.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(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(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(wrapper)
+	};
+}
+//#endregion
+//#region src/reactive/map-handlers.ts
+function createMapHandlers(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(wrapper)
+	};
+}
+//#endregion
+//#region src/reactive/set-handlers.ts
+function createSetHandlers(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(wrapper)
+	};
+}
+//#endregion
+//#region src/reactive/reactive.ts
+var reactiveErrorFn = makeError("reactive");
+var rawToProxyCache = /* @__PURE__ */ new WeakMap();
+var proxyToRawCache = /* @__PURE__ */ new WeakMap();
+function toRaw(value) {
+	if (proxyToRawCache.has(value)) return proxyToRawCache.get(value);
+	return value;
+}
+function isReactive(value) {
+	return proxyToRawCache.has(value);
+}
+var fromInternalWrite = false;
+function internalWrite(fn) {
+	fromInternalWrite = true;
+	fn();
+	fromInternalWrite = 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) throw reactiveErrorFn("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 = false;
+		if (hasOwn(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(v) {
+	return v;
+}
+var ArrayReactiveHandler = class extends ObjectReactiveHandler {
+	interceptors = createArrayHandlers(this.isShallow ? noReactive : 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(this.isShallow ? noReactive : 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(this.isShallow ? noReactive : 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 reactive(raw) {
+	if (isReactive(raw)) return raw;
+	let proxy = rawToProxyCache.get(raw);
+	if (proxy) return proxy;
+	switch (getStringType(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/component.ts
+var componentSetupStack = [];
+var componentErrorFn = makeError("component");
+function getSetupContext(need = true) {
+	const current = componentSetupStack[componentSetupStack.length - 1];
+	if (!current && need) throw componentErrorFn("cannot be called outside the component!");
+	return current;
+}
+function toRefs(ref) {
+	return (Array.isArray(ref) ? ref : [ref]).filter((i) => {
+		return i instanceof DynamicRef;
+	});
+}
+function createReadonlyProxy(value) {
+	return new Proxy(value, readonlyProxyHandler);
+}
+/**
+* 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.refs = null;
+		this.rawProps = props;
+		this.props = createReadonlyProxy({ ...props });
+		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.push(this);
+		const render = this.type(this.props);
+		const isRenderFn = typeof render === "function";
+		this.instance = isRenderFn ? { $render: render } : render;
+		const refs = toRefs(this.props.ref);
+		if (refs.length) {
+			this.refs = refs;
+			onMounted(() => {
+				const refs = this.refs;
+				const length = refs.length;
+				for (let i = 0; i < length; i++) refs[i].bind(this.instance);
+				return () => {
+					const refs = this.refs;
+					const length = refs.length;
+					for (let i = 0; i < length; i++) refs[i].unBind(this.instance);
+				};
+			});
+		}
+		componentSetupStack.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 = toRefs(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;
+			});
+		});
+		if (this.refs) {
+			const len = this.refs.length;
+			for (let i = 0; i < len; i++) {
+				const oldRef = this.refs[i];
+				if (!newRefs.includes(oldRef)) oldRef.unBind(this.instance);
+			}
+		}
+		const len = newRefs.length;
+		for (let i = 0; i < len; i++) newRefs[i].bind(this.instance);
+		if (len) this.refs = newRefs;
+	}
+	canUpdate(oldProps, newProps) {
+		if (typeof this.instance.$useMemo === "function") {
+			if (this.instance.$useMemo(newProps, oldProps)) return false;
+		}
+		return true;
+	}
+	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;
+		}
+	}
+};
+/**
+* 获取当前组件实例
+*/
+function getCurrentInstance() {
+	return getSetupContext();
+}
+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 src/reactive/watch.ts
+function watch(trigger, callback) {
+	let prevFn;
+	const dep = new Dep(() => {
+		pushDepContext(dep);
+		const newValue = trigger();
+		popDepContext();
+		if (newValue === oldValue) return;
+		if (prevFn) prevFn();
+		prevFn = callback(newValue, oldValue);
+		oldValue = newValue;
+	});
+	pushDepContext(dep);
+	let oldValue = trigger();
+	popDepContext();
+	dep.destroyCallbacks.push(() => {
+		prevFn?.();
+	});
+	function unWatch() {
+		dep.destroy();
+	}
+	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();
+}
+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;
+		};
+	};
+}
+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 容器内数据的勾子方法
+*/
+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/memo.ts
+/**
+* @deprecated 即将弃用，Viewfly 默认就有 memo 的效果
+* @param canUseMemo
+* @param render
+*/
+function withMemo(canUseMemo, render) {
+	return {
+		$useMemo: canUseMemo,
+		$render: render
+	};
+}
+//#endregion
+//#region src/base/renderer.ts
+var listenerReg = /^on[A-Z]/;
+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) {
+		if (component.canUpdate(component.props, component.props)) {
+			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 canUpdate = component.canUpdate(component.props, newProps);
+	const propsIsChanged = hasChange(newProps, component.props);
+	if (propsIsChanged) component.updateProps(newProps);
+	if (canUpdate && (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, !canUpdate || !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 ref = atom.jsxNode.props["ref"];
+		applyRefs(ref, atom.nativeNode, false);
+	}
+	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;
+	applyRefs(bindingRefs, nativeNode, true);
+}
+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 unBindRefs;
+	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") {
+			unBindRefs = oldValue;
+			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") {
+			unBindRefs = oldValue;
+			bindRefs = newValue;
+			return;
+		}
+		nativeRenderer.setProperty(nativeNode, key, newValue, isSvg);
+	});
+	if (!updatedChildren) newAtom.child = oldAtom.child;
+	applyRefs(unBindRefs, nativeNode, false);
+	applyRefs(bindRefs, nativeNode, true);
+}
+function applyRefs(refs, nativeNode, binding) {
+	if (refs) {
+		const refList = Array.isArray(refs) ? refs : [refs];
+		const len = refList.length;
+		for (let i = 0; i < len; i++) {
+			const item = refList[i];
+			if (item instanceof DynamicRef) if (binding) item.bind(nativeNode);
+			else item.unBind(nativeNode);
+		}
+	}
+}
+//#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
+function computed(callback, isContinue) {
+	let isStop = false;
+	const dep = new Dep(() => {
+		if (isStop) return;
+		isStop = true;
+		dep.destroy();
+		pushDepContext(dep);
+		const value = callback();
+		popDepContext();
+		internalWrite(() => {
+			proxy.value = value;
+		});
+		canListen(value);
+		isStop = false;
+	});
+	pushDepContext(dep);
+	const value = callback();
+	popDepContext();
+	const proxy = new Proxy({ value }, readonlyProxyHandler);
+	function canListen(value) {
+		if (isContinue) {
+			if (isContinue(value) === false) {
+				dep.destroy();
+				return false;
+			}
+		}
+		return true;
+	}
+	if (!canListen(value)) return proxy;
+	registryComponentDestroyCallback(() => {
+		dep.destroy();
+	});
+	return proxy;
+}
+//#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(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/signals/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 subscribers = /* @__PURE__ */ new Set();
+	function signal() {
+		const listener = getDepContext();
+		if (listener && !subscribers.has(listener)) {
+			listener.destroyCallbacks.push(() => {
+				subscribers.delete(listener);
+			});
+			subscribers.add(listener);
+		}
+		return state;
+	}
+	signal.set = function(newValue) {
+		if (newValue === state) return;
+		state = newValue;
+		Array.from(subscribers).forEach((listener) => listener.effect());
+	};
+	return signal;
+}
+//#endregion
+//#region src/signals/derived.ts
+/**
+* 使用派生值，Viewfly 会收集回调函数内同步执行时访问的 Signal，
+* 并在你获取 createDerived 函数返回的 Signal 的值时，自动计算最新的值。
+*
+* @param fn
+* @param isContinue 可选的停止函数，在每次值更新后调用，当返回值为 false 时，将不再监听依赖的变化
+*/
+function createDerived(fn, isContinue) {
+	let isStop = false;
+	function canListen(value) {
+		if (isContinue) {
+			if (isContinue(value) === false) {
+				listener.destroy();
+				return false;
+			}
+		}
+		return true;
+	}
+	const listener = new Dep(() => {
+		if (isStop) return;
+		isStop = true;
+		listener.destroy();
+		pushDepContext(listener);
+		const value = fn();
+		popDepContext();
+		signal.set(value);
+		canListen(value);
+		isStop = false;
+	});
+	pushDepContext(listener);
+	const value = fn();
+	const signal = createSignal(value);
+	popDepContext();
+	isStop = false;
+	if (canListen(value)) registryComponentDestroyCallback(() => listener.destroy());
+	return signal;
+}
+//#endregion
+//#region src/signals/effect.ts
+function createEffect(deps, callback) {
+	let prevFn;
+	const isArray = Array.isArray(deps);
+	const effect = new Dep(function() {
+		if (prevFn) prevFn();
+		const newValue = isArray ? deps.map((fn) => fn()) : deps();
+		prevFn = callback(newValue, oldValue);
+		oldValue = newValue;
+	});
+	pushDepContext(effect);
+	let oldValue = isArray ? deps.map((fn) => fn()) : deps();
+	popDepContext();
+	let isUnWatch = false;
+	function unWatch() {
+		if (isUnWatch) return;
+		isUnWatch = true;
+		if (prevFn) prevFn();
+		effect.destroy();
+	}
+	registryComponentDestroyCallback(unWatch);
+	return unWatch;
+}
+//#endregion
+export { ArrayReactiveHandler, Component, Dep, DynamicRef, ForwardRef, Fragment, Inject, InjectFlags, Injectable, InjectionToken, Injector, JSXNodeFactory, MapReactiveHandler, NativeRenderer, NullInjector, ObjectReactiveHandler, Optional, Portal, Prop, ReflectiveInjector, RootComponent, Scope, Self, SetReactiveHandler, SkipSelf, StaticRef, THROW_IF_NOT_FOUND, TrackOpTypes, TriggerOpTypes, Type, applyMark, comparePropsWithCallbacks, computed, createContext, createContextProvider, createDerived, createDynamicRef, createEffect, createRef, createRenderer, createSignal, defaultArrayReactiveHandler, defaultMapReactiveHandler, defaultObjectReactiveHandler, defaultSetReactiveHandler, defaultShallowArrayReactiveHandler, defaultShallowMapReactiveHandler, defaultShallowObjectReactiveHandler, defaultShallowSetReactiveHandler, forwardRef, getCurrentInstance, getDepContext, getSetupContext, inject, internalWrite, isReactive, jsx, jsxs, makeError, normalizeProvider, onMounted, onUnmounted, onUpdated, popDepContext, proxyToRawCache, pushDepContext, rawToProxyCache, reactive, readonlyProxyHandler, registryComponentDestroyCallback, shallowReactive, toRaw, track, trigger, viewfly, watch, withAnnotation, withMark, withMemo };