@viewfly/core 2.0.0 → 2.2.0

package/bundles/index.js

@@ -1,2695 +0,0 @@
-'use strict';
-
-require('reflect-metadata');
-
-class ForwardRef {
-    constructor(forwardRefFn) {
-        Object.defineProperty(this, "forwardRefFn", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: forwardRefFn
-        });
-    }
-    getRef() {
-        return this.forwardRefFn();
-    }
-}
-/**
- * 引用后声明的类的工具函数
- * @param fn
- */
-function forwardRef(fn) {
-    return new ForwardRef(fn);
-}
-
-/**
- * 用于保存 class 的元数据
- */
-class Annotations {
-    constructor() {
-        Object.defineProperty(this, "classes", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
-        Object.defineProperty(this, "props", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
-        Object.defineProperty(this, "params", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 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);
-    }
-}
-
-/**
- * 创建参数装饰器的工厂函数
- */
-function makeParamDecorator(token, metadata) {
-    return function (target, propertyKey, parameterIndex) {
-        const annotations = getAnnotations(target);
-        annotations.pushParamMetadata(token, {
-            propertyKey: propertyKey,
-            parameterIndex,
-            metadata
-        });
-    };
-}
-/**
- * 创建属性装饰器的工厂函数
- */
-function makePropertyDecorator(token, injectToken, contextCallback) {
-    return function (target, propertyKey) {
-        const annotations = getAnnotations(target.constructor);
-        annotations.pushPropMetadata(token, {
-            injectToken: injectToken || Reflect.getMetadata('design:type', target, propertyKey),
-            propertyKey,
-            contextCallback
-        });
-    };
-}
-/**
- * 创建类装饰器的工厂函数
- */
-function makeClassDecorator(token, metadata) {
-    return function (target) {
-        const annotations = getAnnotations(target);
-        annotations.setClassMetadata(token, {
-            paramTypes: Reflect.getMetadata('design:paramtypes', target),
-            metadata
-        });
-    };
-}
-/**
- * 获取类注解的工具函数
- */
-function getAnnotations(target) {
-    const key = '__annotations__';
-    // eslint-disable-next-line no-prototype-builtins
-    if (!target.hasOwnProperty(key)) {
-        target[key] = new Annotations();
-    }
-    return target[key];
-}
-
-class Scope {
-    constructor(name) {
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: name
-        });
-    }
-    toString() {
-        return this.name || '[anonymous provide scope]';
-    }
-}
-/**
- * 可注入类的装饰器
- */
-const Injectable = function InjectableDecorator(options) {
-    if (this instanceof InjectableDecorator) {
-        this.provideIn = (options === null || options === void 0 ? void 0 : options.provideIn) || null;
-    }
-    else {
-        return makeClassDecorator(Injectable, new Injectable(options));
-    }
-};
-
-/**
- * 生成自定义依赖注入 token 的类
- */
-/* eslint-disable-next-line */
-class InjectionToken {
-    constructor(description) {
-        Object.defineProperty(this, "description", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: description
-        });
-    }
-    toString() {
-        return this.description || '[anonymous injection token]';
-    }
-}
-
-/**
- * 查找规则
- */
-exports.InjectFlags = void 0;
-(function (InjectFlags) {
-    /** 默认查找规则 */
-    InjectFlags["Default"] = "Default";
-    /** 锁定当前容器 */
-    InjectFlags["Self"] = "Self";
-    /** 跳过当前容器 */
-    InjectFlags["SkipSelf"] = "SkipSelf";
-    /** 可选查找 */
-    InjectFlags["Optional"] = "Optional";
-})(exports.InjectFlags || (exports.InjectFlags = {}));
-/**
- * DI 容器抽象基类
- */
-class Injector {
-}
-
-/**
- * 构造函数参数装饰器，用于改变注入 token
- */
-const Inject = function InjectDecorator(token) {
-    if (this instanceof Inject) {
-        this.token = token;
-    }
-    else {
-        return makeParamDecorator(Inject, new Inject(token));
-    }
-};
-const Self = function SelfDecorator() {
-    if (!(this instanceof Self)) {
-        return makeParamDecorator(Self, new Self());
-    }
-};
-const SkipSelf = function SkipSelfDecorator() {
-    if (!(this instanceof SkipSelf)) {
-        return makeParamDecorator(SkipSelf, new SkipSelf());
-    }
-};
-const Optional = function OptionalDecorator() {
-    if (!(this instanceof Optional)) {
-        return makeParamDecorator(Optional, new Optional());
-    }
-};
-const 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);
-        });
-    }
-};
-
-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);
-}
-
-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;
-    };
-}
-
-const THROW_IF_NOT_FOUND = {
-    __debug_value__: 'THROW_IF_NOT_FOUND'
-};
-const nullInjectorErrorFn = (token) => {
-    return makeError('NullInjector')(`No provide for \`${stringify(token)}\`!`);
-};
-class NullInjector {
-    constructor() {
-        Object.defineProperty(this, "parentInjector", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-    }
-    /* eslint-disable-next-line */
-    get(token, notFoundValue = THROW_IF_NOT_FOUND, _) {
-        if (notFoundValue === THROW_IF_NOT_FOUND) {
-            throw nullInjectorErrorFn(token);
-        }
-        return notFoundValue;
-    }
-}
-
-/**
- * 标准化 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);
-                const propMetadataKeys = getAnnotations(provider.useClass).getPropMetadataKeys();
-                propMetadataKeys.forEach(key => {
-                    const propsMetadata = getAnnotations(provider.useClass).getPropMetadata(key);
-                    propsMetadata.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(Object.assign(Object.assign({}, 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]);
-    const metadataKeys = [Inject, Self, SkipSelf, Optional];
-    metadataKeys.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') {
-            /* eslint-disable max-len */
-            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;
-    });
-}
-
-const reflectiveInjectorErrorFn = (token) => {
-    return makeError('ReflectiveInjector')(`No provide for \`${stringify(token)}\`!`);
-};
-const provideScopeError = (token) => {
-    return makeError('ProvideScope')(`Can not found provide scope \`${stringify(token)}\`!`);
-};
-/**
- * 反射注入器
- */
-class ReflectiveInjector {
-    constructor(parentInjector, staticProviders, scope) {
-        Object.defineProperty(this, "parentInjector", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: parentInjector
-        });
-        Object.defineProperty(this, "scope", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: scope
-        });
-        Object.defineProperty(this, "normalizedProviders", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "recordValues", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
-        this.normalizedProviders = staticProviders.map(provide => {
-            return normalizeProvider(provide);
-        });
-    }
-    /**
-     * 用于获取当前注入器上下文内的实例、对象或数据
-     * @param token 访问 token
-     * @param notFoundValue 如未查找到的返回值
-     * @param flags 查询规则
-     */
-    get(token, notFoundValue = THROW_IF_NOT_FOUND, flags) {
-        var _a;
-        flags = flags || exports.InjectFlags.Default;
-        if (flags === exports.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 = (_a = getAnnotations(token).getClassMetadata(Injectable)) === null || _a === void 0 ? void 0 : _a.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 === exports.InjectFlags.Self) {
-            if (notFoundValue === THROW_IF_NOT_FOUND) {
-                throw reflectiveInjectorErrorFn(token);
-            }
-            return notFoundValue;
-        }
-        if (this.parentInjector) {
-            return this.parentInjector.get(token, notFoundValue, flags === exports.InjectFlags.Optional ? exports.InjectFlags.Optional : exports.InjectFlags.Default);
-        }
-        if (notFoundValue === THROW_IF_NOT_FOUND) {
-            // if (flags === InjectFlags.Optional) {
-            //   return null as U
-            // }
-            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;
-        }
-        const factory = generateFactory(this, (token, value) => {
-            this.recordValues.set(token, value);
-        });
-        value = factory(...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, exports.InjectFlags.Self);
-            }
-            else if (dep.visibility instanceof SkipSelf) {
-                if (this.parentInjector) {
-                    reflectiveValue = this.parentInjector.get(injectToken, tryValue);
-                }
-                else {
-                    if (dep.optional) {
-                        // if (notFoundValue === THROW_IF_NOT_FOUND) {
-                        //   return null
-                        // }
-                        return null;
-                    }
-                    throw reflectiveInjectorErrorFn(injectToken);
-                }
-            }
-            else {
-                reflectiveValue = this.get(injectToken, tryValue);
-            }
-            if (reflectiveValue === tryValue) {
-                if (dep.optional) {
-                    // if (notFoundValue === THROW_IF_NOT_FOUND) {
-                    //   return null
-                    // }
-                    // return notFoundValue
-                    return null;
-                }
-                throw reflectiveInjectorErrorFn(injectToken);
-            }
-            return reflectiveValue;
-        });
-    }
-}
-
-const Type = Function;
-
-/**
- * 当组件第一次渲染完成时触发
- * @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);
-}
-
-class DynamicRef {
-    constructor(callback) {
-        Object.defineProperty(this, "callback", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: callback
-        });
-        Object.defineProperty(this, "unBindMap", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
-        Object.defineProperty(this, "targetCaches", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Set()
-        });
-    }
-    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);
-}
-class StaticRef extends DynamicRef {
-    get current() {
-        return this._current;
-    }
-    constructor() {
-        super(v => {
-            this._current = v;
-            return () => {
-                this._current = null;
-            };
-        });
-        Object.defineProperty(this, "_current", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-    }
-}
-function createRef() {
-    return new StaticRef();
-}
-
-const toStr = Object.prototype.toString;
-function getStringType(v) {
-    return toStr.call(v);
-}
-function isArray(v) {
-    return Array.isArray(v);
-}
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn(target, key) {
-    return hasOwnProperty.call(target, key);
-}
-
-class Dep {
-    constructor(effect) {
-        Object.defineProperty(this, "effect", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: effect
-        });
-        Object.defineProperty(this, "destroyCallbacks", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-    }
-    destroy() {
-        this.destroyCallbacks.forEach(callback => callback());
-        this.destroyCallbacks = [];
-    }
-}
-const deps = [];
-function getDepContext() {
-    return deps.at(-1);
-}
-function pushDepContext(dep) {
-    deps.push(dep);
-}
-function popDepContext() {
-    deps.pop();
-}
-
-const subscribers = new WeakMap();
-function getSubscriber(target) {
-    let subscriber = subscribers.get(target);
-    if (!subscriber) {
-        subscriber = new Map();
-        subscribers.set(target, subscriber);
-    }
-    return subscriber;
-}
-exports.TrackOpTypes = void 0;
-(function (TrackOpTypes) {
-    TrackOpTypes["Get"] = "Get";
-    TrackOpTypes["Has"] = "Has";
-    TrackOpTypes["Iterate"] = "Iterate";
-})(exports.TrackOpTypes || (exports.TrackOpTypes = {}));
-exports.TriggerOpTypes = void 0;
-(function (TriggerOpTypes) {
-    TriggerOpTypes["Set"] = "Set";
-    TriggerOpTypes["Add"] = "Add";
-    TriggerOpTypes["Delete"] = "Delete";
-    TriggerOpTypes["Clear"] = "Clear";
-})(exports.TriggerOpTypes || (exports.TriggerOpTypes = {}));
-const 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 = 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) {
-        const fns = [...effects];
-        fns.forEach(i => i.effect());
-    }
-}
-function trigger(target, type, key = unKnownKey) {
-    const subscriber = getSubscriber(target);
-    if (subscriber) {
-        switch (type) {
-            case exports.TriggerOpTypes.Set:
-                if (isArray(target)) {
-                    const iterateRecord = subscriber.get(exports.TrackOpTypes.Iterate);
-                    runEffect(unKnownKey, iterateRecord);
-                }
-                runEffect(key, subscriber.get(exports.TrackOpTypes.Get));
-                runEffect(key, subscriber.get(exports.TrackOpTypes.Has));
-                break;
-            case exports.TriggerOpTypes.Add:
-            case exports.TriggerOpTypes.Clear:
-            case exports.TriggerOpTypes.Delete:
-                {
-                    const iterateRecord = subscriber.get(exports.TrackOpTypes.Iterate);
-                    runEffect(unKnownKey, iterateRecord);
-                    runEffect(key, subscriber.get(exports.TrackOpTypes.Has));
-                    runEffect(key, subscriber.get(exports.TrackOpTypes.Get));
-                }
-                break;
-        }
-    }
-}
-
-function createIterableIterator(wrapper) {
-    return {
-        *entries() {
-            const target = toRaw(this);
-            track(target, exports.TrackOpTypes.Iterate);
-            for (const [key, value] of target.entries()) {
-                yield [wrapper(key), wrapper(value)];
-            }
-        },
-        *keys() {
-            const target = toRaw(this);
-            track(target, exports.TrackOpTypes.Iterate);
-            for (const item of target.keys()) {
-                yield wrapper(item);
-            }
-        },
-        *values() {
-            const target = toRaw(this);
-            track(target, exports.TrackOpTypes.Iterate);
-            for (const item of target.values()) {
-                yield wrapper(item);
-            }
-        }
-    };
-}
-
-function applyPredicateMethod(self, methodName, predicate, wrapper, thisArg) {
-    const target = toRaw(self);
-    track(target, exports.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, exports.TrackOpTypes.Iterate);
-    return target[methodName](...args.map(toRaw));
-}
-function createArrayHandlers(wrapper) {
-    return Object.assign({ concat(...items) {
-            const target = toRaw(this);
-            trigger(target, exports.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, exports.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, exports.TriggerOpTypes.Delete);
-            return target.pop();
-        },
-        push(...items) {
-            const target = toRaw(this);
-            trigger(target, exports.TriggerOpTypes.Add);
-            return target.push(...items);
-        },
-        reduce(callbackFn, ...args) {
-            const target = toRaw(this);
-            track(target, exports.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, exports.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, exports.TriggerOpTypes.Delete);
-            return target.shift();
-        },
-        some(predicate, thisArg) {
-            return applyPredicateMethod(this, 'some', predicate, thisArg);
-        },
-        splice(start, deleteCount) {
-            const target = toRaw(this);
-            trigger(target, exports.TriggerOpTypes.Set);
-            trigger(target, exports.TriggerOpTypes.Add);
-            trigger(target, exports.TriggerOpTypes.Delete);
-            return target.splice(start, deleteCount).map(i => wrapper(i));
-        },
-        toReversed() {
-            const target = toRaw(this);
-            track(target, exports.TrackOpTypes.Iterate);
-            return target.toReversed();
-        },
-        toSorted(compareFn) {
-            const target = toRaw(this);
-            track(target, exports.TrackOpTypes.Iterate);
-            return target.toSorted(compareFn);
-        },
-        toSpliced(start, deleteCount, ...items) {
-            const target = toRaw(this);
-            track(target, exports.TrackOpTypes.Iterate);
-            return target.toSpliced(start, deleteCount, ...items);
-        },
-        unshift(...items) {
-            const target = toRaw(this);
-            trigger(target, exports.TriggerOpTypes.Add);
-            return target.unshift(...items);
-        },
-        [Symbol.iterator]() {
-            return this.values();
-        } }, createIterableIterator(wrapper));
-}
-
-function createMapHandlers(wrapper) {
-    return Object.assign({ get(key) {
-            const target = toRaw(this);
-            track(target, exports.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 ? exports.TriggerOpTypes.Set : exports.TriggerOpTypes.Add, key);
-            return r;
-        },
-        has(key) {
-            const target = toRaw(this);
-            key = toRaw(key);
-            track(target, exports.TrackOpTypes.Has, key);
-            return target.has(key);
-        },
-        delete(key) {
-            const target = toRaw(this);
-            key = toRaw(key);
-            const r = target.delete(key);
-            trigger(target, exports.TriggerOpTypes.Delete, key);
-            return r;
-        },
-        forEach(callbackFn, thisArg) {
-            const target = toRaw(this);
-            track(target, exports.TrackOpTypes.Iterate, undefined);
-            target.forEach((v, k, m) => {
-                callbackFn.call(this, wrapper(v), wrapper(k), m);
-            }, thisArg);
-        },
-        clear() {
-            const target = toRaw(this);
-            target.clear();
-            trigger(target, exports.TriggerOpTypes.Clear, undefined);
-        },
-        [Symbol.iterator]() {
-            return this.entries();
-        } }, createIterableIterator(wrapper));
-}
-
-function createSetHandlers(wrapper) {
-    return Object.assign({ add(value) {
-            const target = toRaw(this);
-            value = toRaw(value);
-            if (!target.has(value)) {
-                target.add(value);
-                trigger(target, exports.TriggerOpTypes.Add, undefined);
-            }
-            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, exports.TriggerOpTypes.Delete, undefined);
-            }
-            return b;
-        },
-        has(key) {
-            const target = toRaw(this);
-            key = toRaw(key);
-            track(target, exports.TrackOpTypes.Has, key);
-            return target.has(key);
-        },
-        forEach(callbackFn, thisArg) {
-            const target = toRaw(this);
-            track(target, exports.TrackOpTypes.Iterate, undefined);
-            target.forEach((v, k, m) => {
-                callbackFn.call(this, wrapper(v), wrapper(k), m);
-            }, thisArg);
-        },
-        clear() {
-            const target = toRaw(this);
-            const size = target.size;
-            if (size !== 0) {
-                target.clear();
-                trigger(target, exports.TriggerOpTypes.Clear, undefined);
-            }
-        },
-        [Symbol.iterator]() {
-            return this.values();
-        } }, createIterableIterator(wrapper));
-}
-
-const reactiveErrorFn = makeError('reactive');
-const rawToProxyCache = new WeakMap();
-const proxyToRawCache = new WeakMap();
-function toRaw(value) {
-    if (proxyToRawCache.has(value)) {
-        return proxyToRawCache.get(value);
-    }
-    return value;
-}
-function isReactive(value) {
-    return proxyToRawCache.has(value);
-}
-let fromInternalWrite = false;
-function internalWrite(fn) {
-    fromInternalWrite = true;
-    fn();
-    fromInternalWrite = false;
-}
-class ObjectReactiveHandler {
-    constructor(config) {
-        Object.defineProperty(this, "isShallow", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "isReadonly", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        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, exports.TriggerOpTypes.Set, p);
-        }
-        else {
-            trigger(target, exports.TriggerOpTypes.Add, p);
-        }
-        return b;
-    }
-    get(target, p, receiver) {
-        track(target, exports.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, exports.TriggerOpTypes.Delete, p);
-        return b;
-    }
-    ownKeys(target) {
-        track(target, exports.TrackOpTypes.Iterate);
-        return Reflect.ownKeys(target);
-    }
-}
-function noReactive(v) {
-    return v;
-}
-class ArrayReactiveHandler extends ObjectReactiveHandler {
-    constructor(config) {
-        super(config);
-        Object.defineProperty(this, "interceptors", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: createArrayHandlers(this.isShallow ? noReactive : reactive)
-        });
-    }
-    get(target, p, receiver) {
-        if (Reflect.has(this.interceptors, p) && p in target) {
-            return this.interceptors[p];
-        }
-        return super.get(target, p, receiver);
-    }
-}
-class MapReactiveHandler extends ObjectReactiveHandler {
-    constructor(config) {
-        super(config);
-        Object.defineProperty(this, "interceptors", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: createMapHandlers(this.isShallow ? noReactive : reactive)
-        });
-    }
-    get(target, p, receiver) {
-        if (Reflect.has(this.interceptors, p) && p in target) {
-            return this.interceptors[p];
-        }
-        if (p === 'size') {
-            track(target, exports.TrackOpTypes.Iterate, p);
-            return Reflect.get(target, p);
-        }
-        return super.get(target, p, receiver);
-    }
-}
-class SetReactiveHandler extends ObjectReactiveHandler {
-    constructor(config) {
-        super(config);
-        Object.defineProperty(this, "interceptors", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: createSetHandlers(this.isShallow ? noReactive : reactive)
-        });
-    }
-    get(target, p, receiver) {
-        if (Reflect.has(this.interceptors, p) && p in target) {
-            return this.interceptors[p];
-        }
-        if (p === 'size') {
-            track(target, exports.TrackOpTypes.Iterate, p);
-            return Reflect.get(target, p);
-        }
-        return super.get(target, p, receiver);
-    }
-}
-const defaultObjectReactiveHandler = new ObjectReactiveHandler({
-    readonly: false,
-    shallow: false
-});
-const defaultArrayReactiveHandler = new ArrayReactiveHandler({
-    readonly: false,
-    shallow: false
-});
-const defaultMapReactiveHandler = new MapReactiveHandler({
-    readonly: false,
-    shallow: false
-});
-const defaultSetReactiveHandler = new SetReactiveHandler({
-    readonly: false,
-    shallow: false
-});
-const readonlyProxyHandler = new ObjectReactiveHandler({
-    shallow: true,
-    readonly: true
-});
-function reactive(raw) {
-    if (isReactive(raw)) {
-        return raw;
-    }
-    let proxy = rawToProxyCache.get(raw);
-    if (proxy) {
-        return proxy;
-    }
-    const type = getStringType(raw);
-    switch (type) {
-        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;
-}
-
-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;
-}
-const refKey = 'ref';
-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;
-}
-const TextAtomType = Symbol('Text');
-const ElementAtomType = Symbol('Element');
-const ComponentAtomType = Symbol('Component');
-
-const componentSetupStack = [];
-const 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 组件管理类，用于管理组件的生命周期，上下文等
- */
-class Component {
-    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 = 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(Object.assign({}, 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++) {
-                    const ref = refs[i];
-                    ref.bind(this.instance);
-                }
-                return () => {
-                    const refs = this.refs;
-                    const length = refs.length;
-                    for (let i = 0; i < length; i++) {
-                        const ref = refs[i];
-                        ref.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++) {
-            const newRef = newRefs[i];
-            newRef.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);
-    }
-}
-
-function Fragment(props) {
-    return () => {
-        return props.children;
-    };
-}
-function jsx(type, props, key) {
-    return JSXNodeFactory.createNode(type, props, key);
-}
-const jsxs = jsx;
-const JSXNodeFactory = {
-    createNode(type, props, key) {
-        return {
-            type,
-            props,
-            key
-        };
-    }
-};
-
-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 === null || prevFn === void 0 ? void 0 : prevFn();
-    });
-    function unWatch() {
-        dep.destroy();
-    }
-    registryComponentDestroyCallback(unWatch);
-    return unWatch;
-}
-
-const injectMap = 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([Object.assign({ provide: params.provide }, props)]);
-        watch(() => {
-            return props.useClass || props.useFactory || props.useValue || props.useExisting;
-        }, () => {
-            Context = createContext([Object.assign({ provide: params.provide }, props)]);
-        });
-        return () => {
-            return jsx(Context, { children: props.children });
-        };
-    };
-}
-/**
- * 通过组件上下文获取 IoC 容器内数据的勾子方法
- */
-function inject(token, notFoundValue = THROW_IF_NOT_FOUND, flags) {
-    const component = getCurrentInstance();
-    const injector = getInjector(component);
-    return injector.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 parentInjector = injectMap.get(instance) || getInjector(instance.parentComponent);
-        const injector = new ReflectiveInjector(parentInjector, [{
-                provide: Injector,
-                useFactory() {
-                    return injector;
-                }
-            }, ...(annotation.providers || [])], annotation.scope);
-        injectMap.set(instance, injector);
-        return componentSetup(props);
-    };
-}
-
-class NativeRenderer {
-}
-
-function withMemo(canUseMemo, render) {
-    return {
-        $useMemo: canUseMemo,
-        $render: render
-    };
-}
-
-const listenerReg = /^on[A-Z]/;
-function createRenderer(component, nativeRenderer, namespace) {
-    let isInit = true;
-    return function render(host) {
-        if (isInit) {
-            isInit = false;
-            const atom = {
-                type: ComponentAtomType,
-                index: 0,
-                nodeType: component.type,
-                jsxNode: component,
-                sibling: null,
-                child: null,
-                nativeNode: null,
-                namespace
-            };
-            componentRender(nativeRenderer, component, atom, {
-                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) {
-    const newTemplate = component.rerender();
-    newAtom.child = createChildChain(newTemplate, nativeRenderer, newAtom.namespace);
-    diff(nativeRenderer, component, newAtom.child, oldChildAtom, context, needMove);
-}
-function deepUpdateByComponentDirtyTree(nativeRenderer, component, needMove) {
-    if (component.dirty) {
-        const canUpdate = component.canUpdate(component.props, component.props);
-        if (canUpdate) {
-            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 = Object.assign({ 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.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);
-        }
-        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[refKey];
-        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 = Object.assign({ 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) {
-    const ns = nativeRenderer.getNameSpace(type, namespace);
-    return createChildChain(children, nativeRenderer, ns);
-}
-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 === refKey) {
-            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);
-        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 === refKey) {
-            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 === refKey) {
-            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 === refKey) {
-            unBindRefs = oldValue;
-            bindRefs = newValue;
-            return;
-        }
-        nativeRenderer.setProperty(nativeNode, key, newValue, isSvg);
-    });
-    if (!updatedChildren) {
-        newAtom.child = oldAtom.child;
-        // reuseElementChildrenView(nativeRenderer, newAtom, context)
-    }
-    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) {
-                binding ? item.bind(nativeNode) : item.unBind(nativeNode);
-            }
-        }
-    }
-}
-
-/**
- * Viewfly 根组件，用于实现组件状态更新事件通知
- */
-class RootComponent extends Component {
-    constructor(factory, refresh) {
-        super(null, factory, {});
-        Object.defineProperty(this, "refresh", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: refresh
-        });
-    }
-    markAsChanged(changedComponent) {
-        this._changed = true;
-        if (changedComponent) {
-            this.changedSubComponents.add(changedComponent);
-        }
-        this.refresh();
-    }
-}
-
-const 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) {
-            var _a, _b;
-            if (isStarted) {
-                throw viewflyErrorFn('application has already started.');
-            }
-            for (const module of modules) {
-                (_a = module.setup) === null || _a === void 0 ? void 0 : _a.call(module, app);
-            }
-            isStarted = true;
-            appHost = host;
-            render(host);
-            for (const module of modules) {
-                (_b = module.onAfterStartup) === null || _b === void 0 ? void 0 : _b.call(module, app);
-            }
-            if (!autoUpdate) {
-                return app;
-            }
-            return app;
-        },
-        render() {
-            if (appHost) {
-                render(appHost);
-            }
-            return app;
-        },
-        destroy() {
-            var _a;
-            destroyed = true;
-            rootComponent.markAsDirtied();
-            app.render();
-            for (const module of modules) {
-                (_a = module.onDestroy) === null || _a === void 0 ? void 0 : _a.call(module);
-            }
-        }
-    };
-    return app;
-}
-
-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) {
-            const b = isContinue(value);
-            if (b === false) {
-                dep.destroy();
-                return false;
-            }
-        }
-        return true;
-    }
-    if (!canListen(value)) {
-        return proxy;
-    }
-    registryComponentDestroyCallback(() => {
-        dep.destroy();
-    });
-    return proxy;
-}
-
-const defaultShallowObjectReactiveHandler = new ObjectReactiveHandler({
-    readonly: false,
-    shallow: true
-});
-const defaultShallowArrayReactiveHandler = new ArrayReactiveHandler({
-    readonly: false,
-    shallow: true
-});
-const defaultShallowMapReactiveHandler = new MapReactiveHandler({
-    readonly: false,
-    shallow: true
-});
-const defaultShallowSetReactiveHandler = new SetReactiveHandler({
-    readonly: false,
-    shallow: true
-});
-function shallowReactive(raw) {
-    if (isReactive(raw)) {
-        return raw;
-    }
-    let proxy = rawToProxyCache.get(raw);
-    if (proxy) {
-        return proxy;
-    }
-    const type = getStringType(raw);
-    switch (type) {
-        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;
-}
-
-/**
- * 组件状态管理器
- * @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 = 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;
-        const listeners = Array.from(subscribers);
-        listeners.forEach(listener => listener.effect());
-    };
-    return signal;
-}
-
-/**
- * 使用派生值，Viewfly 会收集回调函数内同步执行时访问的 Signal，
- * 并在你获取 createDerived 函数返回的 Signal 的值时，自动计算最新的值。
- *
- * @param fn
- * @param isContinue 可选的停止函数，在每次值更新后调用，当返回值为 false 时，将不再监听依赖的变化
- */
-function createDerived(fn, isContinue) {
-    let isStop = false;
-    function canListen(value) {
-        if (isContinue) {
-            const b = isContinue(value);
-            if (b === 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;
-}
-
-/* eslint-enable max-len*/
-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;
-}
-
-exports.ArrayReactiveHandler = ArrayReactiveHandler;
-exports.Component = Component;
-exports.Dep = Dep;
-exports.DynamicRef = DynamicRef;
-exports.ForwardRef = ForwardRef;
-exports.Fragment = Fragment;
-exports.Inject = Inject;
-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.Prop = Prop;
-exports.ReflectiveInjector = ReflectiveInjector;
-exports.RootComponent = RootComponent;
-exports.Scope = Scope;
-exports.Self = Self;
-exports.SetReactiveHandler = SetReactiveHandler;
-exports.SkipSelf = SkipSelf;
-exports.StaticRef = StaticRef;
-exports.THROW_IF_NOT_FOUND = THROW_IF_NOT_FOUND;
-exports.Type = Type;
-exports.comparePropsWithCallbacks = comparePropsWithCallbacks;
-exports.computed = computed;
-exports.createContext = createContext;
-exports.createContextProvider = createContextProvider;
-exports.createDerived = createDerived;
-exports.createDynamicRef = createDynamicRef;
-exports.createEffect = createEffect;
-exports.createRef = createRef;
-exports.createRenderer = createRenderer;
-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.viewfly = viewfly;
-exports.watch = watch;
-exports.withAnnotation = withAnnotation;
-exports.withMemo = withMemo;