@geektech/tsone 0.0.1 → 0.1.0

package/dist/{index-3j2jsdpc.js → index-wv9gyjqt.js}

@@ -1,10 +1,11 @@
 import {
   StyleManager
-} from "./index-dgv88dz4.js";
+} from "./index-8wjswsye.js";
 
 // lib/core/reactive/types.ts
 var IS_REACTIVE = Symbol("is_reactive");
 var IS_READONLY = Symbol("is_readonly");
+var IS_REF = Symbol("is_ref");
 var MUTATING_ARRAY_METHODS = [
   "push",
   "pop",
@@ -62,7 +63,7 @@ class ReactiveSystem {
         }
         this.track(target2, key);
         const value = Reflect.get(target2, key);
-        if (value && typeof value === "object" && !Array.isArray(value)) {
+        if (isObject(value) && !hasReactiveFlag(value, IS_READONLY)) {
           return this.reactive(value);
         }
         return value;
@@ -73,7 +74,7 @@ class ReactiveSystem {
           return false;
         }
         const oldValue = Reflect.get(target2, key);
-        if (value && typeof value === "object" && !Array.isArray(value) && !hasReactiveFlag(value, IS_REACTIVE)) {
+        if (isObject(value) && !hasReactiveFlag(value, IS_REACTIVE) && !hasReactiveFlag(value, IS_READONLY)) {
           value = this.reactive(value);
         }
         const result = Reflect.set(target2, key, value);
@@ -121,6 +122,9 @@ class ReactiveSystem {
             return result;
           };
         }
+        if (isObject(value) && !hasReactiveFlag(value, IS_READONLY)) {
+          return this.reactive(value);
+        }
         return value;
       },
       set: (target2, key, value) => {
@@ -129,7 +133,7 @@ class ReactiveSystem {
           return false;
         }
         const oldValue = Reflect.get(target2, key);
-        if (value && typeof value === "object" && !Array.isArray(value) && !hasReactiveFlag(value, IS_REACTIVE)) {
+        if (isObject(value) && !hasReactiveFlag(value, IS_REACTIVE) && !hasReactiveFlag(value, IS_READONLY)) {
           value = this.reactive(value);
         }
         const result = Reflect.set(target2, key, value);
@@ -171,11 +175,14 @@ class ReactiveSystem {
     }
     const proxy = new Proxy(target, {
       get: (target2, key) => {
-        if (key === IS_REACTIVE || key === IS_READONLY) {
+        if (key === IS_REACTIVE) {
+          return false;
+        }
+        if (key === IS_READONLY) {
           return true;
         }
         const value = Reflect.get(target2, key);
-        if (value && typeof value === "object" && !Array.isArray(value)) {
+        if (isObject(value)) {
           return this.readonly(value);
         }
         return value;
@@ -193,7 +200,7 @@ class ReactiveSystem {
     return proxy;
   }
   effect(fn, options) {
-    const { lazy = false, scheduler } = options || {};
+    const { lazy = false, scheduler, throwOnError = false } = options || {};
     const effectFn = () => {
       if (!effectFn.active) {
         return fn();
@@ -204,6 +211,9 @@ class ReactiveSystem {
         this.activeEffect = effectFn;
         return fn();
       } catch (error) {
+        if (throwOnError) {
+          throw error;
+        }
         console.error("Effect error:", error);
         return;
       } finally {
@@ -310,6 +320,21 @@ function effect(fn, options) {
 function computed(getter) {
   return ReactiveSystem.getInstance().computed(getter);
 }
+function ref(value) {
+  const wrapper = { value };
+  Object.defineProperty(wrapper, IS_REF, {
+    configurable: false,
+    enumerable: false,
+    value: true
+  });
+  return reactive(wrapper);
+}
+function isRef(value) {
+  return isObject(value) && Boolean(Reflect.get(value, IS_REF));
+}
+function unref(value) {
+  return isRef(value) ? value.value : value;
+}
 function stop(effect2) {
   ReactiveSystem.getInstance().stop(effect2);
 }
@@ -320,40 +345,6 @@ function isReadonly(value) {
   return isObject(value) && hasReactiveFlag(value, IS_READONLY);
 }
 
-// lib/core/renderer/props.ts
-function isEventProp(key) {
-  return /^on[A-Z]/.test(key) || /^on[a-z]/.test(key);
-}
-function eventNameFromProp(key) {
-  return key.slice(2).toLowerCase();
-}
-function parseEventName(event) {
-  const [eventName, ...modifiers] = event.split(".");
-  return { eventName, modifiers: new Set(modifiers) };
-}
-function wrapEventHandler(handler, modifiers) {
-  const eventHandler = (event) => {
-    if (modifiers.has("stop")) {
-      event.stopPropagation();
-    }
-    if (modifiers.has("prevent")) {
-      event.preventDefault();
-    }
-    if (modifiers.has("self") && event.currentTarget !== event.target) {
-      return;
-    }
-    if (modifiers.has("once")) {
-      event.currentTarget.removeEventListener(event.type, eventHandler);
-    }
-    handler(event);
-  };
-  return eventHandler;
-}
-function setStyleValue(style, property, value) {
-  const cssProperty = property.includes("-") ? property : property.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
-  style.setProperty(cssProperty, String(value));
-}
-
 // lib/core/vnode.ts
 function isComponentNode(vnode) {
   return typeof vnode === "object" && vnode !== null && "component" in vnode;
@@ -374,6 +365,55 @@ function h(tag, props, children, listeners, key, directions) {
     directions
   };
 }
+function Tag(tag, options = {}) {
+  return {
+    tag,
+    ...options
+  };
+}
+function createElementFactory(tag) {
+  return (options = {}) => Tag(tag, options);
+}
+var Div = createElementFactory("div");
+var Span = createElementFactory("span");
+var P = createElementFactory("p");
+var Button = createElementFactory("button");
+var Input = createElementFactory("input");
+var Section = createElementFactory("section");
+var Main = createElementFactory("main");
+var Header = createElementFactory("header");
+var Footer = createElementFactory("footer");
+var Nav = createElementFactory("nav");
+var Article = createElementFactory("article");
+var Aside = createElementFactory("aside");
+var H1 = createElementFactory("h1");
+var H2 = createElementFactory("h2");
+var H3 = createElementFactory("h3");
+var H4 = createElementFactory("h4");
+var H5 = createElementFactory("h5");
+var H6 = createElementFactory("h6");
+var Strong = createElementFactory("strong");
+var Em = createElementFactory("em");
+var Small = createElementFactory("small");
+var Pre = createElementFactory("pre");
+var Code = createElementFactory("code");
+var Blockquote = createElementFactory("blockquote");
+var Ul = createElementFactory("ul");
+var Ol = createElementFactory("ol");
+var Li = createElementFactory("li");
+var A = createElementFactory("a");
+var Img = createElementFactory("img");
+var Form = createElementFactory("form");
+var Label = createElementFactory("label");
+var Textarea = createElementFactory("textarea");
+var Select = createElementFactory("select");
+var Option = createElementFactory("option");
+var Table = createElementFactory("table");
+var Thead = createElementFactory("thead");
+var Tbody = createElementFactory("tbody");
+var Tr = createElementFactory("tr");
+var Th = createElementFactory("th");
+var Td = createElementFactory("td");
 function createComponent(componentClass, props, children, key, directions) {
   return {
     component: componentClass,
@@ -391,166 +431,236 @@ function slot(name, key, directions) {
     directions
   };
 }
+function each(items, render, key) {
+  return items.map((item, index) => {
+    const vnode = render(item, index);
+    if (typeof vnode === "string") {
+      throw new Error("each render callback must return a VNode");
+    }
+    return { ...vnode, key: key(item, index) };
+  });
+}
 
-// lib/core/renderer.ts
-class RendererContext {
-  strategies;
-  constructor() {
-    this.strategies = [
-      new TextRenderStrategy,
-      new ComponentRenderStrategy,
-      new SlotRenderStrategy,
-      new ElementRenderStrategy
-    ];
+// lib/core/model.ts
+function pathSegments(path) {
+  const segments = path.split(".");
+  if (path.length === 0 || segments.some((segment) => segment.length === 0 || segment === "__proto__" || segment === "prototype" || segment === "constructor")) {
+    throw new Error(`Invalid model path "${path}"`);
   }
-  mount(vnode, context) {
-    return this.findStrategy(vnode).mount(vnode, context);
+  return segments;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOwn(value, key) {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+function modelPath(binding) {
+  return typeof binding === "string" ? binding : binding.path;
+}
+function getModelValue(state, path) {
+  let value = state;
+  for (const segment of pathSegments(path)) {
+    if (!isRecord(value)) {
+      throw new Error(`Invalid model path "${path}"`);
+    }
+    if (!hasOwn(value, segment)) {
+      if (segment in value) {
+        throw new Error(`Invalid model path "${path}"`);
+      }
+      return;
+    }
+    value = value[segment];
   }
-  patch(oldVNode, newVNode, currentNode, context) {
-    const oldStrategy = this.findStrategy(oldVNode);
-    const newStrategy = this.findStrategy(newVNode);
-    if (oldStrategy !== newStrategy) {
-      const nextNode = newStrategy.mount(newVNode, context);
-      currentNode.parentNode?.replaceChild(nextNode, currentNode);
-      oldStrategy.unmount(oldVNode, currentNode, context);
-      return nextNode;
+  return value;
+}
+function setModelValue(state, path, value) {
+  const segments = pathSegments(path);
+  let target = state;
+  for (const segment of segments.slice(0, -1)) {
+    if (!hasOwn(target, segment)) {
+      if (segment in target) {
+        throw new Error(`Invalid model path "${path}"`);
+      }
+      target[segment] = {};
+    } else if (!isRecord(target[segment])) {
+      throw new Error(`Invalid model path "${path}"`);
     }
-    return oldStrategy.patch(oldVNode, newVNode, currentNode, context);
+    const nextTarget = target[segment];
+    if (!isRecord(nextTarget)) {
+      throw new Error(`Invalid model path "${path}"`);
+    }
+    target = nextTarget;
   }
-  unmount(vnode, currentNode, context) {
-    this.findStrategy(vnode).unmount(vnode, currentNode, context);
+  const lastSegment = segments[segments.length - 1];
+  target[lastSegment] = value;
+}
+function displayValue(binding, value) {
+  if (typeof binding !== "string" && binding.format) {
+    return binding.format(value);
   }
-  findStrategy(vnode) {
-    const strategy = this.strategies.find((item) => item.matches(vnode));
-    if (!strategy) {
-      throw new Error("No render strategy found for vnode");
-    }
-    return strategy;
+  return value === undefined || value === null ? "" : String(value);
+}
+function toModelValue(binding, value) {
+  if (typeof binding !== "string" && binding.parse) {
+    return binding.parse(value);
   }
+  return value;
 }
-
-class TextRenderStrategy {
-  matches(vnode) {
-    return typeof vnode === "string";
+function syncControl(element, binding, value) {
+  if (element instanceof HTMLInputElement) {
+    if (element.type === "checkbox") {
+      element.checked = Array.isArray(value) ? value.some((item) => String(item) === element.value) : Boolean(value);
+      return;
+    }
+    if (element.type === "radio") {
+      element.checked = value === element.value;
+      return;
+    }
+    element.value = displayValue(binding, value);
+    return;
   }
-  mount(vnode, context) {
-    return context.templateEngine.parseTemplate(vnode);
+  if (element instanceof HTMLTextAreaElement) {
+    element.value = displayValue(binding, value);
+    return;
   }
-  patch(oldVNode, newVNode, currentNode, context) {
-    if (oldVNode === newVNode) {
-      return currentNode;
+  if (element instanceof HTMLSelectElement) {
+    if (element.multiple) {
+      const selected = Array.isArray(value) ? new Set(value.map(String)) : new Set;
+      for (let index = 0;index < element.options.length; index += 1) {
+        const option = element.options.item(index);
+        if (!option) {
+          continue;
+        }
+        option.selected = selected.has(option.value);
+      }
+      return;
     }
-    const nextNode = this.mount(newVNode, context);
-    currentNode.parentNode?.replaceChild(nextNode, currentNode);
-    return nextNode;
+    element.value = displayValue(binding, value);
   }
-  unmount() {}
 }
-
-class ComponentRenderStrategy {
-  instances = new WeakMap;
-  matches(vnode) {
-    return typeof vnode === "object" && vnode !== null && isComponentNode(vnode);
-  }
-  mount(vnode, context) {
-    const ComponentClass = vnode.component;
-    const instance = new ComponentClass(this.createProps(vnode));
-    if (context.appContext && instance.setAppContext) {
-      instance.setAppContext(context.appContext);
+function controlValue(element, currentValue) {
+  if (element instanceof HTMLInputElement) {
+    if (element.type === "checkbox") {
+      if (Array.isArray(currentValue)) {
+        const values = currentValue.filter((value) => String(value) !== element.value);
+        return element.checked ? [...values, element.value] : values;
+      }
+      return element.checked;
     }
-    if (vnode.emitters) {
-      Object.entries(vnode.emitters).forEach(([eventName, listener]) => {
-        instance.on(eventName, listener);
-      });
+    if (element.type === "radio") {
+      return element.checked ? element.value : currentValue;
     }
-    context.registerChild(instance);
-    const node = instance.mountToNode();
-    this.instances.set(node, instance);
-    return node;
+    return element.value;
   }
-  patch(oldVNode, newVNode, currentNode, context) {
-    const instance = this.instances.get(currentNode);
-    if (instance && oldVNode.component === newVNode.component) {
-      instance.setProps(this.createProps(newVNode));
-      instance.update();
-      const nextNode2 = instance.getElement() ?? currentNode;
-      this.instances.set(nextNode2, instance);
-      return nextNode2;
-    }
-    const nextNode = this.mount(newVNode, context);
-    currentNode.parentNode?.replaceChild(nextNode, currentNode);
-    this.unmount(oldVNode, currentNode);
-    return nextNode;
+  if (element instanceof HTMLTextAreaElement) {
+    return element.value;
   }
-  unmount(_vnode, currentNode) {
-    const instance = this.instances.get(currentNode);
-    if (instance) {
-      instance.unmount();
-      this.instances.delete(currentNode);
+  if (element instanceof HTMLSelectElement) {
+    if (!element.multiple) {
+      return element.value;
     }
+    const values = [];
+    for (let index = 0;index < element.selectedOptions.length; index += 1) {
+      const option = element.selectedOptions.item(index);
+      if (option) {
+        values.push(option.value);
+      }
+    }
+    return values;
   }
-  createProps(vnode) {
-    return {
-      ...vnode.props ?? {},
-      children: vnode.children ?? []
-    };
-  }
+  return;
 }
 
-class SlotRenderStrategy {
-  renderedChildren = new WeakMap;
-  matches(vnode) {
-    return typeof vnode === "object" && vnode !== null && isSlotProvider(vnode);
-  }
-  mount(vnode, context) {
-    const slotContainer = document.createElement("div");
-    slotContainer.setAttribute("data-slot", vnode.props.name);
-    this.mountSlotChildren(slotContainer, this.resolveChildren(vnode, context), context);
-    return slotContainer;
-  }
-  patch(oldVNode, newVNode, currentNode, context) {
-    if (currentNode instanceof HTMLElement) {
-      currentNode.setAttribute("data-slot", newVNode.props.name);
-      this.replaceSlotChildren(currentNode, oldVNode, newVNode, context);
+class ModelBindingController {
+  bindings = new WeakMap;
+  bind(element, binding, state) {
+    if (!this.isSupportedControl(element)) {
+      return;
     }
-    return currentNode;
-  }
-  unmount(_vnode, currentNode, context) {
-    if (!(currentNode instanceof HTMLElement)) {
+    const existing = this.bindings.get(element);
+    if (existing && this.sameBinding(existing, binding)) {
       return;
     }
-    this.unmountSlotChildren(currentNode, context);
-    this.renderedChildren.delete(currentNode);
-  }
-  resolveChildren(vnode, context) {
-    return context.slots[vnode.props.name] ?? vnode.children ?? [];
+    this.cleanup(element);
+    const path = modelPath(binding);
+    const sync = () => syncControl(element, binding, getModelValue(state, path));
+    const eventName = element instanceof HTMLTextAreaElement || element instanceof HTMLInputElement && !["checkbox", "radio"].includes(element.type) ? "input" : "change";
+    const listener = () => {
+      const currentValue = getModelValue(state, path);
+      setModelValue(state, path, toModelValue(binding, controlValue(element, currentValue)));
+    };
+    element.addEventListener(eventName, listener);
+    const effectRef = effect(sync);
+    this.bindings.set(element, {
+      binding,
+      path,
+      parse: typeof binding === "string" ? undefined : binding.parse,
+      format: typeof binding === "string" ? undefined : binding.format,
+      eventName,
+      listener,
+      effect: effectRef
+    });
   }
-  replaceSlotChildren(element, _oldVNode, newVNode, context) {
-    this.unmountSlotChildren(element, context);
-    element.textContent = "";
-    this.mountSlotChildren(element, this.resolveChildren(newVNode, context), context);
+  cleanup(element) {
+    const existing = this.bindings.get(element);
+    if (!existing) {
+      return;
+    }
+    element.removeEventListener(existing.eventName, existing.listener);
+    stop(existing.effect);
+    this.bindings.delete(element);
   }
-  mountSlotChildren(element, children, context) {
-    children.forEach((child) => {
-      element.appendChild(context.renderer.mount(child, context));
-    });
-    this.renderedChildren.set(element, children);
+  isSupportedControl(element) {
+    return element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement || element instanceof HTMLSelectElement;
   }
-  unmountSlotChildren(element, context) {
-    const children = this.renderedChildren.get(element) ?? [];
-    children.forEach((child, index) => {
-      const childNode = element.childNodes[index];
-      if (childNode) {
-        context.renderer.unmount(child, childNode, context);
-      }
-    });
+  sameBinding(record, binding) {
+    if (typeof record.binding === "string" || typeof binding === "string") {
+      return record.binding === binding;
+    }
+    return record.path === binding.path && record.parse === binding.parse && record.format === binding.format;
   }
 }
 
+// lib/core/renderer/props.ts
+function isEventProp(key) {
+  return /^on[A-Z]/.test(key) || /^on[a-z]/.test(key);
+}
+function eventNameFromProp(key) {
+  return key.slice(2).toLowerCase();
+}
+function parseEventName(event) {
+  const [eventName, ...modifiers] = event.split(".");
+  return { eventName, modifiers: new Set(modifiers) };
+}
+function wrapEventHandler(handler, modifiers) {
+  const eventHandler = (event) => {
+    if (modifiers.has("stop")) {
+      event.stopPropagation();
+    }
+    if (modifiers.has("prevent")) {
+      event.preventDefault();
+    }
+    if (modifiers.has("self") && event.currentTarget !== event.target) {
+      return;
+    }
+    if (modifiers.has("once")) {
+      event.currentTarget.removeEventListener(event.type, eventHandler);
+    }
+    handler(event);
+  };
+  return eventHandler;
+}
+function setStyleValue(style, property, value) {
+  const cssProperty = property.includes("-") ? property : property.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+  style.setProperty(cssProperty, String(value));
+}
+
+// lib/core/renderer/element-strategy.ts
 class ElementRenderStrategy {
   listeners = new WeakMap;
   effects = new WeakMap;
-  modelBindings = new WeakMap;
+  modelBindings = new ModelBindingController;
   matches(vnode) {
     return typeof vnode === "object" && vnode !== null && isHTMLNode(vnode);
   }
@@ -560,11 +670,9 @@ class ElementRenderStrategy {
     }
     const element = document.createElement(vnode.tag);
     this.applyProps(element, {}, vnode.props ?? {}, context);
-    this.applyDirections(element, undefined, vnode.directions, context);
     this.updateListeners(element, {}, this.collectListeners(vnode));
-    (vnode.children ?? []).forEach((child) => {
-      element.appendChild(context.renderer.mount(child, context));
-    });
+    this.mountChildren(element, vnode, context);
+    this.applyDirections(element, undefined, vnode.directions, context);
     return element;
   }
   patch(oldVNode, newVNode, currentNode, context) {
@@ -584,9 +692,9 @@ class ElementRenderStrategy {
       return nextNode;
     }
     this.applyProps(currentNode, oldVNode.props ?? {}, newVNode.props ?? {}, context);
-    this.applyDirections(currentNode, oldVNode.directions, newVNode.directions, context);
     this.updateListeners(currentNode, this.collectListeners(oldVNode), this.collectListeners(newVNode));
-    this.updateChildren(currentNode, oldVNode.children ?? [], newVNode.children ?? [], context);
+    this.updateChildren(currentNode, oldVNode, newVNode, context);
+    this.applyDirections(currentNode, oldVNode.directions, newVNode.directions, context);
     return currentNode;
   }
   unmount(vnode, currentNode, context) {
@@ -599,9 +707,20 @@ class ElementRenderStrategy {
       currentNode.removeEventListener(eventName, listener);
     });
     this.listeners.delete(currentNode);
-    this.modelBindings.delete(currentNode);
+    this.modelBindings.cleanup(currentNode);
+    this.unmountChildren(currentNode, vnode, context);
+  }
+  mountChildren(element, vnode, context) {
+    (vnode.children ?? []).forEach((child) => {
+      element.appendChild(context.renderer.mount(child, context));
+    });
+  }
+  updateChildren(element, oldVNode, newVNode, context) {
+    this.updateOrdinaryChildren(element, oldVNode.children ?? [], newVNode.children ?? [], context);
+  }
+  unmountChildren(element, vnode, context) {
     (vnode.children ?? []).forEach((child, index) => {
-      const childNode = currentNode.childNodes[index];
+      const childNode = element.childNodes[index];
       if (childNode) {
         context.renderer.unmount(child, childNode, context);
       }
@@ -656,12 +775,16 @@ class ElementRenderStrategy {
     } else if (oldDirections && "show" in oldDirections) {
       element.style.display = "";
     }
-    if (newDirections?.model) {
-      this.setupTwoWayBinding(element, newDirections.model, context);
+    if (!newDirections?.model) {
+      this.modelBindings.cleanup(element);
+      return;
     }
+    this.modelBindings.bind(element, newDirections.model, context.templateEngine.state);
   }
-  updateChildren(element, oldChildren, newChildren, context) {
-    if (this.hasKeyedChildren(oldChildren, newChildren)) {
+  updateOrdinaryChildren(element, oldChildren, newChildren, context) {
+    this.assertNoDuplicateKeys(oldChildren);
+    this.assertNoDuplicateKeys(newChildren);
+    if (this.hasOnlyKeyedChildren(oldChildren, newChildren)) {
       this.updateKeyedChildren(element, oldChildren, newChildren, context);
       return;
     }
@@ -730,13 +853,26 @@ class ElementRenderStrategy {
       }
     });
   }
-  hasKeyedChildren(oldChildren, newChildren) {
-    return [...oldChildren, ...newChildren].some((child) => this.getVNodeKey(child) !== undefined);
+  hasOnlyKeyedChildren(oldChildren, newChildren) {
+    return [...oldChildren, ...newChildren].every((child) => this.getVNodeKey(child) !== undefined);
   }
-  getVNodeKey(vnode) {
-    if (typeof vnode === "string") {
-      return;
-    }
+  assertNoDuplicateKeys(children) {
+    const keys = new Set;
+    children.forEach((child) => {
+      const key = this.getVNodeKey(child);
+      if (key === undefined) {
+        return;
+      }
+      if (keys.has(key)) {
+        throw new Error(`Duplicate key "${key}"`);
+      }
+      keys.add(key);
+    });
+  }
+  getVNodeKey(vnode) {
+    if (typeof vnode === "string") {
+      return;
+    }
     return vnode.key;
   }
   collectListeners(vnode) {
@@ -780,59 +916,481 @@ class ElementRenderStrategy {
     });
     this.trackEffect(element, effectRef);
   }
-  setupTwoWayBinding(element, modelKey, context) {
-    if (!(element instanceof HTMLInputElement) && !(element instanceof HTMLTextAreaElement) && !(element instanceof HTMLSelectElement)) {
+  trackEffect(element, effectRef) {
+    const effects = this.effects.get(element) ?? new Set;
+    effects.add(effectRef);
+    this.effects.set(element, effects);
+  }
+}
+
+// lib/core/animation/list-animation-controller.ts
+var ENTER_KEYFRAMES = {
+  fade: [{ opacity: 0 }, { opacity: 1 }],
+  "slide-up": [
+    { opacity: 0, transform: "translateY(12px)" },
+    { opacity: 1, transform: "translateY(0)" }
+  ],
+  "slide-down": [
+    { opacity: 0, transform: "translateY(-12px)" },
+    { opacity: 1, transform: "translateY(0)" }
+  ],
+  "slide-left": [
+    { opacity: 0, transform: "translateX(12px)" },
+    { opacity: 1, transform: "translateX(0)" }
+  ],
+  "slide-right": [
+    { opacity: 0, transform: "translateX(-12px)" },
+    { opacity: 1, transform: "translateX(0)" }
+  ],
+  scale: [
+    { opacity: 0, transform: "scale(0.95)" },
+    { opacity: 1, transform: "scale(1)" }
+  ]
+};
+
+class ListAnimationController {
+  runs = new WeakMap;
+  playEnter(element, options) {
+    return this.play(element, options, "enter");
+  }
+  playExit(element, options) {
+    return this.play(element, options, "exit");
+  }
+  cancel(element) {
+    const current = this.runs.get(element);
+    if (!current) {
       return;
     }
-    if (this.modelBindings.get(element) === modelKey) {
-      return;
+    this.runs.delete(element);
+    current.animation.cancel();
+  }
+  play(element, transition, phase) {
+    this.cancel(element);
+    if (!this.canAnimate(element)) {
+      return null;
     }
-    this.modelBindings.set(element, modelKey);
-    const getValue = () => {
-      const value = this.getStateValue(context, modelKey);
-      return value === undefined || value === null ? "" : String(value);
+    const enterKeyframes = ENTER_KEYFRAMES[transition.type];
+    const keyframes = phase === "enter" ? [...enterKeyframes] : [...enterKeyframes].reverse();
+    const options = {
+      duration: transition.duration,
+      easing: "ease",
+      fill: "both"
+    };
+    const animation = element.animate(keyframes, options);
+    const token = Symbol("list-animation");
+    const finished = animation.finished.then(() => "finished", () => "cancelled");
+    const run = {
+      animation,
+      token,
+      keyframes,
+      options,
+      finished
     };
-    const setValue = (value) => {
-      const keys = modelKey.split(".");
-      let target = context.templateEngine.state;
-      for (let index = 0;index < keys.length - 1; index += 1) {
-        const key = keys[index];
-        if (!target[key] || typeof target[key] !== "object") {
-          target[key] = {};
+    this.runs.set(element, run);
+    finished.then((result) => {
+      if (this.runs.get(element)?.token !== token) {
+        return;
+      }
+      this.runs.delete(element);
+      if (phase === "enter" && result === "finished") {
+        animation.cancel();
+      }
+    });
+    return run;
+  }
+  canAnimate(element) {
+    const reduced = typeof window !== "undefined" && typeof window.matchMedia === "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+    return !reduced && typeof element.animate === "function";
+  }
+}
+
+// lib/core/animation/types.ts
+var TRANSITION_ANIMATION_TYPES = [
+  "fade",
+  "slide-up",
+  "slide-down",
+  "slide-left",
+  "slide-right",
+  "scale"
+];
+function normalizeTransitionGroupProps(props) {
+  const tag = (props.tag ?? "div").trim();
+  const type = props.type ?? "fade";
+  const duration = props.duration ?? 300;
+  if (!tag) {
+    throw new Error("TransitionGroup tag must not be empty");
+  }
+  if (!TRANSITION_ANIMATION_TYPES.includes(type)) {
+    throw new Error(`Unknown TransitionGroup animation type "${type}"`);
+  }
+  if (!Number.isFinite(duration) || duration < 0) {
+    throw new Error("TransitionGroup duration must be a non-negative finite number");
+  }
+  return { tag, type, duration };
+}
+function validateTransitionGroupChildren(children) {
+  const keys = new Set;
+  return children.map((child) => {
+    if (typeof child === "string" || child.key === undefined || keys.has(child.key)) {
+      throw new Error("TransitionGroup children must have unique keys");
+    }
+    keys.add(child.key);
+    return child;
+  });
+}
+function isTransitionGroupNode(vnode) {
+  return typeof vnode === "object" && vnode !== null && "transitionGroup" in vnode && isHTMLNode(vnode);
+}
+
+// lib/core/animation/transition-group-strategy.ts
+class TransitionGroupRenderStrategy extends ElementRenderStrategy {
+  entries = new WeakMap;
+  animations = new ListAnimationController;
+  matches(vnode) {
+    return isTransitionGroupNode(vnode);
+  }
+  mountChildren(element, groupVNode, context) {
+    const keyedChildren = validateTransitionGroupChildren(groupVNode.children ?? []);
+    const entries = new Map;
+    keyedChildren.forEach((childVNode) => {
+      const node = context.renderer.mount(childVNode, context);
+      element.appendChild(node);
+      const entry = {
+        key: childVNode.key,
+        vnode: childVNode,
+        node,
+        status: "active"
+      };
+      entries.set(entry.key, entry);
+      this.playEnter(entry, node, groupVNode.transitionGroup);
+    });
+    this.entries.set(element, entries);
+  }
+  updateChildren(element, _oldVNode, newVNode, context) {
+    const entries = this.entries.get(element) ?? new Map;
+    const nextChildren = validateTransitionGroupChildren(newVNode.children ?? []);
+    const nextKeys = new Set(nextChildren.map((child) => child.key));
+    const ordered = [];
+    nextChildren.forEach((childVNode) => {
+      const key = childVNode.key;
+      const current = entries.get(key);
+      if (current) {
+        const wasExiting = current.status === "exiting";
+        if (wasExiting && current.node instanceof HTMLElement) {
+          this.animations.cancel(current.node);
         }
-        target = target[key];
+        current.status = "active";
+        current.animationToken = undefined;
+        current.node = context.renderer.patch(current.vnode, childVNode, current.node, context);
+        current.vnode = childVNode;
+        ordered.push(current);
+        if (wasExiting) {
+          this.playEnter(current, current.node, newVNode.transitionGroup);
+        }
+        return;
       }
-      target[keys[keys.length - 1]] = value;
-    };
-    element.value = getValue();
-    const eventName = element instanceof HTMLSelectElement ? "change" : "input";
-    const inputListener = () => {
-      setValue(element.value);
-    };
-    element.addEventListener(eventName, inputListener);
-    const store = this.listeners.get(element) ?? new Map;
-    store.set(`model:${modelKey}`, { eventName, listener: inputListener });
-    this.listeners.set(element, store);
-    const effectRef = effect(() => {
-      const nextValue = getValue();
-      if (element.value !== nextValue) {
-        element.value = nextValue;
+      const node = context.renderer.mount(childVNode, context);
+      const entry = {
+        key,
+        vnode: childVNode,
+        node,
+        status: "active"
+      };
+      entries.set(key, entry);
+      ordered.push(entry);
+      this.playEnter(entry, node, newVNode.transitionGroup);
+    });
+    entries.forEach((entry, key) => {
+      if (nextKeys.has(key) || entry.status !== "active") {
+        return;
       }
+      this.startExit(element, entry, newVNode.transitionGroup, context);
     });
-    this.trackEffect(element, effectRef);
+    this.placeActiveEntries(element, ordered);
+    this.entries.set(element, entries);
   }
-  getStateValue(context, modelKey) {
-    return modelKey.split(".").reduce((value, key) => {
-      if (!value || typeof value !== "object") {
+  unmountChildren(element, vnode, context) {
+    const entries = this.entries.get(element);
+    if (!entries) {
+      super.unmountChildren(element, vnode, context);
+      return;
+    }
+    entries.forEach((entry) => {
+      if (entry.node instanceof HTMLElement) {
+        this.animations.cancel(entry.node);
+      }
+      context.renderer.unmount(entry.vnode, entry.node, context);
+      if (entry.node.parentNode === element) {
+        element.removeChild(entry.node);
+      }
+    });
+    entries.clear();
+    this.entries.delete(element);
+  }
+  playEnter(entry, node, options) {
+    if (!(node instanceof HTMLElement)) {
+      return;
+    }
+    const run = this.animations.playEnter(node, options);
+    entry.animationToken = run?.token;
+  }
+  startExit(wrapper, entry, options, context) {
+    entry.status = "exiting";
+    const run = entry.node instanceof HTMLElement ? this.animations.playExit(entry.node, options) : null;
+    if (!run) {
+      this.finishExit(wrapper, entry, context);
+      return;
+    }
+    entry.animationToken = run.token;
+    run.finished.then((result) => {
+      if (result === "finished" && entry.status === "exiting" && entry.animationToken === run.token) {
+        this.finishExit(wrapper, entry, context);
+      }
+    });
+  }
+  finishExit(wrapper, entry, context) {
+    const entries = this.entries.get(wrapper);
+    if (entries?.get(entry.key) !== entry) {
+      return;
+    }
+    context.renderer.unmount(entry.vnode, entry.node, context);
+    if (entry.node.parentNode === wrapper) {
+      wrapper.removeChild(entry.node);
+    }
+    entries.delete(entry.key);
+  }
+  placeActiveEntries(wrapper, ordered) {
+    let reference = null;
+    for (let index = ordered.length - 1;index >= 0; index -= 1) {
+      wrapper.insertBefore(ordered[index].node, reference);
+      reference = ordered[index].node;
+    }
+  }
+}
+
+// lib/core/renderer.ts
+class RendererContext {
+  strategies;
+  constructor() {
+    this.strategies = [
+      new TextRenderStrategy,
+      new ComponentRenderStrategy,
+      new SlotRenderStrategy,
+      new TransitionGroupRenderStrategy,
+      new ElementRenderStrategy
+    ];
+  }
+  mount(vnode, context) {
+    return this.findStrategy(vnode).mount(vnode, context);
+  }
+  patch(oldVNode, newVNode, currentNode, context) {
+    const oldStrategy = this.findStrategy(oldVNode);
+    const newStrategy = this.findStrategy(newVNode);
+    if (oldStrategy !== newStrategy) {
+      const nextNode = newStrategy.mount(newVNode, context);
+      currentNode.parentNode?.replaceChild(nextNode, currentNode);
+      oldStrategy.unmount(oldVNode, currentNode, context);
+      return nextNode;
+    }
+    return oldStrategy.patch(oldVNode, newVNode, currentNode, context);
+  }
+  unmount(vnode, currentNode, context) {
+    this.findStrategy(vnode).unmount(vnode, currentNode, context);
+  }
+  findStrategy(vnode) {
+    const strategy = this.strategies.find((item) => item.matches(vnode));
+    if (!strategy) {
+      throw new Error("No render strategy found for vnode");
+    }
+    return strategy;
+  }
+}
+
+class TextRenderStrategy {
+  matches(vnode) {
+    return typeof vnode === "string";
+  }
+  mount(vnode, context) {
+    return context.templateEngine.parseTemplate(vnode);
+  }
+  patch(oldVNode, newVNode, currentNode, context) {
+    if (oldVNode === newVNode) {
+      return currentNode;
+    }
+    const nextNode = this.mount(newVNode, context);
+    currentNode.parentNode?.replaceChild(nextNode, currentNode);
+    return nextNode;
+  }
+  unmount() {}
+}
+
+class ComponentRenderStrategy {
+  instances = new WeakMap;
+  instanceNodes = new Map;
+  emitterUnsubscribers = new WeakMap;
+  matches(vnode) {
+    return typeof vnode === "object" && vnode !== null && isComponentNode(vnode);
+  }
+  mount(vnode, context) {
+    if (vnode.directions?.if === false) {
+      return document.createComment("if");
+    }
+    const ComponentClass = vnode.component;
+    const instance = new ComponentClass(this.createProps(vnode));
+    if (context.appContext && instance.setAppContext) {
+      instance.setAppContext(context.appContext);
+    }
+    this.syncEmitters(instance, vnode.emitters ?? {});
+    context.registerChild(instance);
+    const node = instance.mountToNode();
+    this.trackInstanceNode(instance, node);
+    instance.setElementChangeListener?.((previousNode, nextNode) => {
+      this.trackInstanceNode(instance, previousNode);
+      this.trackInstanceNode(instance, nextNode);
+    });
+    return node;
+  }
+  patch(oldVNode, newVNode, currentNode, context) {
+    if (currentNode.nodeType === Node.COMMENT_NODE) {
+      const nextNode2 = this.mount(newVNode, context);
+      currentNode.parentNode?.replaceChild(nextNode2, currentNode);
+      return nextNode2;
+    }
+    if (newVNode.directions?.if === false) {
+      const nextNode2 = document.createComment("if");
+      currentNode.parentNode?.replaceChild(nextNode2, currentNode);
+      this.unmount(oldVNode, currentNode, context);
+      return nextNode2;
+    }
+    const instance = this.instances.get(currentNode);
+    if (instance && oldVNode.component === newVNode.component) {
+      this.syncEmitters(instance, newVNode.emitters ?? {});
+      instance.setProps(this.createProps(newVNode));
+      const nextNode2 = instance.getElement() ?? currentNode;
+      this.trackInstanceNode(instance, nextNode2);
+      return nextNode2;
+    }
+    const nextNode = this.mount(newVNode, context);
+    currentNode.parentNode?.replaceChild(nextNode, currentNode);
+    this.unmount(oldVNode, currentNode, context);
+    return nextNode;
+  }
+  unmount(_vnode, currentNode, context) {
+    const instance = this.instances.get(currentNode);
+    if (instance) {
+      this.clearEmitters(instance);
+      instance.unmount();
+      this.clearInstanceNodes(instance);
+      context.unregisterChild(instance);
+    }
+  }
+  createProps(vnode) {
+    return {
+      ...vnode.props ?? {},
+      children: vnode.children ?? []
+    };
+  }
+  syncEmitters(instance, emitters) {
+    const current = this.emitterUnsubscribers.get(instance) ?? new Map;
+    current.forEach(({ listener: currentListener, unsubscribe }, eventName) => {
+      const listener = emitters[eventName];
+      if (!listener || listener !== currentListener) {
+        unsubscribe();
+        current.delete(eventName);
+      }
+    });
+    Object.entries(emitters).forEach(([eventName, listener]) => {
+      if (current.get(eventName)?.listener === listener) {
         return;
       }
-      return value[key];
-    }, context.templateEngine.state);
+      current.set(eventName, {
+        listener,
+        unsubscribe: instance.on(eventName, listener)
+      });
+    });
+    this.emitterUnsubscribers.set(instance, current);
   }
-  trackEffect(element, effectRef) {
-    const effects = this.effects.get(element) ?? new Set;
-    effects.add(effectRef);
-    this.effects.set(element, effects);
+  clearEmitters(instance) {
+    this.emitterUnsubscribers.get(instance)?.forEach(({ unsubscribe }) => {
+      unsubscribe();
+    });
+    this.emitterUnsubscribers.delete(instance);
+  }
+  trackInstanceNode(instance, node) {
+    this.instances.set(node, instance);
+    const nodes = this.instanceNodes.get(instance) ?? new Set;
+    nodes.add(node);
+    this.instanceNodes.set(instance, nodes);
+  }
+  clearInstanceNodes(instance) {
+    this.instanceNodes.get(instance)?.forEach((node) => {
+      this.instances.delete(node);
+    });
+    this.instanceNodes.delete(instance);
+  }
+}
+
+class SlotRenderStrategy {
+  renderedChildren = new WeakMap;
+  matches(vnode) {
+    return typeof vnode === "object" && vnode !== null && isSlotProvider(vnode);
+  }
+  mount(vnode, context) {
+    if (vnode.directions?.if === false) {
+      return document.createComment("if");
+    }
+    const slotContainer = document.createElement("div");
+    slotContainer.setAttribute("data-slot", vnode.props.name);
+    this.mountSlotChildren(slotContainer, this.resolveChildren(vnode, context), context);
+    return slotContainer;
+  }
+  patch(oldVNode, newVNode, currentNode, context) {
+    if (currentNode.nodeType === Node.COMMENT_NODE) {
+      const nextNode = this.mount(newVNode, context);
+      currentNode.parentNode?.replaceChild(nextNode, currentNode);
+      return nextNode;
+    }
+    if (newVNode.directions?.if === false) {
+      const nextNode = document.createComment("if");
+      currentNode.parentNode?.replaceChild(nextNode, currentNode);
+      this.unmount(oldVNode, currentNode, context);
+      return nextNode;
+    }
+    if (currentNode instanceof HTMLElement) {
+      currentNode.setAttribute("data-slot", newVNode.props.name);
+      this.replaceSlotChildren(currentNode, oldVNode, newVNode, context);
+    }
+    return currentNode;
+  }
+  unmount(_vnode, currentNode, context) {
+    if (!(currentNode instanceof HTMLElement)) {
+      return;
+    }
+    this.unmountSlotChildren(currentNode, context);
+    this.renderedChildren.delete(currentNode);
+  }
+  resolveChildren(vnode, context) {
+    return context.slots[vnode.props.name] ?? vnode.children ?? [];
+  }
+  replaceSlotChildren(element, _oldVNode, newVNode, context) {
+    this.unmountSlotChildren(element, context);
+    element.textContent = "";
+    this.mountSlotChildren(element, this.resolveChildren(newVNode, context), context);
+  }
+  mountSlotChildren(element, children, context) {
+    children.forEach((child) => {
+      element.appendChild(context.renderer.mount(child, context));
+    });
+    this.renderedChildren.set(element, children);
+  }
+  unmountSlotChildren(element, context) {
+    const children = this.renderedChildren.get(element) ?? [];
+    children.forEach((child, index) => {
+      const childNode = element.childNodes[index];
+      if (childNode) {
+        context.renderer.unmount(child, childNode, context);
+      }
+    });
   }
 }
 
@@ -889,8 +1447,8 @@ class TemplateEngine {
       if (key) {
         keys.add(key);
         const value = this.getValueFromState(key);
-        const displayValue = value === undefined || value === null ? "" : String(value);
-        result = result.replace(match[0], displayValue);
+        const displayValue2 = value === undefined || value === null ? "" : String(value);
+        result = result.replace(match[0], displayValue2);
       }
     });
     return result;
@@ -910,7 +1468,7 @@ class TemplateEngine {
   }
   clearBindings() {
     this.bindings.forEach((binding) => {
-      binding.effect.active = false;
+      stop(binding.effect);
     });
     this.bindings = [];
   }
@@ -953,8 +1511,11 @@ class Component {
   templateEngine;
   childComponents = new Set;
   eventListeners = {};
+  providers = new Map;
   updateEffect;
   appContext = null;
+  parentComponent = null;
+  elementChangeListener = null;
   styleManager;
   state;
   mounted = false;
@@ -969,7 +1530,7 @@ class Component {
       if (this.mounted) {
         this.update();
       }
-    });
+    }, { throwOnError: true });
   }
   mount(container) {
     if (!container || !(container instanceof HTMLElement)) {
@@ -997,15 +1558,15 @@ class Component {
     if (!this.el || !this.vnode) {
       return;
     }
-    try {
-      this.beforeUpdate();
-      const newVNode = this.render();
-      this.el = this.renderer.patch(this.vnode, newVNode, this.el, this.createRenderContext());
-      this.vnode = newVNode;
-      this.onUpdated();
-    } catch (error) {
-      console.error("组件更新错误:", error);
+    this.beforeUpdate();
+    const newVNode = this.render();
+    const previousElement = this.el;
+    this.el = this.renderer.patch(this.vnode, newVNode, this.el, this.createRenderContext());
+    if (previousElement !== this.el) {
+      this.elementChangeListener?.(previousElement, this.el);
     }
+    this.vnode = newVNode;
+    this.onUpdated();
   }
   unmount() {
     if (!this.mounted) {
@@ -1016,8 +1577,15 @@ class Component {
       this.renderer.unmount(this.vnode, this.el, this.createRenderContext());
     }
     this.childComponents.clear();
+    Object.keys(this.eventListeners).forEach((eventName) => {
+      this.eventListeners[eventName].clear();
+      delete this.eventListeners[eventName];
+    });
+    this.providers.clear();
+    this.parentComponent = null;
+    this.elementChangeListener = null;
     this.templateEngine.clearBindings();
-    this.styleManager.clearStyles();
+    this.styleManager.destroy();
     stop(this.updateEffect);
     if (this.el?.parentNode) {
       this.el.parentNode.removeChild(this.el);
@@ -1045,6 +1613,28 @@ class Component {
       child.setAppContext?.(context);
     });
   }
+  setParentComponent(parent) {
+    this.parentComponent = parent;
+  }
+  setElementChangeListener(listener) {
+    this.elementChangeListener = listener;
+  }
+  provide(key, value) {
+    this.providers.set(key, value);
+  }
+  inject(key, fallback) {
+    const result = this.resolveInjection(key);
+    return result.found ? result.value : fallback;
+  }
+  resolveInjection(key) {
+    if (this.providers.has(key)) {
+      return { found: true, value: this.providers.get(key) };
+    }
+    if (this.parentComponent?.resolveInjection) {
+      return this.parentComponent.resolveInjection(key);
+    }
+    return this.resolveAppInjection(key);
+  }
   getElement() {
     return this.el;
   }
@@ -1070,6 +1660,7 @@ class Component {
       this.eventListeners[eventName] = new Set;
     }
     this.eventListeners[eventName].add(listener);
+    return () => this.off(eventName, listener);
   }
   off(eventName, listener) {
     this.eventListeners[eventName]?.delete(listener);
@@ -1082,7 +1673,12 @@ class Component {
       slots: this.collectSlots(),
       registerChild: (component) => {
         this.childComponents.add(component);
+        component.setParentComponent?.(this);
         component.setAppContext?.(this.appContext);
+      },
+      unregisterChild: (component) => {
+        this.childComponents.delete(component);
+        component.setParentComponent?.(null);
       }
     };
   }
@@ -1125,6 +1721,13 @@ class Component {
     const globalApp = globalThis.__APP__;
     return this.getRouterFrom(globalApp);
   }
+  resolveAppInjection(key) {
+    if (!this.appContext || typeof this.appContext !== "object") {
+      return { found: false, value: undefined };
+    }
+    const app = this.appContext.app;
+    return app?.resolveInjection?.(key) ?? { found: false, value: undefined };
+  }
   trackReactiveValue(value, seen) {
     if (!value || typeof value !== "object" || seen.has(value)) {
       return;
@@ -1147,6 +1750,12 @@ function setRouter(r) {
   }
   router = r;
 }
+function useRouter() {
+  if (!router) {
+    throw new Error("Router is not initialized. Please make sure you have installed the router plugin.");
+  }
+  return router;
+}
 
 // lib/router/matcher.ts
 function normalizePath(path) {
@@ -1207,13 +1816,18 @@ function createRouterHref(path, mode, base) {
 function getBrowserLocation(mode, base) {
   let path;
   let fullPath;
+  let queryString;
   if (mode === "history") {
     fullPath = window.location.pathname + window.location.search;
     path = window.location.pathname;
+    queryString = window.location.search;
   } else {
     const hash = window.location.hash;
     fullPath = hash || "#/";
     path = fullPath.startsWith("#") ? fullPath.slice(1) : fullPath;
+    const queryStart = path.indexOf("?");
+    queryString = queryStart >= 0 ? path.slice(queryStart + 1) : "";
+    path = queryStart >= 0 ? path.slice(0, queryStart) : path;
   }
   if (path.startsWith(base) && base !== "/" && path !== "/") {
     path = path.slice(base.length);
@@ -1222,7 +1836,7 @@ function getBrowserLocation(mode, base) {
   return {
     path,
     fullPath,
-    query: parseQuery(mode === "hash" ? path.split("?")[1] ?? "" : window.location.search),
+    query: parseQuery(queryString),
     params: {}
   };
 }
@@ -1492,7 +2106,7 @@ function createRouter(options) {
   return new Router(options);
 }
 
-export { ReactiveSystem, reactive, readonly, effect, computed, stop, isReactive, isReadonly, TemplateEngine, isComponentNode, isHTMLNode, isSlotProvider, h, createComponent, slot, RendererContext, TextRenderStrategy, ComponentRenderStrategy, SlotRenderStrategy, ElementRenderStrategy, Component, Router, RouterLink, RouterView, createRouter };
+export { isComponentNode, isHTMLNode, isSlotProvider, h, Tag, Div, Span, P, Button, Input, Section, Main, Header, Footer, Nav, Article, Aside, H1, H2, H3, H4, H5, H6, Strong, Em, Small, Pre, Code, Blockquote, Ul, Ol, Li, A, Img, Form, Label, Textarea, Select, Option, Table, Thead, Tbody, Tr, Th, Td, createComponent, slot, each, ReactiveSystem, reactive, readonly, effect, computed, ref, isRef, unref, stop, isReactive, isReadonly, modelPath, getModelValue, setModelValue, ModelBindingController, ElementRenderStrategy, normalizeTransitionGroupProps, validateTransitionGroupChildren, RendererContext, TextRenderStrategy, ComponentRenderStrategy, SlotRenderStrategy, TemplateEngine, Component, useRouter, Router, RouterLink, RouterView, createRouter };
 
-//# debugId=97822D95A36A4F3E64756E2164756E21
-//# sourceMappingURL=index-3j2jsdpc.js.map
+//# debugId=91AF0EEFB67A584364756E2164756E21
+//# sourceMappingURL=index-wv9gyjqt.js.map