@lytjs/component 5.0.1 → 6.4.0

package/dist/index.mjs

@@ -1 +1,1865 @@
-import{shallowReactive as Ce,computed as B,watch as Pe}from"@lytjs/reactivity";import{computed as he,effect as Ee}from"@lytjs/reactivity/signal";import{signal as W}from"@lytjs/reactivity/signal";function U(e){let t={},o=Object.keys(e);for(let n=0;n<o.length;n++){let r=o[n];t[r]=W(e[r])}return t}function S(e){return typeof e=="function"&&e!==null&&"set"in e}function T(e){return new Proxy(e,{get(t,o){if(typeof o=="symbol")return t[o];let n=t[o];return S(n)?n():t[o]},set(t,o,n){if(typeof o=="symbol")return t[o]=n,!0;let r=t[o];return S(r)?r.set(n):t[o]=n,!0},has(t,o){return o in t},ownKeys(t){return Object.keys(t)},getOwnPropertyDescriptor(t,o){if(typeof o=="string"&&o in t)return{configurable:!0,enumerable:!0,get:()=>{let n=t[o];return S(n)?n():n},set:n=>{let r=t[o];S(r)?r.set(n):t[o]=n}}}})}function q(e){let t={},o=Object.keys(e);for(let n=0;n<o.length;n++){let r=o[n],l=e[r];t[r]=S(l)?l():l}return t}function H(e,t){let o=Object.keys(t);for(let n=0;n<o.length;n++){let r=o[n],l=e[r];S(l)&&l.set(t[r])}}function Z(e){if(!e)return;let t=Object.keys(e);for(let o=0;o<t.length;o++){let n=t[o],r=e[n];if(r&&typeof r=="function"&&"dispose"in r)try{r.dispose()}catch(l){}delete e[n]}}import{isPlainObject as G,isFunction as R,isString as J,isBoolean as Q,isNumber as X,isArray as x,isObject as Y}from"@lytjs/common";function ee(e){return e===String?"String":e===Number?"Number":e===Boolean?"Boolean":e===Array?"Array":e===Object?"Object":e===Function?"Function":"unknown"}function L(e){if(!e)return{options:{},keys:[]};if(x(e)){let r={},l=[];for(let s=0;s<e.length;s++){let i=e[s];r[i]={type:null},l.push(i)}return{options:r,keys:l}}let t={},o=[],n=Object.keys(e);for(let r=0;r<n.length;r++){let l=n[r],s=e[l];s==null?t[l]={type:null}:s===String||s===Number||s===Boolean||s===Array||s===Object||s===Function?t[l]={type:s}:G(s)?t[l]={...s}:x(s)?t[l]={type:s}:t[l]={type:null},o.push(l)}return{options:t,keys:o}}function $(e,t,o){let{type:n,required:r,validator:l}=t;if(o==null)return!r;if(n!=null){let s=x(n)?n:[n],i=!1;for(let p=0;p<s.length;p++){let a=s[p],c=!1;if(a===String?c=J(o):a===Number?c=X(o):a===Boolean?c=Q(o):a===Function?c=R(o):a===Array?c=x(o):a===Object&&(c=Y(o)),c){i=!0;break}}if(!i){let p=s.map(ee).join(" | ");return!1}}if(l&&R(l))try{if(!l(o))return!1}catch(s){return!1}return!0}function z(e,t){let{default:o}=e;if(o!==void 0){if(R(o)){let n=e.type;if(!(n===Function||x(n)&&n.indexOf(Function)!==-1))return o()}return o}}function C(e,t){let{options:o,keys:n}=e.propsOptions,r={};for(let l=0;l<n.length;l++){let s=n[l],i=o[s],p=t?t[s]:void 0;p===void 0&&(p=z(i,s)),i.type!==null&&i.type!==void 0&&(x(i.type)?i.type:[i.type]).indexOf(Boolean)!==-1&&p===void 0&&(p=!1),$(s,i,p),r[s]=p}return e.props=r,r}import{isFunction as F,isArray as te}from"@lytjs/common";function oe(e){return e}function P(e){return e.replace(/([A-Z])/g,"-$1").toLowerCase()}function ne(e){return e.replace(/-(\w)/g,(t,o)=>o.toUpperCase())}function v(e){if(!e)return{keys:[],validators:{}};let t=[],o={};if(te(e)){for(let r=0;r<e.length;r++){let l=P(e[r]);t.push(l),o[l]=null}return{keys:t,validators:o}}let n=Object.keys(e);for(let r=0;r<n.length;r++){let l=n[r],s=P(l),i=e[l];t.push(s),F(i)?o[s]=i:o[s]=null}return{keys:t,validators:o}}function M(e,t,...o){let n=P(t),r=e.emitsOptions;if(r&&r.keys.length>0){let a=r.keys.indexOf(n)!==-1,c=r.validators[n];if(F(c))try{if(!c(...o))return!1}catch(f){return!1}}let l="on"+n.charAt(0).toUpperCase()+n.slice(1),s=l.replace(/-([a-z])/g,(a,c)=>c.toUpperCase()),i=e.props||{},p=i[s]||i[l];return F(p)?(p(...o),!0):!1}var w=(s=>(s.INIT="init",s.MOUNTED="mounted",s.BEFORE_UPDATE="beforeUpdate",s.UPDATED="updated",s.BEFORE_UNMOUNT="beforeUnmount",s.UNMOUNTED="unmounted",s))(w||{}),h=null;function re(e){return typeof e=="function"}function E(e){let t=h;return h=e,t}function g(e){return function(o,n){if(!re(o))return;let r=n||h;r&&(r[e]||(r[e]=[]),r[e].push(o))}}function d(e,t,...o){let n=e[t];if(!(!n||n.length===0))for(let r=0;r<n.length;r++)try{n[r](...o)}catch(l){}}var se=g("init"),ie=g("mounted"),le=g("beforeUpdate"),pe=g("updated"),ae=g("beforeUnmount"),ce=g("unmounted");import{isFunction as j,isPlainObject as ue}from"@lytjs/common";function k(e){return e==null?null:j(e)?e:Array.isArray(e)?e.length>0?e:null:e}function D(e,t){let o={};if(t==null)return e.slots=o,o;if(j(t)||Array.isArray(t))return o.default=k(t),e.slots=o,o;if(ue(t)){let n=Object.keys(t);for(let r=0;r<n.length;r++){let l=n[r],s=t[l];s!==void 0&&(o[l]=k(s))}return e.slots=o,o}return o.default=k(t),e.slots=o,o}function fe(e,t="default",o){let n=e[t];return n==null?null:j(n)?n(o):n}function ye(e,t="default"){let o=e[t];return o!=null}var u=null;function de(e){if(u){let t=u._lifecycleHooks||(u._lifecycleHooks={});(t.mounted||(t.mounted=[])).push(e)}}function me(e){if(u){let t=u._lifecycleHooks||(u._lifecycleHooks={});(t.unmounted||(t.unmounted=[])).push(e)}}function ge(e){if(u){let t=u._lifecycleHooks||(u._lifecycleHooks={});(t.updated||(t.updated=[])).push(e)}}function Se(e){if(u){let t=u._lifecycleHooks||(u._lifecycleHooks={});(t.beforeMount||(t.beforeMount=[])).push(e)}}function xe(e){if(u){let t=u._lifecycleHooks||(u._lifecycleHooks={});(t.beforeUnmount||(t.beforeUnmount=[])).push(e)}}var I=new WeakMap;function be(e,t){if(u){let o=I.get(u);o||(o=new Map,I.set(u,o)),o.set(e,t)}}function ke(e,t){if(u){let o=u;for(;o;){let n=I.get(o);if(n&&n.has(e))return n.get(e);o=o._parent}}return t}function _(e,t,o,n){u=t;try{return e(o,n)}finally{let r=t._lifecycleHooks||(t._lifecycleHooks={});(r.unmounted||(r.unmounted=[])).push(()=>{I.delete(t)}),u=null}}function Oe(){return u}import{isFunction as m,isPlainObject as N,mergeObjects as Ie}from"@lytjs/common";function Ne(e){return{name:e.name,options:e,_isComponentDefine:!0}}function Ue(e){return{options:e,_isComponentDefine:!0}}function Te(e){let t=e.options,o=L(t.props),n=v(t.emits),r={_isComponent:!0,type:t,name:e.name||t.name,propsOptions:o,emitsOptions:n,props:{},state:{},setupState:{},computedRefs:{},subTree:null,isMounted:!1,isUnmounted:!1,slots:{},watchStopHandles:[],renderProxy:null,emit:null};return r.emit=(l,...s)=>M(r,l,...s),r.renderProxy=He(r),r}function He(e){return{get $name(){return e.name},get $props(){return e.props},get $state(){return e.state},get $slots(){return e.slots},get $isMounted(){return e.isMounted},$emit:e.emit,$forceUpdate(){e.update&&e.update()},$unmount(){K(e)},$setState(o){e._signalState?H(e._signalState,o):Ie(e.state,o),e.update&&e.update()}}}function Re(e,t,o){C(e,t||null),D(e,o||null);let n=e.type;m(n)&&!n._isComponentDefine?V(e):A(e)}function A(e){let{type:t}=e,o=t.reactivityMode==="signal",n=E(e);try{if(m(t.setup)){let s={attrs:e.props,slots:e.slots,emit:e.emit},i=_(t.setup,e,e.props,s);if(m(i))t.render=i;else if(N(i)){e.setupState={...i};let p=Object.keys(i);for(let a=0;a<p.length;a++)Object.defineProperty(e.renderProxy,p[a],{get(){return e.setupState[p[a]]},set(c){e.setupState[p[a]]=c},enumerable:!0})}}if(m(t.state)){let s=t.state();if(N(s))if(o){let i=U(s);e._signalState=i,e.state=T(i)}else e.state=Ce({...s})}if(t.computed){let s=Object.keys(t.computed);for(let i=0;i<s.length;i++){let p=s[i],a=t.computed[p],c=typeof a=="function"?()=>a.call(e.renderProxy):()=>a.get.call(e.renderProxy),f=typeof a=="function"?void 0:b=>a.set.call(e.renderProxy,b),y;o?y=he(c):f?y=B({get:c,set:f}):y=B(c),e.computedRefs[p]=y}}let r=t.methods;if(N(r)){let s=Object.keys(r);for(let i=0;i<s.length;i++){let p=s[i],a=r[p];m(a)&&(e.renderProxy[p]=a.bind(e.renderProxy))}}if(m(t.init)){let s=t.init.call(e.renderProxy,e.props,e.state);if(N(s)){e.setupState={...e.setupState,...s};let i=Object.keys(s);for(let p=0;p<i.length;p++)Object.defineProperty(e.renderProxy,i[p],{get(){return e.setupState[i[p]]},set(a){e.setupState[i[p]]=a},enumerable:!0})}}let l=Object.keys(e.state);for(let s=0;s<l.length;s++){let i=l[s];Object.defineProperty(e.renderProxy,i,{get(){return e.state[i]},set(p){e.state[i]=p},enumerable:!0})}if(t.computed){let s=Object.keys(t.computed);for(let i=0;i<s.length;i++){let p=s[i],a=e.computedRefs[p];o?Object.defineProperty(e.renderProxy,p,{get(){return a()},enumerable:!0}):Object.defineProperty(e.renderProxy,p,{get(){return a.value},set(c){a.value=c},enumerable:!0})}}if(t.watch){let s=Object.keys(t.watch);for(let i=0;i<s.length;i++){let p=s[i],a=t.watch[p],c=()=>{let f=e.state[p];if(f!==void 0)return f;let y=e.props[p];return y!==void 0?y:e.renderProxy[p]};if(o){let f=Ee(y=>{let b=c();a.handler.call(e.renderProxy,b,void 0)});e.watchStopHandles.push(f)}else{let f=Pe(c,(y,b)=>{a.handler.call(e.renderProxy,y,b)},{immediate:!!a.immediate,deep:!!a.deep});e.watchStopHandles.push(f)}}}d(e,"init")}finally{E(n)}}function V(e){let t=e.type,o={slots:e.slots,emit:e.emit},n=t(e.props,o);e.subTree=n}function O(e,t){let o=e._lifecycleHooks;if(!o||!o[t])return;let n=o[t];for(let r=0;r<n.length;r++)try{n[r]()}catch(l){}}function Le(e,t){if(e.isMounted)return;O(e,"beforeMount");let{type:o}=e;m(o.render)&&t&&(e.subTree=o.render.call(e.renderProxy,t,e)),e.isMounted=!0,d(e,"mounted"),O(e,"mounted")}function Fe(e,t,o){if(e.isUnmounted)return;o&&C(e,o),d(e,"beforeUpdate");let{type:n}=e;m(n.render)&&t&&(e.subTree=n.render.call(e.renderProxy,t,e)),d(e,"updated"),O(e,"updated")}function K(e){if(e.isUnmounted)return;d(e,"beforeUnmount"),O(e,"beforeUnmount"),e.isUnmounted=!0,e.isMounted=!1,e.subTree=null;for(let o of e.watchStopHandles)o();e.watchStopHandles=[],d(e,"unmounted"),O(e,"unmounted");let t=["init","mounted","beforeUpdate","updated","beforeUnmount","unmounted"];for(let o=0;o<t.length;o++)e[t[o]]=void 0;e._lifecycleHooks=void 0}export{w as LifecycleHook,d as callLifecycleHook,P as camelizeToHyphen,Se as compositionOnBeforeMount,xe as compositionOnBeforeUnmount,de as compositionOnMounted,me as compositionOnUnmounted,ge as compositionOnUpdated,Te as createComponentInstance,g as createLifecycleHook,U as createSignalState,T as createSignalStateProxy,h as currentInstance,Ne as defineComponent,oe as defineEmits,Ue as defineFunctionalComponent,Z as disposeSignalState,M as emit,Oe as getCurrentInstance,z as getPropDefaultValue,q as getSignalStateSnapshot,ye as hasSlot,ne as hyphenToCamel,C as initProps,D as initSlots,ke as inject,Le as mountComponent,v as normalizeEmits,L as normalizePropsOptions,k as normalizeSlotValue,ae as onBeforeUnmount,le as onBeforeUpdate,se as onInit,ie as onMounted,ce as onUnmounted,pe as onUpdated,H as patchSignalState,be as provide,fe as renderSlot,_ as runSetup,E as setCurrentInstance,Re as setupComponent,V as setupFunctionComponent,A as setupStatefulComponent,K as unmountComponent,Fe as updateComponent,$ as validateProp};
+import { EMPTY_OBJ, isArray, hasOwn, isFunction, isString, isNumber, isBoolean, isObject, isNullish, NOOP, isPromise } from '@lytjs/common-is';
+import { warn, error } from '@lytjs/common-error';
+import { kebabToCamel } from '@lytjs/common-string';
+import { reactive, computed, watch, ref, signal, computedSignal, effectScope } from '@lytjs/reactivity';
+import { nextTick } from '@lytjs/common-scheduler';
+import { createCommentVNode, ShapeFlags, createVNode, registerSuspenseLinker } from '@lytjs/vdom';
+import { createBaseVNode, ShapeFlags as ShapeFlags$1, Fragment, Text } from '@lytjs/common-vnode';
+
+// src/component-setup.ts
+function normalizePropsOptions(rawProps) {
+  if (!rawProps) return EMPTY_OBJ;
+  if (isArray(rawProps)) {
+    const result2 = {};
+    for (let i = 0; i < rawProps.length; i++) {
+      const key = rawProps[i];
+      result2[key] = {};
+    }
+    return result2;
+  }
+  const result = {};
+  for (const key in rawProps) {
+    if (hasOwn(rawProps, key)) {
+      const value = rawProps[key];
+      result[key] = isFunction(value) || isArray(value) ? { type: value } : value;
+    }
+  }
+  return result;
+}
+function resolvePropValue(propOptions, value, _instance, key) {
+  const { type, default: defaultValue, required, validator } = propOptions;
+  if (value === void 0) {
+    if (defaultValue !== void 0) {
+      let def;
+      if (isFunction(defaultValue)) {
+        try {
+          def = defaultValue();
+        } catch (e) {
+          def = void 0;
+        }
+      } else {
+        def = defaultValue;
+      }
+      return def;
+    }
+    if (type === Boolean || isArray(type) && type.includes(Boolean)) {
+      return false;
+    }
+    return void 0;
+  }
+  return value;
+}
+function validateType(value, type, key) {
+  if (type === null || type === void 0) return true;
+  getTypeName(value);
+  if (isArray(type)) {
+    for (let i = 0; i < type.length; i++) {
+      if (checkType(value, type[i])) return true;
+    }
+    type.map((t) => getTypeName(t)).join(" | ");
+  } else {
+    if (checkType(value, type)) return true;
+    getTypeName(type);
+  }
+  return false;
+}
+function checkType(value, type) {
+  if (type === String) return isString(value);
+  if (type === Number) return isNumber(value);
+  if (type === Boolean) return isBoolean(value);
+  if (type === Object) return isObject(value) && !isArray(value);
+  if (type === Array) return isArray(value);
+  if (type === Function) return isFunction(value);
+  return false;
+}
+function getTypeName(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (isArray(value)) return "Array";
+  if (isString(value)) return "String";
+  if (isNumber(value)) return "Number";
+  if (isBoolean(value)) return "Boolean";
+  if (isFunction(value)) return "Function";
+  if (isObject(value)) return "Object";
+  return String(value);
+}
+var currentInstance = null;
+function setCurrentInstance(instance) {
+  currentInstance = instance;
+}
+function getCurrentInstance() {
+  return currentInstance;
+}
+function registerLifecycleHook(instance, hookName, fn) {
+  if (instance) {
+    instance.lifecycle[hookName].add(fn);
+  }
+}
+function onMounted(fn) {
+  if (currentInstance) {
+    registerLifecycleHook(currentInstance, "mounted", fn);
+  }
+}
+function onUpdated(fn) {
+  if (currentInstance) {
+    registerLifecycleHook(currentInstance, "updated", fn);
+  }
+}
+function onUnmounted(fn) {
+  if (currentInstance) {
+    registerLifecycleHook(currentInstance, "unmounted", fn);
+  }
+}
+function onBeforeMount(fn) {
+  if (currentInstance) {
+    registerLifecycleHook(currentInstance, "beforeMount", fn);
+  }
+}
+function onBeforeUpdate(fn) {
+  if (currentInstance) {
+    registerLifecycleHook(currentInstance, "beforeUpdate", fn);
+  }
+}
+function onBeforeUnmount(fn) {
+  if (currentInstance) {
+    registerLifecycleHook(currentInstance, "beforeUnmount", fn);
+  }
+}
+function onErrorCaptured(fn) {
+  if (currentInstance) {
+    if (!currentInstance.errorCapturedHooks) {
+      currentInstance.errorCapturedHooks = [];
+    }
+    currentInstance.errorCapturedHooks.push(fn);
+  }
+}
+function onActivated(fn) {
+  if (currentInstance) {
+    if (!currentInstance.activatedHooks) {
+      currentInstance.activatedHooks = [];
+    }
+    currentInstance.activatedHooks.push(fn);
+  }
+}
+function onDeactivated(fn) {
+  if (currentInstance) {
+    if (!currentInstance.deactivatedHooks) {
+      currentInstance.deactivatedHooks = [];
+    }
+    currentInstance.deactivatedHooks.push(fn);
+  }
+}
+function onRenderTracked(fn) {
+}
+function onRenderTriggered(fn) {
+}
+function callOptionsHook(instance, hook, name) {
+  if (hook) {
+    try {
+      hook.call(instance.ctx);
+    } catch (err) {
+      handleError(err, instance, `${name} hook`);
+    }
+  }
+}
+function callLifecycleHook(instance, hookName) {
+  const hooks = instance.lifecycle[hookName];
+  if (hooks.size > 0) {
+    for (const hook of hooks) {
+      try {
+        hook();
+      } catch (err) {
+        handleError(err, instance, hookName);
+      }
+    }
+  }
+}
+function callCreatedHook(instance) {
+  const { beforeCreate, created } = instance.type;
+  callOptionsHook(instance, beforeCreate, "beforeCreate");
+  callOptionsHook(instance, created, "created");
+}
+function callMountedHook(instance) {
+  const { beforeMount, mounted } = instance.type;
+  callLifecycleHook(instance, "beforeMount");
+  callOptionsHook(instance, beforeMount, "beforeMount");
+  callLifecycleHook(instance, "mounted");
+  callOptionsHook(instance, mounted, "mounted");
+  instance.isMounted = true;
+}
+function callUpdatedHook(instance) {
+  const { beforeUpdate, updated } = instance.type;
+  callLifecycleHook(instance, "beforeUpdate");
+  callOptionsHook(instance, beforeUpdate, "beforeUpdate");
+  callLifecycleHook(instance, "updated");
+  callOptionsHook(instance, updated, "updated");
+}
+function callUnmountedHook(instance) {
+  const { beforeUnmount, unmounted } = instance.type;
+  callLifecycleHook(instance, "beforeUnmount");
+  callOptionsHook(instance, beforeUnmount, "beforeUnmount");
+  callLifecycleHook(instance, "unmounted");
+  callOptionsHook(instance, unmounted, "unmounted");
+  instance.isUnmounted = true;
+}
+function handleError(err, instance, info) {
+  let current = instance;
+  while (current) {
+    const hooks = current.errorCapturedHooks;
+    if (hooks && hooks.length > 0) {
+      for (const hook of hooks) {
+        const result = hook(err, current, info);
+        if (result === false) return true;
+      }
+    }
+    const errorHandler = current.type.errorCaptured;
+    if (errorHandler) {
+      const result = errorHandler.call(
+        current.ctx,
+        err,
+        current,
+        info
+      );
+      if (result === false) return true;
+    }
+    current = current.parent;
+  }
+  if (instance) {
+    const appErrorHandler = instance.root.appContext?.config?.errorHandler;
+    if (typeof appErrorHandler === "function") {
+      const publicInstance = instance.ctx ? instance.ctx : null;
+      appErrorHandler(err, publicInstance, info);
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/emit.ts
+function normalizeEmitsOptions(emits) {
+  if (!emits) return null;
+  if (isArray(emits)) {
+    const result = {};
+    for (let i = 0; i < emits.length; i++) {
+      const key = emits[i];
+      result[key] = null;
+    }
+    return result;
+  }
+  return emits;
+}
+function normalizeEventName(event) {
+  return kebabToCamel(event);
+}
+function toHandlerKey(event) {
+  if (!event) return "";
+  const camelized = normalizeEventName(event);
+  return `on${camelized[0].toUpperCase()}${camelized.slice(1)}`;
+}
+function emit(instance, event, ...args) {
+  if (instance.isUnmounted) return;
+  const handlerName = toHandlerKey(event);
+  const handler = instance.props[handlerName] ?? instance.attrs[handlerName];
+  if (isFunction(handler)) {
+    try {
+      handler(...args);
+    } catch (err) {
+      handleError(err, instance, `event handler for "${event}"`);
+    }
+  }
+}
+function isEmitValid(instance, event) {
+  if (!instance.emitsOptions) return true;
+  const normalized = normalizeEventName(event);
+  return hasOwn(instance.emitsOptions, normalized) || hasOwn(instance.emitsOptions, event);
+}
+function initSlots(instance, children) {
+  if (isNullish(children)) {
+    instance.slots = {};
+    return;
+  }
+  const slots = {};
+  if (isFunction(children)) {
+    slots.default = children;
+  } else if (isObject(children) && !isArray(children)) {
+    const slotObj = children;
+    for (const key in slotObj) {
+      if (isFunction(slotObj[key])) {
+        slots[key] = slotObj[key];
+      }
+    }
+  }
+  instance.slots = slots;
+}
+function normalizeSlotValue(value) {
+  if (isNullish(value)) return [];
+  if (isArray(value)) return value;
+  if (value.__v_isVNode === true) {
+    return [value];
+  }
+  return [value];
+}
+function defineComponent(options) {
+  return options;
+}
+function defineFunctionalComponent(render, props) {
+  return {
+    name: "FunctionalComponent",
+    props: props ?? {},
+    setup(_props) {
+      return render;
+    },
+    // 标记为函数式组件
+    __isFunctional: true
+  };
+}
+function mergeOptions(options, seen = /* @__PURE__ */ new WeakSet(), path = [], pathLength = 0) {
+  if (seen.has(options)) {
+    return { ...options };
+  }
+  seen.add(options);
+  path[pathLength] = options;
+  let merged = { ...options };
+  if (options.extends) {
+    merged = mergeOptionsPair(mergeOptions(options.extends, seen, path, pathLength + 1), merged);
+  }
+  if (options.mixins) {
+    for (const mixin of options.mixins) {
+      merged = mergeOptionsPair(merged, mergeOptions(mixin, seen, path, pathLength + 1));
+    }
+  }
+  return merged;
+}
+function mergeOptionsPair(parent, child) {
+  const merged = { ...parent };
+  for (const key in child) {
+    if (key === "props" || key === "emits" || key === "inject") {
+      const parentVal = parent[key];
+      const childVal = child[key];
+      if (parentVal && childVal) {
+        merged[key] = { ...parentVal, ...childVal };
+      } else if (childVal) {
+        merged[key] = childVal;
+      }
+    } else if (key === "data" || key === "provide") {
+      const parentVal = parent[key];
+      const childVal = child[key];
+      if (parentVal && childVal) {
+        merged[key] = function() {
+          const parentData = isFunction(parentVal) ? parentVal.call(this) : parentVal;
+          const childData = isFunction(childVal) ? childVal.call(this) : childVal;
+          return {
+            ...parentData,
+            ...childData
+          };
+        };
+      } else if (childVal) {
+        merged[key] = childVal;
+      }
+    } else if (key === "computed" || key === "methods" || key === "watch") {
+      const parentVal = parent[key];
+      const childVal = child[key];
+      if (parentVal && childVal) {
+        merged[key] = { ...parentVal, ...childVal };
+      } else if (childVal) {
+        merged[key] = childVal;
+      }
+    } else if (key === "beforeCreate" || key === "created" || key === "beforeMount" || key === "mounted" || key === "beforeUpdate" || key === "updated" || key === "beforeUnmount" || key === "unmounted") {
+      const parentVal = parent[key];
+      const childVal = child[key];
+      if (parentVal && childVal) {
+        merged[key] = function() {
+          parentVal.call(this);
+          childVal.call(this);
+        };
+      } else if (childVal) {
+        merged[key] = childVal;
+      }
+    } else if (key === "mixins" || key === "extends") ; else if (hasOwn(child, key)) {
+      merged[key] = child[key];
+    }
+  }
+  return merged;
+}
+function createAppContext() {
+  return {
+    config: {},
+    components: {},
+    directives: {},
+    mixins: [],
+    provides: /* @__PURE__ */ Object.create(null)
+  };
+}
+var PUBLIC_PROPERTIES_MAP = {
+  $: 1,
+  $el: 2,
+  $data: 4,
+  $props: 8,
+  $attrs: 16,
+  $slots: 32,
+  $refs: 64,
+  $parent: 128,
+  $root: 256,
+  $emit: 512,
+  $options: 1024,
+  $forceUpdate: 2048,
+  $nextTick: 4096,
+  $watch: 8192
+};
+function createComponentPublicInstance(instance) {
+  if (!instance.accessCache) {
+    instance.accessCache = /* @__PURE__ */ Object.create(null);
+  }
+  const PublicInstanceProxyHandlers = {
+    get(target, key) {
+      if (typeof key === "symbol") {
+        if (key in target) {
+          const res = target[key];
+          if (typeof res === "function" && key !== Symbol.toPrimitive && key !== Symbol.iterator) {
+            return res.bind(target);
+          }
+          return res;
+        }
+        return void 0;
+      }
+      const cachedValue = instance.accessCache[key];
+      if (cachedValue !== void 0) {
+        switch (cachedValue) {
+          case 32 /* CONTEXT */: {
+            const res = target[key];
+            if (typeof res === "function" && key !== "$emit") {
+              return res.bind(target);
+            }
+            return res;
+          }
+          case 1 /* OTHER */:
+            return void 0;
+          case 2 /* SETUP_STATE */:
+            return instance.setupState[key];
+          case 4 /* DATA */:
+            return instance.data[key];
+          case 8 /* PROPS */:
+            return instance.props[key];
+          case 16 /* GLOBAL_PROPERTIES */: {
+            const globalProperties2 = instance.appContext?.config?.globalProperties;
+            return globalProperties2 ? globalProperties2[key] : void 0;
+          }
+        }
+      }
+      if (key in target) {
+        const res = target[key];
+        if (typeof res === "function" && key !== "$emit") {
+          return res.bind(target);
+        }
+        instance.accessCache[key] = 32 /* CONTEXT */;
+        return res;
+      }
+      const globalProperties = instance.appContext?.config?.globalProperties;
+      if (globalProperties && hasOwn(globalProperties, key)) {
+        instance.accessCache[key] = 16 /* GLOBAL_PROPERTIES */;
+        return globalProperties[key];
+      }
+      if (hasOwn(instance.setupState, key)) {
+        instance.accessCache[key] = 2 /* SETUP_STATE */;
+        return instance.setupState[key];
+      }
+      if (hasOwn(instance.data, key)) {
+        instance.accessCache[key] = 4 /* DATA */;
+        return instance.data[key];
+      }
+      if (hasOwn(instance.props, key)) {
+        instance.accessCache[key] = 8 /* PROPS */;
+        return instance.props[key];
+      }
+      instance.accessCache[key] = 1 /* OTHER */;
+      return void 0;
+    },
+    set(_target, key, value) {
+      if (typeof key === "symbol") {
+        if (key === Symbol.toPrimitive || key === Symbol.iterator) {
+          return false;
+        }
+        _target[key] = value;
+        return true;
+      }
+      if (hasOwn(instance.setupState, key)) {
+        instance.setupState[key] = value;
+        return true;
+      }
+      if (hasOwn(instance.data, key)) {
+        instance.data[key] = value;
+        return true;
+      }
+      return false;
+    },
+    has(_target, key) {
+      if (typeof key === "symbol") {
+        return key in instance.setupState || key in instance.data || key in instance.props || key in _target;
+      }
+      const cachedValue = instance.accessCache[key];
+      if (cachedValue !== void 0) {
+        return cachedValue !== 1 /* OTHER */;
+      }
+      const globalProperties = instance.appContext?.config?.globalProperties;
+      const found = key in instance.setupState || key in instance.data || key in instance.props || (globalProperties ? key in globalProperties : false) || key in _target;
+      instance.accessCache[key] = found ? 32 /* CONTEXT */ : 1 /* OTHER */;
+      return found;
+    }
+  };
+  const ctx = {
+    get $data() {
+      return instance.data;
+    },
+    get $props() {
+      return instance.props;
+    },
+    get $el() {
+      return instance.vnode?.el ?? null;
+    },
+    get $options() {
+      return instance.type;
+    },
+    get $refs() {
+      return instance.refs;
+    },
+    get $slots() {
+      return instance.slots;
+    },
+    $emit: instance.emit,
+    $forceUpdate: () => {
+      if (instance.update) {
+        instance.update();
+      } else if (instance.isMounted && instance.render && !instance.isUnmounted) {
+        nextTick(() => {
+          if (instance.isUnmounted) return;
+          const prevTree = instance.subTree;
+          const nextTree = instance.render(instance.ctx);
+          if (nextTree) {
+            instance.subTree = nextTree;
+            nextTree.el = prevTree?.el ?? null;
+            if (prevTree && "anchor" in prevTree) {
+              nextTree.anchor = prevTree.anchor;
+            }
+            if (prevTree && "ref" in prevTree) {
+              nextTree.ref = prevTree.ref;
+            }
+          }
+        });
+      }
+    },
+    $nextTick: () => nextTick()
+  };
+  return new Proxy(ctx, PublicInstanceProxyHandlers);
+}
+
+// src/component-init.ts
+function normalizeWatchHandler(raw, methods, proxy) {
+  if (typeof raw === "function") {
+    return raw.bind(proxy);
+  }
+  if (typeof raw === "string") {
+    if (methods && hasOwn(methods, raw)) {
+      return methods[raw].bind(proxy);
+    }
+    return null;
+  }
+  if (raw !== null && typeof raw === "object" && typeof raw.handler !== "undefined") {
+    return normalizeWatchHandler(raw.handler, methods, proxy);
+  }
+  return null;
+}
+function finishComponentSetup(instance) {
+  const { type } = instance;
+  try {
+    instance.ctx = createComponentPublicInstance(instance);
+  } catch (err) {
+    handleError(err, instance, "finishComponentSetup (createComponentPublicInstance)");
+    instance.render = () => null;
+    return;
+  }
+  try {
+    if (type.data) {
+      const data = type.data.call(instance.ctx) ?? {};
+      instance.data = reactive(data);
+    }
+  } catch (err) {
+    handleError(err, instance, "finishComponentSetup (data initialization)");
+    instance.render = () => null;
+    return;
+  }
+  const devPropsKeys = null;
+  const proxy = instance.ctx;
+  try {
+    if (type.methods) {
+      for (const key in type.methods) {
+        if (hasOwn(type.methods, key)) {
+          const method = type.methods[key];
+          if (false) ;
+          instance.ctx[key] = method.bind(proxy);
+        }
+      }
+      if (devPropsKeys) ;
+    }
+  } catch (err) {
+    handleError(err, instance, "finishComponentSetup (methods initialization)");
+    instance.render = () => null;
+    return;
+  }
+  try {
+    if (type.computed) {
+      for (const key in type.computed) {
+        if (hasOwn(type.computed, key)) {
+          const opt = type.computed[key];
+          let c;
+          if (typeof opt === "function") {
+            c = computed(() => opt.call(proxy));
+          } else if (opt && typeof opt === "object") {
+            const { get, set } = opt;
+            if (false) ;
+            c = computed({
+              get: get ? () => get.call(proxy) : () => void 0,
+              set: set ? (v) => set.call(proxy, v) : void 0
+            });
+          } else if (false) ;
+          if (false) ;
+          instance.ctx[key] = c;
+        }
+      }
+      if (devPropsKeys) ;
+    }
+  } catch (err) {
+    handleError(err, instance, "finishComponentSetup (computed initialization)");
+    instance.render = () => null;
+    return;
+  }
+  try {
+    if (type.watch) {
+      for (const key in type.watch) {
+        if (hasOwn(type.watch, key)) {
+          const raw = type.watch[key];
+          const handlers = [];
+          if (Array.isArray(raw)) {
+            for (const h of raw) {
+              const normalized = normalizeWatchHandler(h, type.methods, proxy);
+              if (normalized) handlers.push(normalized);
+            }
+          } else {
+            const h = normalizeWatchHandler(raw, type.methods, proxy);
+            if (h) handlers.push(h);
+          }
+          const options = {};
+          if (!Array.isArray(raw) && raw !== null && typeof raw === "object" && typeof raw.handler !== "undefined") {
+            const watchObj = raw;
+            if (typeof watchObj.immediate === "boolean") options.immediate = watchObj.immediate;
+            if (typeof watchObj.deep === "boolean") options.deep = watchObj.deep;
+            if (typeof watchObj.flush === "string")
+              options.flush = watchObj.flush;
+          }
+          for (const handler of handlers) {
+            watch(
+              () => proxy[key],
+              handler,
+              options
+            );
+          }
+        }
+      }
+    }
+  } catch (err) {
+    handleError(err, instance, "finishComponentSetup (watch initialization)");
+    instance.render = () => null;
+    return;
+  }
+  try {
+    callCreatedHook(instance);
+    if (type.renderTracked) {
+      if (!instance.renderTrackedHooks) {
+        instance.renderTrackedHooks = [];
+      }
+      instance.renderTrackedHooks.push(type.renderTracked.bind(proxy));
+    }
+    if (type.renderTriggered) {
+      if (!instance.renderTriggeredHooks) {
+        instance.renderTriggeredHooks = [];
+      }
+      instance.renderTriggeredHooks.push(type.renderTriggered.bind(proxy));
+    }
+  } catch (err) {
+    handleError(err, instance, "finishComponentSetup (lifecycle hooks)");
+    instance.render = () => null;
+    return;
+  }
+  try {
+    if (!instance.render) {
+      if (type.render) {
+        instance.render = type.render.bind(instance.ctx);
+      }
+    }
+  } catch (err) {
+    handleError(err, instance, "finishComponentSetup (render setup)");
+    instance.render = () => null;
+  }
+}
+
+// src/component-setup.ts
+var ASYNC_SETUP_TIMEOUT = 3e4;
+var uid = 0;
+var setupContextCache = /* @__PURE__ */ new WeakMap();
+function createComponentInstance(vnode, parent) {
+  const rawType = vnode.type;
+  if (rawType === null || rawType === void 0 || typeof rawType === "string" || typeof rawType === "number" || typeof rawType === "boolean" || typeof rawType === "symbol") {
+    throw new Error(
+      `[lytjs/component] createComponentInstance: invalid vnode.type "${String(rawType)}". Expected a component options object or function.`
+    );
+  }
+  const type = vnode.type;
+  try {
+    const mergedOptions = mergeOptions(type);
+    const appContext = parent ? parent.appContext : createAppContext();
+    const instance = {
+      uid: uid++,
+      type: mergedOptions,
+      vnode,
+      subTree: null,
+      props: EMPTY_OBJ,
+      slots: {},
+      ctx: {},
+      setupState: {},
+      data: {},
+      propsOptions: normalizePropsOptions(mergedOptions.props),
+      emitsOptions: normalizeEmitsOptions(mergedOptions.emits),
+      emit: NOOP,
+      isMounted: false,
+      isUnmounted: false,
+      isDeactivated: false,
+      isKeepingAlive: false,
+      refs: {},
+      lifecycle: {
+        beforeMount: /* @__PURE__ */ new Set(),
+        mounted: /* @__PURE__ */ new Set(),
+        beforeUpdate: /* @__PURE__ */ new Set(),
+        updated: /* @__PURE__ */ new Set(),
+        beforeUnmount: /* @__PURE__ */ new Set(),
+        unmounted: /* @__PURE__ */ new Set()
+      },
+      provides: parent ? parent.provides : /* @__PURE__ */ Object.create(null),
+      parent,
+      root: null,
+      appContext,
+      attrs: {},
+      accessCache: null
+    };
+    instance.emit = (event, ...args) => emit(instance, event, ...args);
+    instance.root = parent ? parent.root : instance;
+    return instance;
+  } catch (err) {
+    handleError(err, parent, "createComponentInstance");
+    throw err;
+  }
+}
+function setupComponent(instance) {
+  const vnode = instance.vnode;
+  if (!vnode) return;
+  const { children } = vnode;
+  const props = vnode.props ?? null;
+  initProps(instance, props);
+  initSlots(instance, children);
+  const setupResult = runSetup(instance);
+  if (isPromise(setupResult)) {
+    vnode.isAsyncPlaceholder = true;
+    let timeoutId;
+    const timedSetupResult = Promise.race([
+      setupResult,
+      new Promise((_, reject) => {
+        timeoutId = setTimeout(
+          () => reject(new Error("Async component setup timed out")),
+          ASYNC_SETUP_TIMEOUT
+        );
+      })
+    ]);
+    timedSetupResult.then((resolvedResult) => {
+      if (timeoutId !== void 0) {
+        clearTimeout(timeoutId);
+        timeoutId = void 0;
+      }
+      if (instance.isUnmounted) return;
+      handleSetupResult(instance, resolvedResult);
+      vnode.isAsyncPlaceholder = false;
+    }).catch((err) => {
+      if (timeoutId !== void 0) {
+        clearTimeout(timeoutId);
+        timeoutId = void 0;
+      }
+      vnode.isAsyncPlaceholder = false;
+      handleError(err, instance, "setup function");
+    });
+  } else {
+    handleSetupResult(instance, setupResult);
+  }
+}
+function runSetup(instance) {
+  const { setup } = instance.type;
+  if (!setup) return void 0;
+  setCurrentInstance(instance);
+  try {
+    const setupContext = createSetupContext(instance);
+    const result = setup(instance.props, setupContext);
+    return result;
+  } catch (err) {
+    handleError(err, instance, "setup function");
+    instance.render = () => null;
+    return void 0;
+  } finally {
+    setCurrentInstance(null);
+  }
+}
+function handleSetupResult(instance, setupResult) {
+  if (isFunction(setupResult)) {
+    instance.render = setupResult;
+  } else if (isObject(setupResult) && setupResult !== null) {
+    instance.setupState = setupResult;
+  }
+  finishComponentSetup(instance);
+}
+function initProps(instance, rawProps) {
+  const propsOptions = instance.propsOptions;
+  const props = {};
+  if (!rawProps) {
+    instance.props = props;
+    return;
+  }
+  for (const key in propsOptions) {
+    if (hasOwn(propsOptions, key)) {
+      const value = rawProps[key];
+      props[key] = resolvePropValue(propsOptions[key], value);
+    }
+  }
+  const attrs = {};
+  for (const key in rawProps) {
+    if (hasOwn(rawProps, key) && !hasOwn(propsOptions, key)) {
+      attrs[key] = rawProps[key];
+    }
+  }
+  instance.props = props;
+  instance.attrs = attrs;
+}
+function createSetupContext(instance) {
+  const cached = setupContextCache.get(instance);
+  if (cached) {
+    return cached;
+  }
+  const context = {
+    attrs: instance.attrs,
+    slots: instance.slots,
+    emit: instance.emit,
+    expose(exposed) {
+      if (!exposed) {
+        instance.exposed = null;
+        return;
+      }
+      const publicApiKeys = /* @__PURE__ */ new Set([
+        "$data",
+        "$props",
+        "$el",
+        "$emit",
+        "$forceUpdate",
+        "$nextTick",
+        "$slots",
+        "$refs",
+        "$options"
+      ]);
+      const safeExposed = {};
+      for (const key of Object.keys(exposed)) {
+        if (key !== "__proto__" && key !== "constructor" && !publicApiKeys.has(key)) {
+          safeExposed[key] = exposed[key];
+        }
+      }
+      instance.exposed = safeExposed;
+    }
+  };
+  setupContextCache.set(instance, context);
+  return context;
+}
+function provide(key, value) {
+  const instance = getCurrentInstance();
+  if (instance) {
+    if (instance.provides === (instance.parent?.provides ?? null)) {
+      instance.provides = Object.create(
+        instance.provides
+      );
+    }
+    instance.provides[key] = value;
+  }
+}
+function inject(key, defaultValue, options) {
+  const instance = getCurrentInstance();
+  if (!instance) {
+    return resolveDefault(defaultValue, options);
+  }
+  const lookupKey = options?.from ?? key;
+  if (options?.local) {
+    const provides = instance.provides;
+    const hasOwnProvides = instance.parent ? provides !== instance.parent.provides : true;
+    if (hasOwnProvides && hasOwn(provides, lookupKey)) {
+      return provides[lookupKey];
+    }
+    return resolveDefault(defaultValue, options);
+  }
+  let current = instance.parent;
+  while (current) {
+    const provides = current.provides;
+    if (lookupKey in provides) {
+      return provides[lookupKey];
+    }
+    current = current.parent;
+  }
+  return resolveDefault(defaultValue, options);
+}
+function resolveDefault(defaultValue, options) {
+  if (defaultValue === void 0) return void 0;
+  if (options?.factory && typeof defaultValue === "function") {
+    return defaultValue();
+  }
+  return defaultValue;
+}
+var LRUCache = class {
+  constructor(maxSize = 10) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxSize = maxSize;
+  }
+  get(key) {
+    const instance = this.cache.get(key);
+    if (instance !== void 0) {
+      this.cache.delete(key);
+      this.cache.set(key, instance);
+    }
+    return instance;
+  }
+  set(key, instance) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    }
+    if (this.cache.size >= this.maxSize) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey !== void 0) {
+        const oldestInstance = this.cache.get(oldestKey);
+        if (oldestInstance) {
+          deactivateInstance(oldestInstance);
+          oldestInstance.effects?.forEach((effect) => {
+            effect.stop();
+          });
+        }
+        this.cache.delete(oldestKey);
+      }
+    }
+    this.cache.set(key, instance);
+  }
+  delete(key) {
+    return this.cache.delete(key);
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  forEach(callback) {
+    this.cache.forEach(callback);
+  }
+  get size() {
+    return this.cache.size;
+  }
+  keys() {
+    return this.cache.keys();
+  }
+  /**
+   * 更新缓存的最大容量
+   */
+  setMaxSize(newMaxSize) {
+    this.maxSize = newMaxSize;
+    while (this.cache.size > this.maxSize) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey !== void 0) {
+        const oldestInstance = this.cache.get(oldestKey);
+        if (oldestInstance) {
+          deactivateInstance(oldestInstance);
+          oldestInstance.effects?.forEach((effect) => {
+            effect.stop();
+          });
+        }
+        this.cache.delete(oldestKey);
+      }
+    }
+  }
+};
+var KeepAlive = {
+  name: "KeepAlive",
+  props: {
+    include: {},
+    exclude: {},
+    max: { type: Number },
+    onCacheKey: { type: Function }
+  },
+  setup(_props, _ctx) {
+    const props = _props;
+    const maxCacheSize = props.max ?? 10;
+    const cache = new LRUCache(maxCacheSize);
+    const _currentVNode = null;
+    watch(
+      () => _props.max,
+      (newMax) => {
+        if (newMax !== void 0 && typeof newMax === "number" && newMax > 0) {
+          cache.setMaxSize(newMax);
+        }
+      }
+    );
+    return {
+      cache,
+      _currentVNode
+    };
+  },
+  render(ctx) {
+    const instance = ctx;
+    const props = instance.props;
+    const defaultSlot = instance.slots?.default;
+    if (!defaultSlot) return createCommentVNode("keep-alive");
+    const children = defaultSlot();
+    if (!children || children.length === 0) return createCommentVNode("keep-alive");
+    const rawVNode = children[0];
+    if (rawVNode == null) return createCommentVNode("keep-alive");
+    if (typeof rawVNode.type === "string" || rawVNode.type === globalThis.__LYTJS_FRAGMENT__ || rawVNode.type === globalThis.__LYTJS_TEXT__ || rawVNode.type === globalThis.__LYTJS_COMMENT__) {
+      return rawVNode;
+    }
+    const compType = rawVNode.type;
+    const compName = typeof compType === "object" && compType !== null && "name" in compType ? compType.name : typeof compType === "function" ? compType.name : void 0;
+    const isIncluded = props.include === void 0 || matchesPattern(compName, props.include);
+    const isExcluded = props.exclude !== void 0 && matchesPattern(compName, props.exclude);
+    if (!isIncluded || isExcluded) {
+      return rawVNode;
+    }
+    const cacheKey = getCacheKey(instance, rawVNode);
+    const cachedInstance = getCachedInstance(instance, cacheKey);
+    if (cachedInstance) {
+      cacheInstance(instance, cacheKey, cachedInstance);
+      rawVNode.component = cachedInstance;
+      rawVNode.shapeFlag |= ShapeFlags.COMPONENT_KEPT_ALIVE;
+      activateInstance(cachedInstance);
+      return rawVNode;
+    }
+    instance.setupState._currentVNode = rawVNode;
+    return rawVNode;
+  },
+  created() {
+  }
+};
+function createKeepAliveInstance(props = {}, parent = null) {
+  const vnode = createVNode(
+    KeepAlive,
+    {
+      ...props,
+      include: props.include,
+      exclude: props.exclude,
+      max: props.max,
+      onCacheKey: props.onCacheKey
+    },
+    null,
+    ShapeFlags.STATEFUL_COMPONENT
+  );
+  const instance = createComponentInstance(vnode, parent);
+  setupComponent(instance);
+  return instance;
+}
+function matchesPattern(name, pattern) {
+  if (!pattern) return true;
+  if (name === void 0) return false;
+  if (isString(pattern)) {
+    return name === pattern;
+  }
+  if (pattern instanceof RegExp) {
+    return pattern.test(name);
+  }
+  if (isArray(pattern)) {
+    return pattern.some((p) => matchesPattern(name, p));
+  }
+  return true;
+}
+function getCacheKey(keepAlive, vnode) {
+  const onCacheKey = keepAlive.props.onCacheKey;
+  if (isFunction(onCacheKey)) {
+    try {
+      return String(onCacheKey(vnode));
+    } catch (e) {
+      handleError(e, keepAlive, "onCacheKey");
+    }
+  }
+  const type = vnode.type;
+  if (typeof type === "string") {
+    return type;
+  }
+  if (type && typeof type === "object" && "name" in type) {
+    return String(type.name) || String(type);
+  }
+  if (typeof type === "function" && "name" in type) {
+    return type.name || String(type);
+  }
+  return String(type);
+}
+function cacheInstance(keepAlive, key, instance) {
+  const cache = keepAlive.setupState.cache;
+  if (cache.has(key)) {
+    cache.delete(key);
+  }
+  cache.set(key, instance);
+}
+function getCachedInstance(keepAlive, key) {
+  const cache = keepAlive.setupState.cache;
+  return cache.get(key);
+}
+function removeCachedInstance(keepAlive, key) {
+  const cache = keepAlive.setupState.cache;
+  return cache.delete(key);
+}
+function activateInstance(instance) {
+  instance.isDeactivated = false;
+  if (instance.type.activated) {
+    instance.type.activated.call(instance.ctx);
+  }
+  if (instance.activatedHooks) {
+    for (const hook of instance.activatedHooks) {
+      try {
+        hook();
+      } catch (e) {
+        handleError(e, instance, "activated hook");
+      }
+    }
+  }
+}
+function deactivateInstance(instance) {
+  instance.isDeactivated = true;
+  if (instance.type.deactivated) {
+    instance.type.deactivated.call(instance.ctx);
+  }
+  if (instance.deactivatedHooks) {
+    for (const hook of instance.deactivatedHooks) {
+      try {
+        hook();
+      } catch (e) {
+        handleError(e, instance, "deactivated hook");
+      }
+    }
+  }
+}
+var _linkerRegistered = false;
+function ensureLinkerRegistered() {
+  if (_linkerRegistered) return;
+  _linkerRegistered = true;
+  registerSuspenseLinker(((asyncState, vnodeBoundary, domSwitch) => {
+    linkSuspenseBoundary(asyncState, vnodeBoundary, domSwitch);
+  }));
+}
+var SuspenseAbortedError = class extends Error {
+  constructor(pendingId) {
+    super(`Suspense boundary (id: ${pendingId}) was aborted`);
+    this.pendingId = pendingId;
+    this.name = "SuspenseAbortedError";
+  }
+};
+var Suspense = {
+  name: "Suspense",
+  props: {
+    timeout: { type: Number, default: void 0 }
+  },
+  setup(_props, _ctx) {
+    ensureLinkerRegistered();
+    const boundary = {
+      isPending: false,
+      error: null,
+      promise: null,
+      pendingPromises: /* @__PURE__ */ new Set(),
+      onResolve: [],
+      onPending: [],
+      onError: [],
+      aborted: false
+    };
+    const props = _props;
+    if (props.onResolve) boundary.onResolve.push(props.onResolve);
+    if (props.onPending) boundary.onPending.push(props.onPending);
+    if (props.onError) boundary.onError.push(props.onError);
+    return {
+      boundary
+    };
+  }
+};
+function createSuspenseInstance(props = {}, parent = null) {
+  const vnode = createBaseVNode({
+    type: Suspense,
+    props: {
+      timeout: props.timeout,
+      onResolve: props.onResolve,
+      onPending: props.onPending,
+      onError: props.onError
+    },
+    shapeFlag: ShapeFlags$1.SUSPENSE | ShapeFlags$1.STATEFUL_COMPONENT
+  });
+  const instance = createComponentInstance(vnode, parent);
+  setupComponent(instance);
+  return instance;
+}
+function createSuspenseBoundary() {
+  return {
+    isPending: false,
+    error: null,
+    promise: null,
+    pendingPromises: /* @__PURE__ */ new Set(),
+    onResolve: [],
+    onPending: [],
+    onError: [],
+    aborted: false
+  };
+}
+function registerAsyncChild(boundary, promise) {
+  if (boundary.aborted) return false;
+  const wasPending = boundary.isPending;
+  boundary.isPending = true;
+  boundary.error = null;
+  boundary.pendingPromises.add(promise);
+  if (!wasPending) {
+    for (const cb of boundary.onPending) {
+      cb();
+    }
+    if (boundary.domSwitch) {
+      const switchFn = boundary.domSwitch;
+      nextTick(() => {
+        if (!boundary.aborted) {
+          switchFn(boundary, true);
+        }
+      });
+    }
+  }
+  promise.then((result) => {
+    if (boundary.aborted) return;
+    boundary.pendingPromises.delete(promise);
+    if (boundary.pendingPromises.size === 0) {
+      boundary.isPending = false;
+      boundary.promise = null;
+      for (const cb of boundary.onResolve) {
+        try {
+          cb();
+        } catch (e) {
+          error(`Error in suspense resolve callback: ${String(e)}`);
+        }
+      }
+      if (boundary.domSwitch) {
+        const switchFn = boundary.domSwitch;
+        nextTick(() => {
+          if (!boundary.aborted) {
+            switchFn(boundary, false);
+          }
+        });
+      }
+    }
+    return result;
+  }).catch((err) => {
+    if (boundary.aborted) return;
+    boundary.pendingPromises.delete(promise);
+    const caughtError = err instanceof Error ? err : new Error(String(err));
+    boundary.error = caughtError;
+    if (boundary.pendingPromises.size === 0) {
+      boundary.isPending = false;
+      boundary.promise = null;
+      for (const cb of boundary.onError) {
+        try {
+          cb(caughtError);
+        } catch (e) {
+          error(`Error in suspense error callback: ${String(e)}`);
+        }
+      }
+    }
+  });
+  return !wasPending;
+}
+function isSuspensePending(boundary) {
+  return boundary.isPending;
+}
+function getSuspenseError(boundary) {
+  return boundary.error;
+}
+function linkSuspenseBoundary(asyncState, vnodeBoundary, domSwitch) {
+  asyncState.vnodeBoundary = vnodeBoundary;
+  asyncState.domSwitch = domSwitch;
+}
+function resolveSuspense(boundary) {
+  boundary.isPending = false;
+  boundary.aborted = true;
+  boundary.promise = null;
+  boundary.error = null;
+  boundary.pendingPromises.clear();
+  for (const cb of boundary.onResolve) {
+    try {
+      cb();
+    } catch (e) {
+      error(`Error in suspense resolve callback: ${String(e)}`);
+    }
+  }
+}
+function abortSuspense(boundary) {
+  boundary.aborted = true;
+  boundary.isPending = false;
+  boundary.promise = null;
+  if (boundary.pendingPromises.size > 0) {
+    const abortError = new SuspenseAbortedError(boundary.pendingPromises.size);
+    boundary.pendingPromises.forEach((promise) => {
+      try {
+        const p = promise;
+        if (typeof p.abort === "function") {
+          p.abort(abortError);
+        }
+      } catch {
+      }
+    });
+    boundary.pendingPromises.clear();
+  }
+  boundary.onResolve.length = 0;
+  boundary.onPending.length = 0;
+  boundary.onError.length = 0;
+}
+
+// src/transition.ts
+var Transition = {
+  name: "Transition",
+  props: {
+    name: { type: String },
+    appear: { type: Boolean, default: false },
+    mode: { type: String, default: "default" },
+    enterFromClass: { type: String },
+    enterActiveClass: { type: String },
+    enterToClass: { type: String },
+    leaveFromClass: { type: String },
+    leaveActiveClass: { type: String },
+    leaveToClass: { type: String },
+    onBeforeEnter: { type: Function },
+    onEnter: { type: Function },
+    onAfterEnter: { type: Function },
+    onEnterCancelled: { type: Function },
+    onBeforeLeave: { type: Function },
+    onLeave: { type: Function },
+    onAfterLeave: { type: Function },
+    onLeaveCancelled: { type: Function }
+  },
+  // FIX: P0-06 移除多余的 IIFE 包装和 as unknown as void 类型欺骗，
+  // 直接返回渲染函数，让组件系统正确识别 setup 返回的渲染函数
+  // FIX: DTS build error - 添加类型断言
+  setup(_props, { slots }) {
+    return (() => slots.default?.());
+  }
+};
+
+// src/transition-group.ts
+var TransitionGroup = {
+  name: "TransitionGroup",
+  props: {
+    name: { type: String },
+    appear: { type: Boolean, default: false },
+    tag: { type: [String, Boolean] },
+    moveClass: { type: String },
+    enterFromClass: { type: String },
+    enterActiveClass: { type: String },
+    enterToClass: { type: String },
+    leaveFromClass: { type: String },
+    leaveActiveClass: { type: String },
+    leaveToClass: { type: String },
+    onBeforeEnter: { type: Function },
+    onEnter: { type: Function },
+    onAfterEnter: { type: Function },
+    onEnterCancelled: { type: Function },
+    onBeforeLeave: { type: Function },
+    onLeave: { type: Function },
+    onAfterLeave: { type: Function },
+    onLeaveCancelled: { type: Function }
+  },
+  // FIX: DTS build error - 添加类型断言
+  setup(_props, { slots }) {
+    return (() => slots.default?.());
+  }
+};
+
+// src/teleport.ts
+var Teleport = {
+  name: "Teleport",
+  // FIX: P1-21 定义正确的 props 类型替代 as any
+  // FIX: DTS build error - 使用 any 避免 PropConstructor 类型不兼容
+  // FIX: DTS build error - props 使用 any 类型
+  props: {
+    to: { type: [String, Object], required: true },
+    disabled: { type: Boolean, default: false }
+  },
+  setup() {
+  }
+};
+var activeErrorBoundaries = /* @__PURE__ */ new Set();
+var globalHandlerInstalled = false;
+function globalUnhandledRejectionHandler(event) {
+  for (const eb of activeErrorBoundaries) {
+    eb.handler(event);
+  }
+}
+function isErrorBoundaryProps(props) {
+  return props !== null && typeof props === "object";
+}
+var ErrorBoundary = {
+  name: "ErrorBoundary",
+  props: {
+    onError: { type: Function },
+    fallback: { type: Object },
+    /** 是否捕获异步 Promise 错误 */
+    capturePromiseRejections: { type: Boolean, default: false }
+  },
+  setup(props) {
+    const error2 = ref(null);
+    const hasError = ref(false);
+    const typedProps = isErrorBoundaryProps(props) ? props : {};
+    onErrorCaptured((err, _instance, info) => {
+      error2.value = err;
+      hasError.value = true;
+      typedProps.onError?.(err, info);
+      return false;
+    });
+    let currentBoundary = null;
+    onMounted(() => {
+      if (typedProps.capturePromiseRejections && typeof window !== "undefined") {
+        currentBoundary = {
+          handler: (event) => {
+            const err = event.reason instanceof Error ? event.reason : new Error(String(event.reason));
+            error2.value = err;
+            hasError.value = true;
+            typedProps.onError?.(
+              err,
+              "unhandledrejection"
+            );
+          }
+        };
+        activeErrorBoundaries.add(currentBoundary);
+        if (!globalHandlerInstalled) {
+          globalHandlerInstalled = true;
+          window.addEventListener("unhandledrejection", globalUnhandledRejectionHandler);
+        }
+      }
+    });
+    onUnmounted(() => {
+      if (currentBoundary) {
+        activeErrorBoundaries.delete(currentBoundary);
+        currentBoundary = null;
+        if (activeErrorBoundaries.size === 0 && globalHandlerInstalled) {
+          globalHandlerInstalled = false;
+          window.removeEventListener("unhandledrejection", globalUnhandledRejectionHandler);
+        }
+      }
+    });
+    const render = (ctx) => {
+      if (hasError.value) {
+        const fallbackSlot = ctx.$slots.fallback;
+        if (fallbackSlot) {
+          const result = fallbackSlot({ error: error2.value });
+          if (!Array.isArray(result)) {
+            return result;
+          }
+          if (result.length > 0) {
+            if (result.length === 1) {
+              return result[0];
+            }
+            return createVNode(Fragment, null, result);
+          }
+        }
+        return createVNode(
+          Text,
+          null,
+          error2.value ? `Error: ${error2.value.message}` : "An error occurred"
+        );
+      }
+      const defaultSlot = ctx.$slots.default;
+      if (defaultSlot) {
+        const result = defaultSlot();
+        if (Array.isArray(result) && result.length > 0) {
+          if (result.length === 1) {
+            return result[0];
+          }
+          return createVNode(Fragment, null, result);
+        }
+      }
+      return createVNode(Text, null, "");
+    };
+    return { error: error2, hasError, render };
+  }
+};
+function createSignalState(initialValue) {
+  return signal(initialValue);
+}
+function createComputedState(getter) {
+  return computedSignal(getter);
+}
+var preloadedComponents = /* @__PURE__ */ new WeakMap();
+var asyncComponentStates = /* @__PURE__ */ new WeakMap();
+function defineAsyncComponent(options) {
+  const normalizedOptions = isFunction(options) ? { loader: options } : options;
+  const {
+    loader,
+    loadingComponent,
+    errorComponent,
+    delay = 200,
+    timeout,
+    // FIX: DTS build error - suspensible 未使�
+    // suspensible = false,
+    onError
+  } = normalizedOptions;
+  let loadPromise = null;
+  function load() {
+    if (preloadedComponents.has(loader)) {
+      return preloadedComponents.get(loader);
+    }
+    if (loadPromise) {
+      return loadPromise;
+    }
+    loadPromise = loader().then((comp) => {
+      const resolvedComponent = comp.default || comp;
+      preloadedComponents.set(loader, Promise.resolve(resolvedComponent));
+      return resolvedComponent;
+    }).catch((err) => {
+      loadPromise = null;
+      const error2 = err instanceof Error ? err : new Error(String(err));
+      if (onError) {
+        onError(error2);
+      }
+      throw error2;
+    });
+    return loadPromise;
+  }
+  function preload() {
+    if (preloadedComponents.has(loader)) {
+      return Promise.resolve();
+    }
+    return load().then(() => {
+    }).catch(() => {
+    });
+  }
+  const AsyncComponentWrapper = {
+    name: "AsyncComponentWrapper",
+    setup(_props, { slots }) {
+      const instance = getCurrentInstance();
+      let state;
+      if (instance && asyncComponentStates.has(instance)) {
+        state = asyncComponentStates.get(instance);
+      } else {
+        state = {
+          loadedComponent: null,
+          error: null,
+          isLoading: false,
+          isLoaded: false,
+          isError: false,
+          loadingPromise: null
+        };
+        if (instance) {
+          asyncComponentStates.set(instance, state);
+        }
+      }
+      if (state.isLoaded && state.loadedComponent) {
+        return () => renderLoadedComponent(state.loadedComponent, slots);
+      }
+      if (state.isError) {
+        return () => errorComponent ? createComponentVNode(errorComponent, { error: state.error }) : createAsyncCommentVNode(" Async component error ");
+      }
+      if (!state.isLoading) {
+        state.isLoading = true;
+        state.loadingPromise = load().then((comp) => {
+          state.loadedComponent = comp;
+          state.isLoaded = true;
+          state.isLoading = false;
+          if (instance) {
+            triggerComponentUpdate(instance);
+          }
+        }).catch((err) => {
+          state.error = err instanceof Error ? err : new Error(String(err));
+          state.isError = true;
+          state.isLoading = false;
+          if (instance) {
+            triggerComponentUpdate(instance);
+          }
+        });
+        if (timeout !== void 0 && timeout > 0) {
+          const timeoutId = setTimeout(() => {
+            if (!state.isLoaded && !state.isError) {
+              state.error = new Error(`Async component loading timed out after ${timeout}ms`);
+              state.isError = true;
+              state.isLoading = false;
+              if (instance) {
+                triggerComponentUpdate(instance);
+              }
+            }
+          }, timeout);
+          onBeforeUnmount(() => {
+            clearTimeout(timeoutId);
+          });
+        }
+      }
+      return () => {
+        if (delay === 0 && state.isLoading && !state.loadedComponent) {
+          return createAsyncCommentVNode(" Async component loading ");
+        }
+        if (loadingComponent) {
+          return createComponentVNode(loadingComponent, {});
+        }
+        return createAsyncCommentVNode(" Async component loading ");
+      };
+    }
+  };
+  return Object.assign(AsyncComponentWrapper, { preload });
+}
+function triggerComponentUpdate(instance) {
+  if (instance.update) {
+    instance.update();
+  }
+}
+function createComponentVNode(component, props) {
+  return createVNode(component, props, null, ShapeFlags.STATEFUL_COMPONENT);
+}
+function createAsyncCommentVNode(text) {
+  return createCommentVNode(text);
+}
+function renderLoadedComponent(component, slots) {
+  return createVNode(component, {}, slots, ShapeFlags.STATEFUL_COMPONENT);
+}
+function preloadComponents(loaders) {
+  return Promise.all(loaders.map((loader) => preloadComponent(loader))).then(() => {
+  });
+}
+function preloadComponent(loader) {
+  if (preloadedComponents.has(loader)) {
+    return Promise.resolve();
+  }
+  return loader().then((comp) => {
+    const resolvedComponent = comp.default || comp;
+    preloadedComponents.set(loader, Promise.resolve(resolvedComponent));
+  }).catch(() => {
+  });
+}
+function isComponentPreloaded(loader) {
+  return preloadedComponents.has(loader);
+}
+function clearPreloadCache(loader) {
+  if (loader) {
+    preloadedComponents.delete(loader);
+  }
+}
+var InjectionToken = class {
+  constructor(description, options) {
+    this.description = description;
+    this.__token = Symbol(description);
+    this.factory = options?.factory;
+    this.lifecycle = options?.lifecycle;
+  }
+  toString() {
+    return `InjectionToken(${this.description})`;
+  }
+};
+function isInjectionToken(value) {
+  return value instanceof InjectionToken;
+}
+var globalProviderRoot = null;
+var currentProviderNode = null;
+function createProviderNode(parent = null) {
+  const node = {
+    id: /* @__PURE__ */ Symbol("provider-node"),
+    parent,
+    children: /* @__PURE__ */ new Set(),
+    providers: /* @__PURE__ */ new Map(),
+    scope: effectScope()
+  };
+  if (parent) {
+    parent.children.add(node);
+  }
+  return node;
+}
+function getProviderRoot() {
+  if (!globalProviderRoot) {
+    globalProviderRoot = createProviderNode();
+  }
+  return globalProviderRoot;
+}
+function enterProviderScope() {
+  const parent = currentProviderNode || getProviderRoot();
+  currentProviderNode = createProviderNode(parent);
+  return currentProviderNode;
+}
+function exitProviderScope() {
+  if (currentProviderNode && currentProviderNode.parent) {
+    currentProviderNode.scope.stop();
+    currentProviderNode.parent.children.delete(currentProviderNode);
+    currentProviderNode = currentProviderNode.parent;
+  }
+}
+function getCurrentProviderNode() {
+  return currentProviderNode;
+}
+var InjectionError = class extends Error {
+  constructor(token, message) {
+    super(`Injection error for token "${String(token)}": ${message}`);
+    this.token = token;
+    this.name = "InjectionError";
+  }
+};
+function provide2(key, valueOrConfig) {
+  const instance = getCurrentInstance();
+  const providerNode = currentProviderNode || (instance ? null : getProviderRoot());
+  const actualKey = isInjectionToken(key) ? key.__token : key;
+  let record;
+  if (isProviderConfig(valueOrConfig)) {
+    const config = valueOrConfig;
+    const lifecycle = config.lifecycle || "singleton";
+    if (config.provide !== void 0) {
+      record = {
+        value: config.provide,
+        lifecycle
+      };
+    } else if (config.useFactory) {
+      record = {
+        value: config.useFactory(),
+        lifecycle
+      };
+    } else if (config.useExisting) {
+      record = {
+        value: () => inject2(config.useExisting),
+        lifecycle
+      };
+    } else {
+      throw new InjectionError(
+        actualKey,
+        "ProviderConfig must have provide, useFactory, or useExisting"
+      );
+    }
+  } else {
+    record = {
+      value: valueOrConfig,
+      lifecycle: "singleton"
+    };
+  }
+  if (instance) {
+    if (instance.provides === (instance.parent?.provides ?? null)) {
+      instance.provides = Object.create(
+        instance.provides
+      );
+    }
+    instance.provides[actualKey] = record.value;
+  } else if (providerNode) {
+    providerNode.providers.set(actualKey, record);
+  }
+}
+function inject2(key, options) {
+  const instance = getCurrentInstance();
+  const providerNode = currentProviderNode;
+  const actualKey = isInjectionToken(key) ? key.__token : key;
+  const lookupKey = actualKey;
+  if (instance) {
+    const result = injectFromInstance(instance, lookupKey, options);
+    if (result !== void 0) {
+      return result;
+    }
+  }
+  if (providerNode) {
+    const result = injectFromProviderNode(providerNode, lookupKey);
+    if (result !== void 0) {
+      return result;
+    }
+  }
+  if (globalProviderRoot) {
+    const result = injectFromProviderNode(globalProviderRoot, lookupKey);
+    if (result !== void 0) {
+      return result;
+    }
+  }
+  if (isInjectionToken(key) && key.factory) {
+    return key.factory();
+  }
+  {
+    throw new InjectionError(actualKey, "No provider found");
+  }
+}
+function injectFromInstance(instance, key, options) {
+  {
+    const provides = instance.provides;
+    if (key in provides) {
+      return provides[key];
+    }
+  }
+  let current = options?.skipSelf ? instance.parent : instance.parent;
+  while (current) {
+    const provides = current.provides;
+    if (key in provides) {
+      return provides[key];
+    }
+    current = current.parent;
+  }
+  return void 0;
+}
+function injectFromProviderNode(node, key, options) {
+  {
+    const record = node.providers.get(key);
+    if (record) {
+      if (typeof record.value === "function" && record.lifecycle === "transient") {
+        return record.value();
+      }
+      return record.value;
+    }
+  }
+  let current = node.parent;
+  while (current) {
+    const record = current.providers.get(key);
+    if (record) {
+      if (typeof record.value === "function" && record.lifecycle === "transient") {
+        return record.value();
+      }
+      return record.value;
+    }
+    current = current.parent;
+  }
+  return void 0;
+}
+function isProviderConfig(value) {
+  return typeof value === "object" && value !== null && ("provide" in value || "useFactory" in value || "useExisting" in value || "lifecycle" in value);
+}
+function provideSingleton(key, factory) {
+  provide2(key, {
+    useFactory: factory,
+    lifecycle: "singleton"
+  });
+}
+function provideScoped(key, factory) {
+  provide2(key, {
+    useFactory: factory,
+    lifecycle: "scoped"
+  });
+}
+function provideTransient(key, factory) {
+  provide2(key, {
+    useFactory: factory,
+    lifecycle: "transient"
+  });
+}
+function provideAll(providers) {
+  for (const provider of providers) {
+    const { provide: key, useValue, useFactory, useExisting, lifecycle } = provider;
+    provide2(key, {
+      provide: useValue,
+      useFactory,
+      useExisting,
+      lifecycle
+    });
+  }
+}
+function withProviderScope(fn) {
+  const node = enterProviderScope();
+  try {
+    return node.scope.run(fn);
+  } finally {
+    exitProviderScope();
+  }
+}
+
+export { ErrorBoundary, InjectionError, InjectionToken, KeepAlive, PUBLIC_PROPERTIES_MAP, Suspense, Teleport, Transition, TransitionGroup, abortSuspense, activateInstance, cacheInstance, callCreatedHook, callLifecycleHook, callMountedHook, callUnmountedHook, callUpdatedHook, clearPreloadCache, createAppContext, createComponentInstance, createComponentPublicInstance, createComputedState, createKeepAliveInstance, createSignalState, createSuspenseBoundary, createSuspenseInstance, deactivateInstance, defineAsyncComponent, defineComponent, defineFunctionalComponent, emit, enterProviderScope, exitProviderScope, finishComponentSetup, getCacheKey, getCachedInstance, getCurrentInstance, getCurrentProviderNode, getProviderRoot, getSuspenseError, handleError, initProps, initSlots, inject, isComponentPreloaded, isEmitValid, isInjectionToken, isSuspensePending, linkSuspenseBoundary, matchesPattern, normalizeEmitsOptions, normalizePropsOptions, normalizeSlotValue, onActivated, onBeforeMount, onBeforeUnmount, onBeforeUpdate, onDeactivated, onErrorCaptured, onMounted, onRenderTracked, onRenderTriggered, onUnmounted, onUpdated, preloadComponent, preloadComponents, provide, provideAll, provideScoped, provideSingleton, provideTransient, registerAsyncChild, removeCachedInstance, resolvePropValue, resolveSuspense, setCurrentInstance, setupComponent, validateType, withProviderScope };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map