@ktjs/core 0.32.4 → 0.33.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { $isArray, $isThenable, $isNode, $is, $emptyFn, $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) => {
@@ -7,15 +7,9 @@ const isRef = (obj) => {
     if (obj.ktType === undefined) {
         return false;
     }
-    return obj.ktType >= 2 /* KTReactiveType.Ref */ && obj.ktType <= 8 /* KTReactiveType.DateRef */;
+    return obj.ktType === 3 /* KTReactiveType.Ref */;
 };
-const isArrayRef = (obj) => obj?.ktType === 3 /* KTReactiveType.ArrayRef */;
-const isMapRef = (obj) => obj?.ktType === 4 /* KTReactiveType.MapRef */;
-const isSetRef = (obj) => obj?.ktType === 5 /* KTReactiveType.SetRef */;
-const isWeakMapRef = (obj) => obj?.ktType === 6 /* KTReactiveType.WeakMapRef */;
-const isWeakSetRef = (obj) => obj?.ktType === 7 /* KTReactiveType.WeakSetRef */;
-const isDateRef = (obj) => obj?.ktType === 8 /* KTReactiveType.DateRef */;
-const isComputed = (obj) => obj?.ktType === 1 /* KTReactiveType.Computed */;
+const isComputed = (obj) => obj?.ktType === 2 /* KTReactiveType.Computed */;
 
 const booleanHandler = (element, key, value) => {
     if (key in element) {
@@ -215,22 +209,14 @@ const IdGenerator = {
     _refOnChangeId: 1,
     get refOnChangeId() {
         return this._refOnChangeId++;
-    },
-    _computedOnChangeId: 1,
-    get computedOnChangeId() {
-        return this._computedOnChangeId++;
     }};
 
-class KTComputed {
+class KTReactive {
     /**
      * Indicates that this is a KTRef instance
      */
     isKT = true;
-    ktType = 1 /* KTReactiveType.Computed */;
-    /**
-     * @internal
-     */
-    _calculator;
+    ktType = 1 /* KTReactiveType.Reative */;
     /**
      * @internal
      */
@@ -238,146 +224,93 @@ class KTComputed {
     /**
      * @internal
      */
-    _onChanges = new Map();
+    _changeHandlers = new Map();
     /**
      * @internal
      */
     _emit(newValue, oldValue, handlerKeys) {
         if (handlerKeys) {
             for (let i = 0; i < handlerKeys.length; i++) {
-                this._onChanges.get(handlerKeys[i])?.(newValue, oldValue);
+                this._changeHandlers.get(handlerKeys[i])?.(newValue, oldValue);
             }
-            return;
-        }
-        this._onChanges.forEach((c) => c(newValue, oldValue));
-    }
-    /**
-     * @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._value = newValue;
-        this._emit(newValue, oldValue, handlerKeys);
-    }
-    /**
-     * @internal
-     */
-    _subscribe(reactives) {
-        for (let i = 0; i < reactives.length; i++) {
-            const reactive = reactives[i];
-            reactive.addOnChange(() => this._recalculate());
+            return this;
         }
+        this._changeHandlers.forEach((c) => c(newValue, oldValue));
+        return this;
     }
-    constructor(_calculator, reactives) {
-        this._calculator = _calculator;
-        this._value = _calculator();
-        this._subscribe(reactives);
+    constructor(_value) {
+        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) {
-        throw new Error('[@ktjs/core error] KTComputed: cannot set value of a computed value');
-    }
-    /**
-     * Force listeners to run once with the latest computed result.
-     */
-    notify(handlerKeys) {
-        this._recalculate(true, handlerKeys);
+        // Only allow KTRef to be set.
     }
     /**
-     * Computed values are derived from dependencies and should not be mutated manually.
+     * 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`
      */
-    mutate(_mutator, handlerKeys) {
-        console.warn('[@ktjs/core warn]','KTComputed.mutate: computed is derived automatically; manual mutate is ignored. Use notify() instead');
-        if (handlerKeys) {
-            this._emit(this._value, this._value, handlerKeys);
-        }
-        return this._value;
+    notify(..._args) {
+        throw new Error('This is meant to be override in ref.ts and computed.ts');
     }
-    toComputed(calculator, dependencies) {
-        return computed(() => calculator(this.value), dependencies ? [this, ...dependencies] : [this]);
+    map(..._args) {
+        throw new Error('This is meant to be override in computed.ts');
     }
     /**
      * Register a callback when the value changes
-     * @param callback (newValue, oldValue) => xxx
+     * @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] KTComputed.addOnChange: callback must be a function');
+            throw new Error('[@ktjs/core error] KTRef.addOnChange: callback must be a function');
         }
-        const k = key ?? IdGenerator.computedOnChangeId;
-        this._onChanges.set(k, callback);
-        return k;
+        const k = key ?? IdGenerator.refOnChangeId;
+        this._changeHandlers.set(k, callback);
+        return this;
     }
-    /**
-     * Unregister a callback
-     * @param key registered listener key
-     */
     removeOnChange(key) {
-        const callback = this._onChanges.get(key);
-        this._onChanges.delete(key);
+        const callback = this._changeHandlers.get(key);
+        this._changeHandlers.delete(key);
         return callback;
     }
 }
-/**
- * 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');
-    }
-    return new KTComputed(computeFn, dependencies);
-}
 
-class KTRef {
-    /**
-     * Indicates that this is a KTRef instance
-     */
-    isKT = true;
-    ktType = 2 /* KTReactiveType.Ref */;
-    /**
-     * @internal
-     */
-    _value;
-    /**
-     * @internal
-     */
-    _onChanges;
-    /**
-     * @internal
-     */
-    _emit(newValue, oldValue, handlerKeys) {
-        if (handlerKeys) {
-            for (let i = 0; i < handlerKeys.length; i++) {
-                this._onChanges.get(handlerKeys[i])?.(newValue, oldValue);
-            }
+// 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;
         }
-        this._onChanges.forEach((c) => c(newValue, oldValue));
-    }
-    constructor(_value, _onChange) {
-        this._value = _value;
-        this._onChanges = new Map();
-        if (_onChange) {
-            this._onChanges.set(IdGenerator.refOnChangeId, _onChange);
-        }
+        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();
+        });
     }
-    /**
-     * If new value and old value are both nodes, the old one will be replaced in the DOM
-     */
+};
+
+class KTRef extends KTReactive {
+    ktType = 3 /* KTReactiveType.Ref */;
+    // ! Cannot be omitted, otherwise this will override `KTReactive` with only setter. And getter will return undefined.
     get value() {
         return this._value;
     }
@@ -389,317 +322,29 @@ class KTRef {
         this._value = newValue;
         this._emit(newValue, oldValue);
     }
-    /**
-     * Force all listeners to run even when reference identity has not changed.
-     * Useful for in-place array/object mutations.
-     */
-    notify(handlerKeys) {
-        this._emit(this._value, this._value, handlerKeys);
-    }
-    /**
-     * Mutate current value in-place and notify listeners once.
-     *
-     * @example
-     * const items = ref<number[]>([1, 2]);
-     * items.mutate((list) => list.push(3));
-     */
-    mutate(mutator, handlerKeys) {
-        if (typeof mutator !== 'function') {
-            throw new Error('[@ktjs/core error] KTRef.mutate: mutator must be a function');
-        }
-        const oldValue = this._value;
-        const result = mutator(this._value);
-        this._emit(this._value, oldValue, handlerKeys);
-        return result;
-    }
-    toComputed(calculator, dependencies) {
-        return computed(() => calculator(this.value), dependencies ? [this, ...dependencies] : [this]);
-    }
-    /**
-     * Register a callback when the value changes
-     * @param callback (newValue, oldValue) => xxx
-     * @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.
-     */
-    addOnChange(callback, key) {
-        if (typeof callback !== 'function') {
-            throw new Error('[@ktjs/core error] KTRef.addOnChange: callback must be a function');
-        }
-        const k = key ?? IdGenerator.refOnChangeId;
-        this._onChanges.set(k, callback);
-        return k;
-    }
-    removeOnChange(key) {
-        const callback = this._onChanges.get(key);
-        this._onChanges.delete(key);
-        return callback;
-    }
-}
-
-/**
- * Calls the setter-like function and emit all changes of it
- */
-const apply = (r, setter, args) => {
-    const v = r.value;
-    const result = setter.apply(v, args);
-    r._onChanges.forEach((handler) => handler(v, v));
-    return result;
-};
-const applyArgless = (r, setter) => {
-    const v = r.value;
-    const result = setter.apply(v);
-    r._onChanges.forEach((handler) => handler(v, v));
-    return result;
-};
-
-class KTArrayRef extends KTRef {
-    constructor(value, onChange) {
-        super(value, onChange);
-        this.ktType = 3 /* KTReactiveType.ArrayRef */;
-    }
-    get length() {
-        return this.value.length;
-    }
-    set length(newLength) {
-        this._value.length = newLength;
-        this._onChanges.forEach((handler) => handler(this._value, this._value));
-    }
-    push(...items) {
-        return apply(this, this._value.push, items);
-    }
-    /**
-     * Same as `Array.prototype.pop`, but emits change after calling it
-     */
-    pop() {
-        return applyArgless(this, this._value.pop);
-    }
-    /**
-     * Same as `Array.prototype.shift`, but emits change after calling it
-     */
-    shift() {
-        return applyArgless(this, this._value.shift);
-    }
-    /**
-     * Same as `Array.prototype.unshift`, but emits change after calling it
-     */
-    unshift(...items) {
-        return apply(this, this._value.unshift, items);
-    }
-    splice(...args) {
-        return apply(this, this._value.splice, args);
-    }
-    sort(...args) {
-        apply(this, this._value.sort, args);
-        return this;
+    // todo 编译器要对这个属性的逃逸（也就是什么都没改或者被赋值）进行检测，比如const a = xxx.draft.
+    get draft() {
+        markMutation(this);
+        return this._value;
     }
     /**
-     * Same as `Array.prototype.reverse`, but emits change after calling it
+     * Force all listeners to run even when reference identity has not changed.
      */
-    reverse() {
-        applyArgless(this, this._value.reverse);
-        return this;
-    }
-    fill(...args) {
-        apply(this, this._value.fill, args);
-        return this;
-    }
-    copyWithin(...args) {
-        apply(this, this._value.copyWithin, args);
-        return this;
-    }
-}
-const arrayRef = (value, onChange) => new KTArrayRef(value, onChange);
-
-class KTDateRef extends KTRef {
-    constructor(value, onChange) {
-        super(value, onChange);
-        this.ktType = 8 /* KTReactiveType.DateRef */;
-    }
-    setTime(timeValue) {
-        return apply(this, this._value.setTime, [timeValue]);
-    }
-    setMilliseconds(millisecondsValue) {
-        return apply(this, this._value.setMilliseconds, [millisecondsValue]);
-    }
-    setUTCMilliseconds(millisecondsValue) {
-        return apply(this, this._value.setUTCMilliseconds, [millisecondsValue]);
-    }
-    setSeconds(...args) {
-        return apply(this, this._value.setSeconds, args);
-    }
-    setUTCSeconds(...args) {
-        return apply(this, this._value.setUTCSeconds, args);
-    }
-    setMinutes(...args) {
-        return apply(this, this._value.setMinutes, args);
-    }
-    setUTCMinutes(...args) {
-        return apply(this, this._value.setUTCMinutes, args);
-    }
-    setHours(...args) {
-        return apply(this, this._value.setHours, args);
-    }
-    setUTCHours(...args) {
-        return apply(this, this._value.setUTCHours, args);
-    }
-    setDate(dateValue) {
-        return apply(this, this._value.setDate, [dateValue]);
-    }
-    setUTCDate(dateValue) {
-        return apply(this, this._value.setUTCDate, [dateValue]);
-    }
-    setMonth(...args) {
-        return apply(this, this._value.setMonth, args);
-    }
-    setUTCMonth(...args) {
-        return apply(this, this._value.setUTCMonth, args);
-    }
-    setFullYear(...args) {
-        return apply(this, this._value.setFullYear, args);
-    }
-    setUTCFullYear(...args) {
-        return apply(this, this._value.setUTCFullYear, args);
-    }
-}
-const dateRef = (value, onChange) => new KTDateRef(value, onChange);
-
-class KTMapRef extends KTRef {
-    constructor(value, onChange) {
-        super(value, onChange);
-        this.ktType = 4 /* KTReactiveType.MapRef */;
-    }
-    get size() {
-        return this._value.size;
-    }
-    has(key) {
-        return this._value.has(key);
-    }
-    get(key) {
-        return this._value.get(key);
-    }
-    set(key, value) {
-        apply(this, this._value.set, [key, value]);
-        return this;
-    }
-    delete(key) {
-        return apply(this, this._value.delete, [key]);
-    }
-    clear() {
-        return applyArgless(this, this._value.clear);
+    notify(oldValue = this._value, newValue = this._value, handlerKeys) {
+        return this._emit(newValue, oldValue, handlerKeys);
     }
 }
-const mapRef = (value, onChange) => new KTMapRef(value, onChange);
-
-class KTSetRef extends KTRef {
-    constructor(value, onChange) {
-        super(value, onChange);
-        this.ktType = 5 /* KTReactiveType.SetRef */;
-    }
-    get size() {
-        return this._value.size;
-    }
-    has(value) {
-        return this._value.has(value);
-    }
-    add(value) {
-        apply(this, this._value.add, [value]);
-        return this;
-    }
-    delete(value) {
-        return apply(this, this._value.delete, [value]);
-    }
-    clear() {
-        return applyArgless(this, this._value.clear);
-    }
-}
-const setRef = (value, onChange) => new KTSetRef(value, onChange);
-
-class KTWeakMapRef extends KTRef {
-    constructor(value, onChange) {
-        super(value, onChange);
-        this.ktType = 6 /* KTReactiveType.WeakMapRef */;
-    }
-    has(key) {
-        return this._value.has(key);
-    }
-    get(key) {
-        return this._value.get(key);
-    }
-    set(key, value) {
-        apply(this, this._value.set, [key, value]);
-        return this;
-    }
-    delete(key) {
-        return apply(this, this._value.delete, [key]);
-    }
-}
-const weakMapRef = (value, onChange) => new KTWeakMapRef(value, onChange);
-
-class KTWeakSetRef extends KTRef {
-    constructor(value, onChange) {
-        super(value, onChange);
-        this.ktType = 7 /* KTReactiveType.WeakSetRef */;
-    }
-    has(value) {
-        return this._value.has(value);
-    }
-    add(value) {
-        apply(this, this._value.add, [value]);
-        return this;
-    }
-    delete(value) {
-        return apply(this, this._value.delete, [value]);
-    }
-}
-const weakSetRef = (value, onChange) => new KTWeakSetRef(value, onChange);
-
 /**
- * Reference to the created HTML element or other reactive data.
- * - **Only** respond to `ref.value` changes, not reactive to internal changes of the element.
- * - Automatically wrap the value with corresponding ref type based on its type.
- *   - When wrapped, setter-like methods will be reactive. like `push` for `Array`, `set` for `Map`, `add` for `Set`, etc.
- *   - Supports: `Array`, `Map`, `Set`, `WeakMap`, `WeakSet`, `Date`.
- *   - Since there will be some cost for runtime detection, and compilation plugin might not be able to analyze all cases. It is recommended to use specific ref type directly if you already know the type of value, like `ref.array`, `ref.map`, etc.
- * @param value any data
- * @param onChange event handler triggered when the value changes, with signature `(newValue, oldValue) => void`
- */
-function autoRef(value, onChange) {
-    if (Array.isArray(value)) {
-        return arrayRef(value, onChange);
-    }
-    if (value instanceof Map) {
-        return mapRef(value, onChange);
-    }
-    if (value instanceof Set) {
-        return setRef(value, onChange);
-    }
-    if (value instanceof WeakMap) {
-        return weakMapRef(value, onChange);
-    }
-    if (value instanceof WeakSet) {
-        return weakSetRef(value, onChange);
-    }
-    if (value instanceof Date) {
-        return dateRef(value, onChange);
-    }
-    return new KTRef(value, onChange);
-}
-// todo 编译时期，插件要尽量分析出谁是谁，并基于最大限度的覆写支持，避免运行时for循环创建ref
-/**
- * Create a plain `KTRef` object.
- *
- * If you want the value to be automatically wrapped with corresponding ref type based on its type, please use `autoRef` instead.
+ * 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, onChange) => new KTRef(value, onChange));
-ref.array = arrayRef;
-ref.date = dateRef;
-ref.map = mapRef;
-ref.set = setRef;
-ref.weakMap = weakMapRef;
-ref.weakSet = weakSetRef;
+const ref = (value) => new KTRef(value);
 /**
  * Assert k-model to be a ref object
  */
@@ -734,6 +379,67 @@ const $initRef = (props, node) => {
     }
 };
 
+class KTComputed extends KTReactive {
+    ktType = 2 /* KTReactiveType.Computed */;
+    /**
+     * @internal
+     */
+    _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;
+    }
+    // todo 侦听的dependency数量比较多的，纳入scheduler
+    constructor(_calculator, dependencies) {
+        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.`);
+    }
+    /**
+     * Force listeners to run once with the latest computed result.
+     */
+    notify(handlerKeys) {
+        return this._recalculate(true, 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');
+    }
+    return new KTComputed(computeFn, dependencies);
+}
+
 /**
  * Register a reactive effect with options.
  * @param effectFn The effect function to run when dependencies change
@@ -760,7 +466,8 @@ function effect(effectFn, reactives, options) {
     };
     // subscribe to dependencies
     for (let i = 0; i < reactives.length; i++) {
-        listenerKeys[i] = reactives[i].addOnChange(run);
+        listenerKeys[i] = i;
+        reactives[i].addOnChange(run, i);
     }
     // auto run unless lazy
     if (!lazy) {
@@ -780,17 +487,12 @@ function effect(effectFn, reactives, options) {
     };
 }
 
-const toReactive = (value, onChange) => {
-    if (isKT(value)) {
-        if (onChange) {
-            value.addOnChange(onChange);
-        }
-        return value;
-    }
-    else {
-        return ref(value, onChange);
-    }
-};
+/**
+ *
+ * @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.
  */
@@ -838,7 +540,7 @@ function applyKModel(element, valueRef) {
  * ## About
  * @package @ktjs/core
  * @author Kasukabe Tsumugi <futami16237@gmail.com>
- * @version 0.32.4 (Last Update: 2026.03.19 08:48:40.357)
+ * @version 0.33.0 (Last Update: 2026.03.21 22:19:51.700)
  * @license MIT
  * @link https://github.com/baendlorel/kt.js
  * @link https://baendlorel.github.io/ Welcome to my site!
@@ -963,7 +665,7 @@ function Fragment$1(props) {
         observer = undefined;
         anchor.__kt_fragment_list__ = elements;
     };
-    const childrenRef = toReactive(props.children, redraw);
+    const childrenRef = toReactive(props.children).addOnChange(redraw);
     const renderInitial = () => {
         const current = childrenRef.value;
         elements.length = 0;
@@ -1026,7 +728,7 @@ function convertChildrenToElements(children) {
             processChild(child.value);
             return;
         }
-        console.warn('Fragment: unsupported child type', child);
+        console.warn('[@ktjs/core warn]','Fragment: unsupported child type', child);
     };
     processChild(children);
     return elements;
@@ -1084,7 +786,7 @@ function KTAsync(props) {
     return comp;
 }
 
-// todo 对于template标签的for和if，会编译为fragment，可特殊处理，让它们保持原样
+// 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__
@@ -1184,8 +886,7 @@ function KTFor(props) {
                     }
                     else {
                         // Insert at end
-                        let nextSibling = anchor.nextSibling;
-                        let temp = nextSibling;
+                        let temp = anchor.nextSibling; // ?? 这里难道不是null？
                         while (temp && newElements.includes(temp)) {
                             temp = temp.nextSibling;
                         }
@@ -1221,7 +922,7 @@ function KTFor(props) {
         return anchor;
     };
     const { key: currentKey = (item) => item, map: currentMap = $identity } = props;
-    const listRef = toReactive(props.list, redraw);
+    const listRef = toReactive(props.list).addOnChange(redraw);
     const anchor = document.createComment('kt-for');
     // Map to track rendered nodes by key
     const nodeMap = new Map();
@@ -1306,5 +1007,5 @@ function KTConditional(condition, tagIf, propsIf, tagElse, propsElse) {
     }
 }
 
-export { $initRef, $modelOrRef, Fragment, KTArrayRef, KTAsync, KTComputed, KTConditional, KTDateRef, KTFor, KTMapRef, KTSetRef, KTWeakMapRef, KTWeakSetRef, applyAttr, autoRef, computed, h as createElement, mathml$1 as createMathMLElement, svg$1 as createSVGElement, dereactive, effect, h, isArrayRef, isComputed, isDateRef, isKT, isMapRef, isRef, isSetRef, isWeakMapRef, isWeakSetRef, jsx, jsxDEV, jsxs, mathml, mathml as mathmlRuntime, ref, svg, svg as svgRuntime, toReactive };
+export { $initRef, $modelOrRef, Fragment, KTAsync, KTComputed, KTConditional, KTFor, KTRef, applyAttr, computed, h as createElement, mathml$1 as createMathMLElement, svg$1 as createSVGElement, dereactive, effect, h, isComputed, isKT, isRef, jsx, jsxDEV, jsxs, mathml, mathml as mathmlRuntime, ref, svg, svg as svgRuntime, toReactive };
 //# sourceMappingURL=index.mjs.map