@ktjs/core 0.33.0 → 0.33.2

package/dist/index.mjs

@@ -1,34 +1,10 @@
-import { $isArray, $isThenable, $isNode, $emptyFn, $is, $applyModel, $forEach, $identity } from '@ktjs/shared';
+import { $isArray, $isThenable, $isNode, $emptyFn, $is, $applyModel, $forEach, $identity } from "@ktjs/shared";
 
-const isKT = (obj) => obj?.isKT;
-const isRef = (obj) => {
-    // & This is tested to be the fastest way.
-    // faster than includes, arrayindex, if or.
-    if (obj.ktType === undefined) {
-        return false;
-    }
-    return obj.ktType === 3 /* KTReactiveType.Ref */;
-};
-const isComputed = (obj) => obj?.ktType === 2 /* KTReactiveType.Computed */;
-
-const booleanHandler = (element, key, value) => {
-    if (key in element) {
-        element[key] = !!value;
-    }
-    else {
-        element.setAttribute(key, value);
-    }
-};
-const valueHandler = (element, key, value) => {
-    if (key in element) {
-        element[key] = value;
-    }
-    else {
-        element.setAttribute(key, value);
-    }
-};
-// Attribute handlers map for optimized lookup
-const handlers = {
+const isKT = obj => obj?.isKT, isRef = obj => void 0 !== obj.ktType && 3 === obj.ktType, isComputed = obj => 2 === obj?.ktType, booleanHandler = (element, key, value) => {
+    key in element ? element[key] = !!value : element.setAttribute(key, value);
+}, valueHandler = (element, key, value) => {
+    key in element ? element[key] = value : element.setAttribute(key, value);
+}, handlers = {
     checked: booleanHandler,
     selected: booleanHandler,
     value: valueHandler,
@@ -49,485 +25,224 @@ const handlers = {
     muted: booleanHandler,
     defer: booleanHandler,
     async: booleanHandler,
-    hidden: (element, _key, value) => (element.hidden = !!value),
+    hidden: (element, _key, value) => element.hidden = !!value
+}, defaultHandler = (element, key, value) => element.setAttribute(key, value), setElementStyle = (element, style) => {
+    if ("string" != typeof style) for (const key in style) element.style[key] = style[key]; else element.style.cssText = style;
 };
 
-const defaultHandler = (element, key, value) => element.setAttribute(key, value);
-const setElementStyle = (element, style) => {
-    if (typeof style === 'string') {
-        element.style.cssText = style;
-        return;
-    }
-    for (const key in style) {
-        element.style[key] = style[key];
-    }
-};
-function attrIsObject(element, attr) {
-    const classValue = attr.class || attr.className;
-    if (classValue !== undefined) {
-        if (isKT(classValue)) {
-            element.setAttribute('class', classValue.value);
-            classValue.addOnChange((v) => element.setAttribute('class', v));
-        }
-        else {
-            element.setAttribute('class', classValue);
-        }
-    }
-    const style = attr.style;
-    if (style) {
-        if (typeof style === 'string') {
-            element.setAttribute('style', style);
-        }
-        else if (typeof style === 'object') {
-            if (isKT(style)) {
-                setElementStyle(element, style.value);
-                style.addOnChange((v) => setElementStyle(element, v));
+function applyAttr(element, attr) {
+    if (attr) {
+        if ("object" != typeof attr || null === attr) throw new Error("[@ktjs/core error] attr must be an object.");
+        !function(element, attr) {
+            const classValue = attr.class || attr.className;
+            void 0 !== classValue && (isKT(classValue) ? (element.setAttribute("class", classValue.value), 
+            classValue.addOnChange(v => element.setAttribute("class", v))) : element.setAttribute("class", classValue));
+            const style = attr.style;
+            if (style && ("string" == typeof style ? element.setAttribute("style", style) : "object" == typeof style && (isKT(style) ? (setElementStyle(element, style.value), 
+            style.addOnChange(v => setElementStyle(element, v))) : setElementStyle(element, style))), 
+            "k-html" in attr) {
+                const html = attr["k-html"];
+                isKT(html) ? (element.innerHTML = html.value, html.addOnChange(v => element.innerHTML = v)) : element.innerHTML = html;
             }
-            else {
-                setElementStyle(element, style);
+            for (const key in attr) {
+                if ("k-model" === key || "k-for" === key || "k-key" === key || "ref" === key || "class" === key || "className" === key || "style" === key || "children" === key || "k-html" === key) continue;
+                const o = attr[key];
+                if (key.startsWith("on:")) {
+                    o && element.addEventListener(key.slice(3), o);
+                    continue;
+                }
+                const handler = handlers[key] || defaultHandler;
+                isKT(o) ? (handler(element, key, o.value), o.addOnChange(v => handler(element, key, v))) : handler(element, key, o);
             }
-        }
-    }
-    if ('k-html' in attr) {
-        const html = attr['k-html'];
-        if (isKT(html)) {
-            element.innerHTML = html.value;
-            html.addOnChange((v) => (element.innerHTML = v));
-        }
-        else {
-            element.innerHTML = html;
-        }
-    }
-    for (const key in attr) {
-        // & Arranged in order of usage frequency
-        if (
-        // key === 'k-if' ||
-        // key === 'k-else' ||
-        key === 'k-model' ||
-            key === 'k-for' ||
-            key === 'k-key' ||
-            key === 'ref' ||
-            key === 'class' ||
-            key === 'className' ||
-            key === 'style' ||
-            key === 'children' ||
-            key === 'k-html') {
-            continue;
-        }
-        const o = attr[key];
-        // normal event handler
-        if (key.startsWith('on:')) {
-            if (o) {
-                element.addEventListener(key.slice(3), o); // chop off the `on:`
-            }
-            continue;
-        }
-        // normal attributes
-        const handler = handlers[key] || defaultHandler;
-        if (isKT(o)) {
-            handler(element, key, o.value);
-            o.addOnChange((v) => handler(element, key, v));
-        }
-        else {
-            handler(element, key, o);
-        }
-    }
-}
-function applyAttr(element, attr) {
-    if (!attr) {
-        return;
-    }
-    if (typeof attr === 'object' && attr !== null) {
-        attrIsObject(element, attr);
-    }
-    else {
-        throw new Error('[@ktjs/core error] attr must be an object.');
+        }(element, attr);
     }
 }
 
-const assureNode = (o) => ($isNode(o) ? o : document.createTextNode(o));
+const assureNode = o => $isNode(o) ? o : document.createTextNode(o);
+
 function apdSingle(element, c) {
-    // & Ignores falsy values, consistent with React's behavior
-    if (c === undefined || c === null || c === false) {
-        return;
-    }
-    if (isKT(c)) {
+    if (null != c && !1 !== c) if (isKT(c)) {
         let node = assureNode(c.value);
-        element.appendChild(node);
-        c.addOnChange((newValue, _oldValue) => {
+        element.appendChild(node), c.addOnChange((newValue, _oldValue) => {
             const oldNode = node;
-            node = assureNode(newValue);
-            oldNode.replaceWith(node);
+            node = assureNode(newValue), oldNode.replaceWith(node);
         });
-    }
-    else {
+    } else {
         const node = assureNode(c);
         element.appendChild(node);
-        // Handle KTFor anchor
         const list = node.__kt_for_list__;
-        if ($isArray(list)) {
-            apd(element, list);
-        }
+        $isArray(list) && apd(element, list);
     }
 }
+
 function apd(element, c) {
-    if ($isThenable(c)) {
-        c.then((r) => apd(element, r));
-    }
-    else if ($isArray(c)) {
-        for (let i = 0; i < c.length; i++) {
-            // & might be thenable here too
-            const ci = c[i];
-            if ($isThenable(ci)) {
-                const comment = document.createComment('ktjs-promise-placeholder');
-                element.appendChild(comment);
-                ci.then((awaited) => comment.replaceWith(awaited));
-            }
-            else {
-                apdSingle(element, ci);
-            }
-        }
-    }
-    else {
-        // & here is thened, so must be a simple elementj
-        apdSingle(element, c);
-    }
+    if ($isThenable(c)) c.then(r => apd(element, r)); else if ($isArray(c)) for (let i = 0; i < c.length; i++) {
+        const ci = c[i];
+        if ($isThenable(ci)) {
+            const comment = document.createComment("ktjs-promise-placeholder");
+            element.appendChild(comment), ci.then(awaited => comment.replaceWith(awaited));
+        } else apdSingle(element, ci);
+    } else apdSingle(element, c);
 }
+
 function applyContent(element, content) {
-    if ($isArray(content)) {
-        for (let i = 0; i < content.length; i++) {
-            apd(element, content[i]);
-        }
-    }
-    else {
-        apd(element, content);
-    }
+    if ($isArray(content)) for (let i = 0; i < content.length; i++) apd(element, content[i]); else apd(element, content);
 }
 
-// # internal methods that cannot be placed in @ktjs/shared
 const IdGenerator = {
     _refOnChangeId: 1,
     get refOnChangeId() {
         return this._refOnChangeId++;
-    }};
+    }
+};
 
 class KTReactive {
-    /**
-     * Indicates that this is a KTRef instance
-     */
-    isKT = true;
-    ktType = 1 /* KTReactiveType.Reative */;
-    /**
-     * @internal
-     */
+    isKT=!0;
+    ktType=1;
     _value;
-    /**
-     * @internal
-     */
-    _changeHandlers = new Map();
-    /**
-     * @internal
-     */
+    _changeHandlers=new Map;
     _emit(newValue, oldValue, handlerKeys) {
         if (handlerKeys) {
-            for (let i = 0; i < handlerKeys.length; i++) {
-                this._changeHandlers.get(handlerKeys[i])?.(newValue, oldValue);
-            }
+            for (let i = 0; i < handlerKeys.length; i++) this._changeHandlers.get(handlerKeys[i])?.(newValue, oldValue);
             return this;
         }
-        this._changeHandlers.forEach((c) => c(newValue, oldValue));
-        return this;
+        return this._changeHandlers.forEach(c => c(newValue, oldValue)), this;
     }
     constructor(_value) {
-        this._value = _value;
-        this._changeHandlers = new Map();
+        this._value = _value, this._changeHandlers = new Map;
     }
-    /**
-     * If new value and old value are both nodes, the old one will be replaced in the DOM
-     * - Use `.mutable` to modify the value.
-     * @readonly
-     */
     get value() {
         return this._value;
     }
-    set value(_newValue) {
-        // Only allow KTRef to be set.
-    }
-    /**
-     * Force all listeners to run even when reference identity has not changed.
-     * Useful for in-place array/object mutations.
-     * - Is implemented differently in `KTRef` and `KTComputed`
-     */
-    notify(..._args) {
-        throw new Error('This is meant to be override in ref.ts and computed.ts');
+    set value(_newValue) {}
+    notify(handlerKeys) {
+        return this._emit(this._value, this._value, handlerKeys);
     }
     map(..._args) {
-        throw new Error('This is meant to be override in computed.ts');
+        throw new Error("This is meant to be override in computed.ts");
     }
-    /**
-     * Register a callback when the value changes
-     * @param callback newValue and oldValue are references. You can use `a.draft` to make in-place mutations since `a.value` will not trigger `onChange` handers.
-     * @param key Optional key to identify the callback, allowing multiple listeners on the same ref and individual removal. If not provided, a unique ID will be generated.
-     */
-    // todo 链式调用addOnChange改造
     addOnChange(callback, key) {
-        if (typeof callback !== 'function') {
-            throw new Error('[@ktjs/core error] KTRef.addOnChange: callback must be a function');
-        }
+        if ("function" != typeof callback) throw new Error("[@ktjs/core error] KTRef.addOnChange: callback must be a function");
         const k = key ?? IdGenerator.refOnChangeId;
-        this._changeHandlers.set(k, callback);
-        return this;
+        return this._changeHandlers.set(k, callback), this;
     }
     removeOnChange(key) {
         const callback = this._changeHandlers.get(key);
-        this._changeHandlers.delete(key);
-        return callback;
+        return this._changeHandlers.delete(key), callback;
     }
 }
 
-// Use microqueue to schedule the flush of pending reactions
-const reactiveToOldValue = new Map();
-let scheduled = false;
-const markMutation = (reactive) => {
-    if (!reactiveToOldValue.has(reactive)) {
-        // @ts-expect-error accessing protected property
-        reactiveToOldValue.set(reactive, reactive._value);
-        // # schedule by microqueue
-        if (scheduled) {
-            return;
-        }
-        scheduled = true;
-        Promise.resolve().then(() => {
-            scheduled = false;
-            reactiveToOldValue.forEach((oldValue, reactive) => {
-                // @ts-expect-error accessing protected property
-                reactive._changeHandlers.forEach((handler) => handler(reactive.value, oldValue));
-            });
-            reactiveToOldValue.clear();
-        });
-    }
-};
+const reactiveToOldValue = new Map;
+
+let scheduled = !1;
 
 class KTRef extends KTReactive {
-    ktType = 3 /* KTReactiveType.Ref */;
-    // ! Cannot be omitted, otherwise this will override `KTReactive` with only setter. And getter will return undefined.
+    ktType=3;
     get value() {
         return this._value;
     }
     set value(newValue) {
-        if ($is(newValue, this._value)) {
-            return;
-        }
+        if ($is(newValue, this._value)) return;
         const oldValue = this._value;
-        this._value = newValue;
-        this._emit(newValue, oldValue);
+        this._value = newValue, this._emit(newValue, oldValue);
     }
-    // todo 编译器要对这个属性的逃逸（也就是什么都没改或者被赋值）进行检测，比如const a = xxx.draft.
     get draft() {
-        markMutation(this);
-        return this._value;
-    }
-    /**
-     * Force all listeners to run even when reference identity has not changed.
-     */
-    notify(oldValue = this._value, newValue = this._value, handlerKeys) {
-        return this._emit(newValue, oldValue, handlerKeys);
+        return (reactive => {
+            if (!reactiveToOldValue.has(reactive)) {
+                if (reactiveToOldValue.set(reactive, reactive._value), scheduled) return;
+                scheduled = !0, Promise.resolve().then(() => {
+                    scheduled = !1, reactiveToOldValue.forEach((oldValue, reactive) => {
+                        reactive._changeHandlers.forEach(handler => handler(reactive.value, oldValue));
+                    }), reactiveToOldValue.clear();
+                });
+            }
+        })(this), this._value;
     }
 }
-/**
- * Create a `KTRef` object.
- * - use `refObject.state` to get plain data
- * - use `refObject.map(calculator)` to create a computed value based on this ref
- * - use `refObject.mutable` to set too, but it will recalculate in the next microtask. Useful for deep objects, `Map`, `Set` or other custom objects
- *
- * @param value any data
- * @param onChange event handler triggered when the value changes, with signature `(newValue, oldValue) => void`
- * @returns
- */
-const ref = (value) => new KTRef(value);
-/**
- * Assert k-model to be a ref object
- */
-const $modelOrRef = (props, defaultValue) => {
-    // & props is an object. Won't use it in any other place
-    if ('k-model' in props) {
-        const kmodel = props['k-model'];
-        if (isRef(kmodel)) {
-            return kmodel;
-        }
-        else {
-            throw new Error(`[@ktjs/core error] k-model data must be a KTRef object, please use 'ref(...)' to wrap it.`);
-        }
+
+const ref = value => new KTRef(value), $modelOrRef = (props, defaultValue) => {
+    if ("k-model" in props) {
+        const kmodel = props["k-model"];
+        if (isRef(kmodel)) return kmodel;
+        throw new Error("[@ktjs/core error] k-model data must be a KTRef object, please use 'ref(...)' to wrap it.");
     }
     return ref(defaultValue);
-};
-const $refSetter = (props, node) => (props.ref.value = node);
-/**
- * Whether `props.ref` is a `KTRef` only needs to be checked in the initial render
- */
-const $initRef = (props, node) => {
-    if (!('ref' in props)) {
-        return $emptyFn;
-    }
+}, $refSetter = (props, node) => props.ref.value = node, $initRef = (props, node) => {
+    if (!("ref" in props)) return $emptyFn;
     const r = props.ref;
-    if (isRef(r)) {
-        r.value = node;
-        return $refSetter;
-    }
-    else {
-        throw new Error('[@ktjs/core error] Fragment: ref must be a KTRef');
-    }
+    if (isRef(r)) return r.value = node, $refSetter;
+    throw new Error("[@ktjs/core error] Fragment: ref must be a KTRef");
 };
 
 class KTComputed extends KTReactive {
-    ktType = 2 /* KTReactiveType.Computed */;
-    /**
-     * @internal
-     */
+    ktType=2;
     _calculator;
-    /**
-     * @internal
-     */
-    _recalculate(forceEmit = false, handlerKeys) {
-        const oldValue = this._value;
-        const newValue = this._calculator();
-        if (oldValue === newValue) {
-            if (forceEmit) {
-                this._emit(newValue, oldValue, handlerKeys);
-            }
-            return this;
-        }
-        this._value = newValue;
-        this._emit(newValue, oldValue, handlerKeys);
-        return this;
+    _recalculate(forceEmit = !1, handlerKeys) {
+        const oldValue = this._value, newValue = this._calculator();
+        return oldValue === newValue ? (forceEmit && this._emit(newValue, oldValue, handlerKeys), 
+        this) : (this._value = newValue, this._emit(newValue, oldValue, handlerKeys), this);
     }
-    // todo 侦听的dependency数量比较多的，纳入scheduler
     constructor(_calculator, dependencies) {
-        super(_calculator());
-        this._calculator = _calculator;
-        for (let i = 0; i < dependencies.length; i++) {
-            dependencies[i].addOnChange(() => this._recalculate());
-        }
+        super(_calculator()), this._calculator = _calculator;
+        for (let i = 0; i < dependencies.length; i++) dependencies[i].addOnChange(() => this._recalculate());
     }
-    /**
-     * If new value and old value are both nodes, the old one will be replaced in the DOM
-     */
     get value() {
         return this._value;
     }
     set value(_newValue) {
-        console.warn('[@ktjs/core warn]',`'value' of Computed are read-only.`);
+        console.warn("[@ktjs/core warn]", "'value' of Computed are read-only.");
     }
-    /**
-     * Force listeners to run once with the latest computed result.
-     */
     notify(handlerKeys) {
-        return this._recalculate(true, handlerKeys);
+        return this._recalculate(!0, handlerKeys);
     }
 }
-KTReactive.prototype.map = function (calculator, dependencies) {
-    return new KTComputed(() => calculator(this._value), dependencies ? [this, ...dependencies] : [this]);
-};
-/**
- * Create a reactive computed value
- * @param computeFn
- * @param dependencies refs and computeds that this computed depends on
- */
+
 function computed(computeFn, dependencies) {
-    if (dependencies.some((v) => !isKT(v))) {
-        throw new Error('[@ktjs/core error] computed: all reactives must be KTRef or KTComputed instances');
-    }
+    if (dependencies.some(v => !isKT(v))) throw new Error("[@ktjs/core error] computed: all reactives must be KTRef or KTComputed instances");
     return new KTComputed(computeFn, dependencies);
 }
 
-/**
- * Register a reactive effect with options.
- * @param effectFn The effect function to run when dependencies change
- * @param reactives The reactive dependencies
- * @param options Effect options: lazy, onCleanup, debugName
- * @returns stop function to remove all listeners
- */
 function effect(effectFn, reactives, options) {
-    const { lazy = false, onCleanup = $emptyFn, debugName = '' } = Object(options);
-    const listenerKeys = [];
-    let active = true;
+    const {lazy: lazy = !1, onCleanup: onCleanup = $emptyFn, debugName: debugName = ""} = Object(options), listenerKeys = [];
+    let active = !0;
     const run = () => {
-        if (!active) {
-            return;
-        }
-        // cleanup before rerun
-        onCleanup();
-        try {
-            effectFn();
-        }
-        catch (err) {
-            console.debug('[@ktjs/core debug]','effect error:', debugName, err);
+        if (active) {
+            onCleanup();
+            try {
+                effectFn();
+            } catch (err) {
+                console.debug("[@ktjs/core debug]", "effect error:", debugName, err);
+            }
         }
     };
-    // subscribe to dependencies
-    for (let i = 0; i < reactives.length; i++) {
-        listenerKeys[i] = i;
-        reactives[i].addOnChange(run, i);
-    }
-    // auto run unless lazy
-    if (!lazy) {
-        run();
-    }
-    // stop function
-    return () => {
-        if (!active) {
-            return;
-        }
-        active = false;
-        for (let i = 0; i < reactives.length; i++) {
-            reactives[i].removeOnChange(listenerKeys[i]);
+    for (let i = 0; i < reactives.length; i++) listenerKeys[i] = i, reactives[i].addOnChange(run, i);
+    return lazy || run(), () => {
+        if (active) {
+            active = !1;
+            for (let i = 0; i < reactives.length; i++) reactives[i].removeOnChange(listenerKeys[i]);
+            onCleanup();
         }
-        // final cleanup
-        onCleanup();
     };
 }
 
-/**
- *
- * @param value
- * @returns
- */
-const toReactive = (value) => isKT(value) ? value : ref(value);
-/**
- * Extracts the value from a KTReactive, or returns the value directly if it's not reactive.
- */
+KTReactive.prototype.map = function(calculator, dependencies) {
+    return new KTComputed(() => calculator(this._value), dependencies ? [ this, ...dependencies ] : [ this ]);
+};
+
+const toReactive = value => isKT(value) ? value : ref(value);
+
 function dereactive(value) {
     return isKT(value) ? value.value : value;
 }
 
 function applyKModel(element, valueRef) {
-    if (!isKT(valueRef)) {
-        throw new Error('[@ktjs/core error] k-model value must be a KTRef.');
-    }
-    if (element.tagName === 'INPUT') {
-        if (element.type === 'radio' || element.type === 'checkbox') {
-            $applyModel(element, valueRef, 'checked', 'change');
-            return;
-        }
-        if (element.type === 'number') {
-            $applyModel(element, valueRef, 'checked', 'change', Number);
-            return;
-        }
-        if (element.type === 'date') {
-            $applyModel(element, valueRef, 'checked', 'change', (v) => new Date(v));
-            return;
-        }
-        $applyModel(element, valueRef, 'value', 'input');
-    }
-    else if (element.tagName === 'SELECT') {
-        $applyModel(element, valueRef, 'value', 'change');
-    }
-    else if (element.tagName === 'TEXTAREA') {
-        $applyModel(element, valueRef, 'value', 'input');
-    }
-    else {
-        console.warn('[@ktjs/core warn]','not supported element for k-model:');
-    }
+    if (!isKT(valueRef)) throw new Error("[@ktjs/core error] k-model value must be a KTRef.");
+    if ("INPUT" === element.tagName) {
+        if ("radio" === element.type || "checkbox" === element.type) return void $applyModel(element, valueRef, "checked", "change");
+        if ("number" === element.type) return void $applyModel(element, valueRef, "checked", "change", Number);
+        if ("date" === element.type) return void $applyModel(element, valueRef, "checked", "change", v => new Date(v));
+        $applyModel(element, valueRef, "value", "input");
+    } else "SELECT" === element.tagName ? $applyModel(element, valueRef, "value", "change") : "TEXTAREA" === element.tagName ? $applyModel(element, valueRef, "value", "input") : console.warn("[@ktjs/core warn]", "not supported element for k-model:");
 }
 
 /**
@@ -540,470 +255,226 @@ function applyKModel(element, valueRef) {
  * ## About
  * @package @ktjs/core
  * @author Kasukabe Tsumugi <futami16237@gmail.com>
- * @version 0.33.0 (Last Update: 2026.03.21 22:19:51.700)
+ * @version 0.33.2 (Last Update: 2026.03.22 00:10:18.944)
  * @license MIT
  * @link https://github.com/baendlorel/kt.js
  * @link https://baendlorel.github.io/ Welcome to my site!
  * @description Core functionality for kt.js - DOM manipulation utilities with JSX/TSX support
  * @copyright Copyright (c) 2026 Kasukabe Tsumugi. All rights reserved.
- */
-const h = (tag, attr, content) => {
-    if (typeof tag !== 'string') {
-        throw new Error('[@ktjs/core error] tagName must be a string.');
-    }
-    // * start creating the element
+ */ const h = (tag, attr, content) => {
+    if ("string" != typeof tag) throw new Error("[@ktjs/core error] tagName must be a string.");
     const element = document.createElement(tag);
-    if (typeof attr === 'object' && attr !== null && 'k-model' in attr) {
-        applyKModel(element, attr['k-model']);
-    }
-    // * Handle content
-    applyAttr(element, attr);
-    applyContent(element, content);
-    return element;
-};
-const svg$1 = (tag, attr, content) => {
-    if (typeof tag !== 'string') {
-        throw new Error('[@ktjs/core error] tagName must be a string.');
-    }
-    // * start creating the element
-    const element = document.createElementNS('http://www.w3.org/2000/svg', tag);
-    // * Handle content
-    applyAttr(element, attr);
-    applyContent(element, content);
-    if (typeof attr === 'object' && attr !== null && 'k-model' in attr) {
-        applyKModel(element, attr['k-model']);
-    }
-    return element;
-};
-const mathml$1 = (tag, attr, content) => {
-    if (typeof tag !== 'string') {
-        throw new Error('[@ktjs/core error] tagName must be a string.');
-    }
-    // * start creating the element
-    const element = document.createElementNS('http://www.w3.org/1998/Math/MathML', tag);
-    // * Handle content
-    applyAttr(element, attr);
-    applyContent(element, content);
-    if (typeof attr === 'object' && attr !== null && 'k-model' in attr) {
-        applyKModel(element, attr['k-model']);
-    }
-    return element;
+    return "object" == typeof attr && null !== attr && "k-model" in attr && applyKModel(element, attr["k-model"]), 
+    applyAttr(element, attr), applyContent(element, content), element;
+}, svg$1 = (tag, attr, content) => {
+    if ("string" != typeof tag) throw new Error("[@ktjs/core error] tagName must be a string.");
+    const element = document.createElementNS("http://www.w3.org/2000/svg", tag);
+    return applyAttr(element, attr), applyContent(element, content), "object" == typeof attr && null !== attr && "k-model" in attr && applyKModel(element, attr["k-model"]), 
+    element;
+}, mathml$1 = (tag, attr, content) => {
+    if ("string" != typeof tag) throw new Error("[@ktjs/core error] tagName must be a string.");
+    const element = document.createElementNS("http://www.w3.org/1998/Math/MathML", tag);
+    return applyAttr(element, attr), applyContent(element, content), "object" == typeof attr && null !== attr && "k-model" in attr && applyKModel(element, attr["k-model"]), 
+    element;
 };
 
-const FRAGMENT_MOUNT_PATCHED = '__kt_fragment_mount_patched__';
-const FRAGMENT_MOUNT = '__kt_fragment_mount__';
-if (typeof Node !== 'undefined' && !globalThis[FRAGMENT_MOUNT_PATCHED]) {
-    globalThis[FRAGMENT_MOUNT_PATCHED] = true;
+if ("undefined" != typeof Node && !globalThis.__kt_fragment_mount_patched__) {
+    globalThis.__kt_fragment_mount_patched__ = !0;
     const originAppendChild = Node.prototype.appendChild;
-    Node.prototype.appendChild = function (node) {
-        const result = originAppendChild.call(this, node);
-        const mount = node[FRAGMENT_MOUNT];
-        if (typeof mount === 'function') {
-            mount();
-        }
-        return result;
+    Node.prototype.appendChild = function(node) {
+        const result = originAppendChild.call(this, node), mount = node.__kt_fragment_mount__;
+        return "function" == typeof mount && mount(), result;
     };
     const originInsertBefore = Node.prototype.insertBefore;
-    Node.prototype.insertBefore = function (node, child) {
-        const result = originInsertBefore.call(this, node, child);
-        const mount = node[FRAGMENT_MOUNT];
-        if (typeof mount === 'function') {
-            mount();
-        }
-        return result;
+    Node.prototype.insertBefore = function(node, child) {
+        const result = originInsertBefore.call(this, node, child), mount = node.__kt_fragment_mount__;
+        return "function" == typeof mount && mount(), result;
     };
 }
-/**
- * Fragment - Container component for managing arrays of child elements
- *
- * Features:
- * 1. Returns a comment anchor node, child elements are inserted after the anchor
- * 2. Supports reactive arrays, automatically updates DOM when array changes
- * 3. Basic version uses simple replacement algorithm (remove all old elements, insert all new elements)
- * 4. Future enhancement: key-based optimization
- *
- * Usage example:
- * ```tsx
- * const children = ref([<div>A</div>, <div>B</div>]);
- * const fragment = <Fragment children={children} />;
- * document.body.appendChild(fragment);
- *
- * // Automatic update
- * children.value = [<div>C</div>, <div>D</div>];
- * ```
- */
-function Fragment$1(props) {
-    const elements = [];
-    const anchor = document.createComment('kt-fragment');
-    let inserted = false;
-    let observer;
-    const redraw = () => {
-        const newElements = childrenRef.value;
-        const parent = anchor.parentNode;
-        if (!parent) {
-            elements.length = 0;
-            for (let i = 0; i < newElements.length; i++) {
-                elements.push(newElements[i]);
-            }
-            anchor.__kt_fragment_list__ = elements;
-            return;
-        }
-        for (let i = 0; i < elements.length; i++) {
-            elements[i].remove();
-        }
-        const fragment = document.createDocumentFragment();
-        elements.length = 0;
-        for (let i = 0; i < newElements.length; i++) {
-            const element = newElements[i];
-            elements.push(element);
-            fragment.appendChild(element);
-        }
-        parent.insertBefore(fragment, anchor.nextSibling);
-        inserted = true;
-        delete anchor[FRAGMENT_MOUNT];
-        observer?.disconnect();
-        observer = undefined;
-        anchor.__kt_fragment_list__ = elements;
-    };
-    const childrenRef = toReactive(props.children).addOnChange(redraw);
-    const renderInitial = () => {
-        const current = childrenRef.value;
-        elements.length = 0;
-        const fragment = document.createDocumentFragment();
-        for (let i = 0; i < current.length; i++) {
-            const element = current[i];
-            elements.push(element);
-            fragment.appendChild(element);
-        }
-        anchor.__kt_fragment_list__ = elements;
-        const parent = anchor.parentNode;
-        if (parent && !inserted) {
-            parent.insertBefore(fragment, anchor.nextSibling);
-            inserted = true;
-        }
-    };
-    renderInitial();
-    anchor[FRAGMENT_MOUNT] = () => {
-        if (!inserted && anchor.parentNode) {
-            redraw();
-        }
-    };
-    observer = new MutationObserver(() => {
-        if (anchor.parentNode && !inserted) {
-            redraw();
-            observer?.disconnect();
-            observer = undefined;
-        }
-    });
-    observer.observe(document.body, { childList: true, subtree: true });
-    $initRef(props, anchor);
-    return anchor;
-}
-/**
- * Convert KTRawContent to HTMLElement array
- */
-function convertChildrenToElements(children) {
-    const elements = [];
-    const processChild = (child) => {
-        if (child === undefined || child === null || child === false || child === true) {
-            // Ignore null, undefined, false, true
-            return;
-        }
-        if ($isArray(child)) {
-            // Recursively process array
-            $forEach(child, processChild);
-            return;
-        }
-        if (typeof child === 'string' || typeof child === 'number') {
-            const span = document.createElement('span');
-            span.textContent = String(child);
-            elements.push(span);
-            return;
-        }
-        if (child instanceof HTMLElement) {
-            elements.push(child);
-            return;
-        }
-        if (isKT(child)) {
-            processChild(child.value);
-            return;
-        }
-        console.warn('[@ktjs/core warn]','Fragment: unsupported child type', child);
-    };
-    processChild(children);
-    return elements;
-}
 
-const jsxh = (tag, props) => (typeof tag === 'function' ? tag(props) : h(tag, props, props.children));
-const placeholder = (data) => document.createComment(data);
+const jsxh = (tag, props) => "function" == typeof tag ? tag(props) : h(tag, props, props.children), placeholder = data => document.createComment(data);
 
 function create(creator, tag, props) {
-    if (props.ref && isComputed(props.ref)) {
-        throw new Error('[@ktjs/core error] Cannot assign a computed value to an element.');
-    }
+    if (props.ref && isComputed(props.ref)) throw new Error("[@ktjs/core error] Cannot assign a computed value to an element.");
     const el = creator(tag, props, props.children);
-    $initRef(props, el);
-    return el;
+    return $initRef(props, el), el;
 }
-const jsx = (tag, props) => create(jsxh, tag, props);
-const svg = (tag, props) => create(svg$1, tag, props);
-const mathml = (tag, props) => create(mathml$1, tag, props);
-/**
- * Fragment support - returns an array of children
- * Enhanced Fragment component that manages arrays of elements
- */
+
+const jsx = (tag, props) => create(jsxh, tag, props), svg = (tag, props) => create(svg$1, tag, props), mathml = (tag, props) => create(mathml$1, tag, props);
+
 function Fragment(props) {
-    const { children } = props ?? {};
-    if (!children) {
-        return placeholder('kt-fragment-empty');
-    }
-    const elements = convertChildrenToElements(children);
-    return Fragment$1({ children: elements });
+    const {children: children} = props ?? {};
+    if (!children) return placeholder("kt-fragment-empty");
+    const elements = function(children) {
+        const elements = [], processChild = child => {
+            if (null != child && !1 !== child && !0 !== child) if ($isArray(child)) $forEach(child, processChild); else {
+                if ("string" == typeof child || "number" == typeof child) {
+                    const span = document.createElement("span");
+                    return span.textContent = String(child), void elements.push(span);
+                }
+                if (child instanceof HTMLElement) elements.push(child); else {
+                    if (!isKT(child)) throw console.warn("[@ktjs/core warn]", "Fragment: unsupported child type", child), 
+                    new Error("Fragment: unsupported child type");
+                    processChild(child.value);
+                }
+            }
+        };
+        return processChild(children), elements;
+    }(children);
+    return function(props) {
+        const elements = [], anchor = document.createComment("kt-fragment");
+        let observer, inserted = !1;
+        const redraw = () => {
+            const newElements = childrenRef.value, parent = anchor.parentNode;
+            if (!parent) {
+                elements.length = 0;
+                for (let i = 0; i < newElements.length; i++) elements.push(newElements[i]);
+                return void (anchor.__kt_fragment_list__ = elements);
+            }
+            for (let i = 0; i < elements.length; i++) elements[i].remove();
+            const fragment = document.createDocumentFragment();
+            elements.length = 0;
+            for (let i = 0; i < newElements.length; i++) {
+                const element = newElements[i];
+                elements.push(element), fragment.appendChild(element);
+            }
+            parent.insertBefore(fragment, anchor.nextSibling), inserted = !0, delete anchor.__kt_fragment_mount__, 
+            observer?.disconnect(), observer = void 0, anchor.__kt_fragment_list__ = elements;
+        }, childrenRef = toReactive(props.children).addOnChange(redraw);
+        return (() => {
+            const current = childrenRef.value;
+            elements.length = 0;
+            const fragment = document.createDocumentFragment();
+            for (let i = 0; i < current.length; i++) {
+                const element = current[i];
+                elements.push(element), fragment.appendChild(element);
+            }
+            anchor.__kt_fragment_list__ = elements;
+            const parent = anchor.parentNode;
+            parent && !inserted && (parent.insertBefore(fragment, anchor.nextSibling), inserted = !0);
+        })(), anchor.__kt_fragment_mount__ = () => {
+            !inserted && anchor.parentNode && redraw();
+        }, observer = new MutationObserver(() => {
+            anchor.parentNode && !inserted && (redraw(), observer?.disconnect(), observer = void 0);
+        }), observer.observe(document.body, {
+            childList: !0,
+            subtree: !0
+        }), $initRef(props, anchor), anchor;
+    }({
+        children: elements
+    });
 }
-/**
- * JSX Development runtime - same as jsx but with additional dev checks
- */
-const jsxDEV = (...args) => {
-    // console.log('JSX DEV called:', ...args);
-    // console.log('children', (args[1] as any)?.children);
-    return jsx(...args);
-};
-/**
- * JSX runtime for React 17+ automatic runtime
- * This is called when using jsx: "react-jsx" or "react-jsxdev"
- */
-const jsxs = jsx;
+
+const jsxDEV = (...args) => jsx(...args), jsxs = jsx;
 
 function KTAsync(props) {
     const raw = props.component(props);
-    let comp = props.skeleton ?? document.createComment('ktjs-suspense-placeholder');
-    if ($isThenable(raw)) {
-        raw.then((resolved) => comp.replaceWith(resolved));
-    }
-    else {
-        comp = raw;
-    }
-    return comp;
+    let comp = props.skeleton ?? document.createComment("ktjs-suspense-placeholder");
+    return $isThenable(raw) ? raw.then(resolved => comp.replaceWith(resolved)) : comp = raw, 
+    comp;
 }
 
-// task 对于template标签的for和if，会编译为fragment，可特殊处理，让它们保持原样
-/**
- * KTFor - List rendering component with key-based optimization
- * Returns a Comment anchor node with rendered elements in __kt_for_list__
- */
 function KTFor(props) {
-    const redraw = () => {
-        const newList = listRef.value;
-        const parent = anchor.parentNode;
+    const {key: currentKey = item => item, map: currentMap = $identity} = props, listRef = toReactive(props.list).addOnChange(() => {
+        const newList = listRef.value, parent = anchor.parentNode;
         if (!parent) {
-            // If not in DOM yet, just rebuild the list
             const newElements = [];
             nodeMap.clear();
             for (let index = 0; index < newList.length; index++) {
-                const item = newList[index];
-                const itemKey = currentKey(item, index, newList);
-                const node = currentMap(item, index, newList);
-                nodeMap.set(itemKey, node);
-                newElements.push(node);
+                const item = newList[index], itemKey = currentKey(item, index, newList), node = currentMap(item, index, newList);
+                nodeMap.set(itemKey, node), newElements.push(node);
             }
-            anchor.__kt_for_list__ = newElements;
-            return anchor;
-        }
-        const oldLength = anchor.__kt_for_list__.length;
-        const newLength = newList.length;
-        // Fast path: empty list
-        if (newLength === 0) {
-            nodeMap.forEach((node) => node.remove());
-            nodeMap.clear();
-            anchor.__kt_for_list__ = [];
-            return anchor;
+            return anchor.__kt_for_list__ = newElements, anchor;
         }
-        // Fast path: all new items
-        if (oldLength === 0) {
-            const newElements = [];
-            const fragment = document.createDocumentFragment();
+        const oldLength = anchor.__kt_for_list__.length, newLength = newList.length;
+        if (0 === newLength) return nodeMap.forEach(node => node.remove()), nodeMap.clear(), 
+        anchor.__kt_for_list__ = [], anchor;
+        if (0 === oldLength) {
+            const newElements = [], fragment = document.createDocumentFragment();
             for (let i = 0; i < newLength; i++) {
-                const item = newList[i];
-                const itemKey = currentKey(item, i, newList);
-                const node = currentMap(item, i, newList);
-                nodeMap.set(itemKey, node);
-                newElements.push(node);
-                fragment.appendChild(node);
+                const item = newList[i], itemKey = currentKey(item, i, newList), node = currentMap(item, i, newList);
+                nodeMap.set(itemKey, node), newElements.push(node), fragment.appendChild(node);
             }
-            parent.insertBefore(fragment, anchor.nextSibling);
-            anchor.__kt_for_list__ = newElements;
-            return anchor;
+            return parent.insertBefore(fragment, anchor.nextSibling), anchor.__kt_for_list__ = newElements, 
+            anchor;
         }
-        // Build key index map and new elements array in one pass
-        const newKeyToNewIndex = new Map();
-        const newElements = new Array(newLength);
-        let maxNewIndexSoFar = 0;
-        let moved = false;
+        const newKeyToNewIndex = new Map, newElements = new Array(newLength);
+        let maxNewIndexSoFar = 0, moved = !1;
         for (let i = 0; i < newLength; i++) {
-            const item = newList[i];
-            const itemKey = currentKey(item, i, newList);
-            newKeyToNewIndex.set(itemKey, i);
-            if (nodeMap.has(itemKey)) {
-                // Reuse existing node
+            const item = newList[i], itemKey = currentKey(item, i, newList);
+            if (newKeyToNewIndex.set(itemKey, i), nodeMap.has(itemKey)) {
                 const node = nodeMap.get(itemKey);
-                newElements[i] = node;
-                // Track if items moved
-                if (i < maxNewIndexSoFar) {
-                    moved = true;
-                }
-                else {
-                    maxNewIndexSoFar = i;
-                }
-            }
-            else {
-                // Create new node
-                newElements[i] = currentMap(item, i, newList);
-            }
+                newElements[i] = node, i < maxNewIndexSoFar ? moved = !0 : maxNewIndexSoFar = i;
+            } else newElements[i] = currentMap(item, i, newList);
         }
-        // Remove nodes not in new list
         const toRemove = [];
         nodeMap.forEach((node, key) => {
-            if (!newKeyToNewIndex.has(key)) {
-                toRemove.push(node);
-            }
+            newKeyToNewIndex.has(key) || toRemove.push(node);
         });
-        for (let i = 0; i < toRemove.length; i++) {
-            toRemove[i].remove();
-        }
-        // Update DOM with minimal operations
+        for (let i = 0; i < toRemove.length; i++) toRemove[i].remove();
         if (moved) {
-            // Use longest increasing subsequence to minimize moves
-            const seq = getSequence(newElements.map((el, i) => (nodeMap.has(currentKey(newList[i], i, newList)) ? i : -1)));
-            let j = seq.length - 1;
-            let anchor = null;
-            // Traverse from end to start for stable insertions
-            for (let i = newLength - 1; i >= 0; i--) {
-                const node = newElements[i];
-                if (j < 0 || i !== seq[j]) {
-                    // Node needs to be moved or inserted
-                    if (anchor) {
-                        parent.insertBefore(node, anchor);
-                    }
-                    else {
-                        // Insert at end
-                        let temp = anchor.nextSibling; // ?? 这里难道不是null？
-                        while (temp && newElements.includes(temp)) {
-                            temp = temp.nextSibling;
-                        }
-                        parent.insertBefore(node, temp);
+            const seq = function(arr) {
+                const p = arr.slice(), result = [ 0 ];
+                let i, j, u, v, c;
+                const len = arr.length;
+                for (i = 0; i < len; i++) {
+                    const arrI = arr[i];
+                    if (-1 !== arrI) if (j = result[result.length - 1], arr[j] < arrI) p[i] = j, result.push(i); else {
+                        for (u = 0, v = result.length - 1; u < v; ) c = (u + v) / 2 | 0, arr[result[c]] < arrI ? u = c + 1 : v = c;
+                        arrI < arr[result[u]] && (u > 0 && (p[i] = result[u - 1]), result[u] = i);
                     }
                 }
-                else {
-                    j--;
-                }
+                u = result.length, v = result[u - 1];
+                for (;u-- > 0; ) result[u] = v, v = p[v];
+                return result;
+            }(newElements.map((el, i) => nodeMap.has(currentKey(newList[i], i, newList)) ? i : -1));
+            let j = seq.length - 1, anchor = null;
+            for (let i = newLength - 1; i >= 0; i--) {
+                const node = newElements[i];
+                if (j < 0 || i !== seq[j]) if (anchor) parent.insertBefore(node, anchor); else {
+                    let temp = anchor.nextSibling;
+                    for (;temp && newElements.includes(temp); ) temp = temp.nextSibling;
+                    parent.insertBefore(node, temp);
+                } else j--;
                 anchor = node;
             }
-        }
-        else {
-            // No moves needed, just insert new nodes
+        } else {
             let currentNode = anchor.nextSibling;
             for (let i = 0; i < newLength; i++) {
                 const node = newElements[i];
-                if (currentNode !== node) {
-                    parent.insertBefore(node, currentNode);
-                }
-                else {
-                    currentNode = currentNode.nextSibling;
-                }
+                currentNode !== node ? parent.insertBefore(node, currentNode) : currentNode = currentNode.nextSibling;
             }
         }
-        // Update maps
         nodeMap.clear();
         for (let i = 0; i < newLength; i++) {
             const itemKey = currentKey(newList[i], i, newList);
             nodeMap.set(itemKey, newElements[i]);
         }
-        anchor.__kt_for_list__ = newElements;
-        return anchor;
-    };
-    const { key: currentKey = (item) => item, map: currentMap = $identity } = props;
-    const listRef = toReactive(props.list).addOnChange(redraw);
-    const anchor = document.createComment('kt-for');
-    // Map to track rendered nodes by key
-    const nodeMap = new Map();
-    // Render initial list
-    const elements = [];
+        return anchor.__kt_for_list__ = newElements, anchor;
+    }), anchor = document.createComment("kt-for"), nodeMap = new Map, elements = [];
     for (let index = 0; index < listRef.value.length; index++) {
-        const item = listRef.value[index];
-        const itemKey = currentKey(item, index, listRef.value);
-        const node = currentMap(item, index, listRef.value);
-        nodeMap.set(itemKey, node);
-        elements.push(node);
+        const item = listRef.value[index], itemKey = currentKey(item, index, listRef.value), node = currentMap(item, index, listRef.value);
+        nodeMap.set(itemKey, node), elements.push(node);
     }
-    anchor.__kt_for_list__ = elements;
-    $initRef(props, anchor);
-    return anchor;
-}
-// Longest Increasing Subsequence algorithm (optimized for diff)
-function getSequence(arr) {
-    const p = arr.slice();
-    const result = [0];
-    let i, j, u, v, c;
-    const len = arr.length;
-    for (i = 0; i < len; i++) {
-        const arrI = arr[i];
-        if (arrI === -1)
-            continue;
-        j = result[result.length - 1];
-        if (arr[j] < arrI) {
-            p[i] = j;
-            result.push(i);
-            continue;
-        }
-        u = 0;
-        v = result.length - 1;
-        while (u < v) {
-            c = ((u + v) / 2) | 0;
-            if (arr[result[c]] < arrI) {
-                u = c + 1;
-            }
-            else {
-                v = c;
-            }
-        }
-        if (arrI < arr[result[u]]) {
-            if (u > 0) {
-                p[i] = result[u - 1];
-            }
-            result[u] = i;
-        }
-    }
-    u = result.length;
-    v = result[u - 1];
-    while (u-- > 0) {
-        result[u] = v;
-        v = p[v];
-    }
-    return result;
+    return anchor.__kt_for_list__ = elements, $initRef(props, anchor), anchor;
 }
 
 function KTConditional(condition, tagIf, propsIf, tagElse, propsElse) {
-    if (!isKT(condition)) {
-        return condition ? jsxh(tagIf, propsIf) : tagElse ? jsxh(tagElse, propsElse) : placeholder('kt-conditional');
-    }
+    if (!isKT(condition)) return condition ? jsxh(tagIf, propsIf) : tagElse ? jsxh(tagElse, propsElse) : placeholder("kt-conditional");
     if (tagElse) {
         let current = condition.value ? jsxh(tagIf, propsIf) : jsxh(tagElse, propsElse);
-        condition.addOnChange((newValue) => {
+        return condition.addOnChange(newValue => {
             const old = current;
-            current = newValue ? jsxh(tagIf, propsIf) : jsxh(tagElse, propsElse);
-            old.replaceWith(current);
-        });
-        return current;
+            current = newValue ? jsxh(tagIf, propsIf) : jsxh(tagElse, propsElse), old.replaceWith(current);
+        }), current;
     }
-    else {
-        const dummy = placeholder('kt-conditional');
+    {
+        const dummy = placeholder("kt-conditional");
         let current = condition.value ? jsxh(tagIf, propsIf) : dummy;
-        condition.addOnChange((newValue) => {
+        return condition.addOnChange(newValue => {
             const old = current;
-            current = newValue ? jsxh(tagIf, propsIf) : dummy;
-            old.replaceWith(current);
-        });
-        return current;
+            current = newValue ? jsxh(tagIf, propsIf) : dummy, old.replaceWith(current);
+        }), current;
     }
 }