@ktjs/core 0.35.0 → 0.36.1

package/README.md

@@ -17,7 +17,9 @@
 
 ## Recent Updates
 
-1. 0.35.x - `reactive.get('a','b')` is a shortcut for `reactive.map((v) => v.a.b)`. By default it has 5 levels of type annotations and it's convienient for common use cases.
+1. 0.36.x - override 0.35.x. Now refs and computeds have 2 new apis:
+   1. `get(...keys)`: create a `KTSubComputed` object. It is a light version of computed, used to bind values
+   2. `subref(...keys)`: create a `KTSubRef` object. It is a light version of ref, used to bind values and also support two-way binding with `k-model`.
 2. 0.34.x - `ref.notify()` no-longer has an optional argument.
 3. 0.33.x - `ref.value` remains the standard read API, and it can also replace the whole outer value with `ref.value = nextValue`.
 4. 0.33.x - `ref.draft` is the deep-mutation entry for literally any objects. Just use `someRef.draft.a = someValue`, and kt.js will add it to microqueue and redraw it on the next tick. Works for `Map`, `Set`, `Array`, `Date` and your custom objects.

package/dist/index.d.ts

@@ -1,42 +1,99 @@
 import { otherstring, HTMLTag, SVGTag, MathMLTag, JSXTag } from '@ktjs/shared';
 export { HTMLTag, InputElementTag, MathMLTag, SVGTag } from '@ktjs/shared';
 
-interface KTEffectOptions {
-    lazy: boolean;
-    onCleanup: () => void;
-    debugName: string;
+declare class KTComputed<T> extends KTReactive<T> {
+    readonly ktype = KTReactiveType.Computed;
+    private readonly _calculator;
+    private _recalculate;
+    constructor(calculator: () => T, dependencies: Array<KTReactiveLike<any>>);
+    notify(): this;
 }
+declare class KTSubComputed<T> extends KTSubReactive<T> {
+    readonly ktype = KTReactiveType.SubComputed;
+}
+type KTComputedLike<T> = KTComputed<T> | KTSubComputed<T>;
 /**
- * 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
- */
-declare function effect(effectFn: () => void, reactives: Array<KTReactive<any>>, options?: Partial<KTEffectOptions>): () => void;
-
-/**
- *
- * @param value
- * @returns
- */
-declare const toReactive: <T>(value: T | KTReactive<T>) => KTReactive<T>;
-/**
- * Extracts the value from a KTReactive, or returns the value directly if it's not reactive.
+ * Create a computed value that automatically updates when its dependencies change.
+ * @param calculator synchronous function that calculates the value of the computed. It should not have side effects.
+ * @param dependencies an array of reactive dependencies that the computed value depends on. The computed value will automatically update when any of these dependencies change.
  */
-declare function dereactive<T = JSX.Element>(value: T | KTReactive<T>): T;
+declare const computed: <T>(calculator: () => T, dependencies: Array<KTReactiveLike<any>>) => KTComputed<T>;
 
+type ChangeHandler<T> = (newValue: T, oldValue: T) => void;
 declare const enum KTReactiveType {
-    Reative = 1,
-    Computed = 2,
-    Ref = 3
+    ReactiveLike = 1,
+    Ref = 2,
+    SubRef = 4,
+    RefLike = 6,
+    Computed = 8,
+    SubComputed = 16,
+    ComputedLike = 24,
+    Reactive = 10
+}
+declare abstract class KTReactiveLike<T> {
+    readonly kid: number;
+    abstract readonly ktype: KTReactiveType;
+    abstract get value(): T;
+    abstract addOnChange(handler: ChangeHandler<T>, key?: any): this;
+    abstract removeOnChange(key: any): this;
+    /**
+     * Create a computed value via current reactive value.
+     * - No matter `this` is added to `dependencies` or not, it is always listened.
+     * @param calculator A function that generates a new value based on current value.
+     * @param dependencies optional other dependencies that the computed value depends on.
+     */
+    map<U>(calculator: (value: T) => U, dependencies?: Array<KTReactiveLike<any>>): KTComputed<U>;
+}
+declare abstract class KTReactive<T> extends KTReactiveLike<T> {
+    constructor(value: T);
+    get value(): T;
+    set value(_newValue: T);
+    addOnChange(handler: ChangeHandler<T>, key?: any): this;
+    removeOnChange(key: any): this;
+    clearOnChange(): this;
+    notify(): this;
+    /**
+     * Generate a sub-computed value based on this reactive, using keys to access nested properties.
+     * - `reactive.get('a', 'b')` means a sub-computed value to `this.value.a.b`.
+     * - `KTSubComputed` is lighter than `KTComputed` because it only listens to changes on the source reactive, while `KTComputed` listens to all its dependencies. So it's better to use `get` when you only need to access nested properties without doing any calculation.
+     */
+    get<K0 extends keyof T, K1 extends keyof T[K0], K2 extends keyof T[K0][K1], K3 extends keyof T[K0][K1][K2], K4 extends keyof T[K0][K1][K2][K3]>(key0: K0, key1: K1, key2: K2, key3: K3, key4: K4): KTSubComputed<T[K0][K1][K2][K3][K4]>;
+    /**
+     * Generate a sub-computed value based on this reactive, using keys to access nested properties.
+     * - `reactive.get('a', 'b')` means a sub-computed value to `this.value.a.b`.
+     * - `KTSubComputed` is lighter than `KTComputed` because it only listens to changes on the source reactive, while `KTComputed` listens to all its dependencies. So it's better to use `get` when you only need to access nested properties without doing any calculation.
+     */
+    get<K0 extends keyof T, K1 extends keyof T[K0], K2 extends keyof T[K0][K1], K3 extends keyof T[K0][K1][K2]>(key0: K0, key1: K1, key2: K2, key3: K3): KTSubComputed<T[K0][K1][K2][K3]>;
+    /**
+     * Generate a sub-computed value based on this reactive, using keys to access nested properties.
+     * - `reactive.get('a', 'b')` means a sub-computed value to `this.value.a.b`.
+     * - `KTSubComputed` is lighter than `KTComputed` because it only listens to changes on the source reactive, while `KTComputed` listens to all its dependencies. So it's better to use `get` when you only need to access nested properties without doing any calculation.
+     */
+    get<K0 extends keyof T, K1 extends keyof T[K0], K2 extends keyof T[K0][K1]>(key0: K0, key1: K1, key2: K2): KTSubComputed<T[K0][K1][K2]>;
+    /**
+     * Generate a sub-computed value based on this reactive, using keys to access nested properties.
+     * - `reactive.get('a', 'b')` means a sub-computed value to `this.value.a.b`.
+     * - `KTSubComputed` is lighter than `KTComputed` because it only listens to changes on the source reactive, while `KTComputed` listens to all its dependencies. So it's better to use `get` when you only need to access nested properties without doing any calculation.
+     */
+    get<K0 extends keyof T, K1 extends keyof T[K0]>(key0: K0, key1: K1): KTSubComputed<T[K0][K1]>;
+    /**
+     * Generate a sub-computed value based on this reactive, using keys to access nested properties.
+     * - `reactive.get('a', 'b')` means a sub-computed value to `this.value.a.b`.
+     * - `KTSubComputed` is lighter than `KTComputed` because it only listens to changes on the source reactive, while `KTComputed` listens to all its dependencies. So it's better to use `get` when you only need to access nested properties without doing any calculation.
+     */
+    get<K0 extends keyof T>(key0: K0): KTSubComputed<T[K0]>;
+}
+declare abstract class KTSubReactive<T> extends KTReactiveLike<T> {
+    readonly source: KTReactive<any>;
+    constructor(source: KTReactive<any>, paths: string);
+    get value(): T;
+    addOnChange(handler: ChangeHandler<T>, key?: any): this;
+    removeOnChange(key: any): this;
 }
-declare const isKT: <T = any>(obj: any) => obj is KTReactive<T>;
-declare const isRef: <T = any>(obj: any) => obj is KTRef<T>;
-declare const isComputed: <T = any>(obj: any) => obj is KTComputed<T>;
 
 declare class KTRef<T> extends KTReactive<T> {
-    readonly ktType = KTReactiveType.Ref;
+    readonly ktype = KTReactiveType.Ref;
+    constructor(_value: T);
     get value(): T;
     set value(newValue: T);
     /**
@@ -44,31 +101,78 @@ declare class KTRef<T> extends KTReactive<T> {
      * - internal value is changed instantly, but the change handlers will be called in the next microtask.
      */
     get draft(): T;
+    notify(): this;
+    /**
+     * Derive a lighter sub-ref from this ref, using keys to access nested properties.
+     * - `ref.subref('a', 'b')` means a sub-ref to `this.value.a.b`. Change it will also change `this.value` and trigger the handlers.
+     * - `KTSubRef` is lighter than `KTRef`.
+     */
+    subref<K0 extends keyof T, K1 extends keyof T[K0], K2 extends keyof T[K0][K1], K3 extends keyof T[K0][K1][K2], K4 extends keyof T[K0][K1][K2][K3]>(key0: K0, key1: K1, key2: K2, key3: K3, key4: K4): KTSubRef<T[K0][K1][K2][K3][K4]>;
+    /**
+     * Derive a lighter sub-ref from this ref, using keys to access nested properties.
+     * - `ref.subref('a', 'b')` means a sub-ref to `this.value.a.b`. Change it will also change `this.value` and trigger the handlers.
+     * - `KTSubRef` is lighter than `KTRef`.
+     */
+    subref<K0 extends keyof T, K1 extends keyof T[K0], K2 extends keyof T[K0][K1], K3 extends keyof T[K0][K1][K2]>(key0: K0, key1: K1, key2: K2, key3: K3): KTSubRef<T[K0][K1][K2][K3]>;
+    /**
+     * Derive a lighter sub-ref from this ref, using keys to access nested properties.
+     * - `ref.subref('a', 'b')` means a sub-ref to `this.value.a.b`. Change it will also change `this.value` and trigger the handlers.
+     * - `KTSubRef` is lighter than `KTRef`.
+     */
+    subref<K0 extends keyof T, K1 extends keyof T[K0], K2 extends keyof T[K0][K1]>(key0: K0, key1: K1, key2: K2): KTSubRef<T[K0][K1][K2]>;
+    /**
+     * Derive a lighter sub-ref from this ref, using keys to access nested properties.
+     * - `ref.subref('a', 'b')` means a sub-ref to `this.value.a.b`. Change it will also change `this.value` and trigger the handlers.
+     * - `KTSubRef` is lighter than `KTRef`.
+     */
+    subref<K0 extends keyof T, K1 extends keyof T[K0]>(key0: K0, key1: K1): KTSubRef<T[K0][K1]>;
+    /**
+     * Derive a lighter sub-ref from this ref, using keys to access nested properties.
+     * - `ref.subref('a', 'b')` means a sub-ref to `this.value.a.b`. Change it will also change `this.value` and trigger the handlers.
+     * - `KTSubRef` is lighter than `KTRef`.
+     */
+    subref<K0 extends keyof T>(key0: K0): KTSubRef<T[K0]>;
+}
+declare class KTSubRef<T> extends KTSubReactive<T> {
+    readonly ktype = KTReactiveType.SubRef;
+    readonly source: KTRef<any>;
+    constructor(source: KTRef<any>, paths: string);
+    get value(): T;
+    set value(newValue: T);
+    get draft(): T;
 }
 /**
- * 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
+ * Create a reactive reference to a value. The returned object has a single property `value` that holds the internal value.
+ * @param value listened value
  */
-declare const ref: <T = JSX.Element>(value?: T) => KTRef<T>;
+declare const ref: <T>(value?: T) => KTRef<T>;
 /**
- * Assert k-model to be a ref object
+ * Assert `k-model` to be a ref-like object
  */
-declare const $modelOrRef: <T = any>(props: any, defaultValue?: T) => KTRef<T>;
-type RefSetter<T> = (props: {
-    ref?: KTRef<T>;
-}, node: T) => void;
+declare const assertModel: <T = any>(props: any, defaultValue?: T) => KTRefLike<T>;
+type KTRefLike<T> = KTRef<T> | KTSubRef<T>;
+
 /**
- * Whether `props.ref` is a `KTRef` only needs to be checked in the initial render
+ * Makes `KTReactify<'a' | 'b'> to be KTReactiveLike<'a'> | KTReactiveLike<'b'>`
  */
-declare const $initRef: <T extends Node>(props: {
-    ref?: KTRef<T>;
-}, node: T) => RefSetter<T>;
+type KTReactifySplit<T> = T extends boolean ? KTReactiveLike<boolean> : T extends any ? KTReactiveLike<T> : never;
+
+type KTReactifyObject<T extends object> = {
+  [K in keyof T]: KTReactifySplit<T[K]>;
+};
+
+type KTReactifyProps<T extends object> = {
+  [K in keyof T]: KTReactifySplit<Exclude<T[K], undefined>> | T[K];
+};
+
+/**
+ * Makes `KTReactify<'a' | 'b'>` to be `KTReactiveLike<'a' | 'b'>`
+ */
+type KTReactify<T> = [T] extends [KTReactiveLike<infer U>] ? KTReactiveLike<U> : KTReactiveLike<T>;
+type KTMaybeReactive<T> = T | KTReactify<T>;
+type KTMaybeReactiveProps<T extends object> = {
+  [K in keyof T]: K extends `on:${string}` ? T[K] : KTMaybeReactive<Exclude<T[K], undefined>> | T[K];
+};
 
 // Base events available to all HTML elements
 type BaseAttr = KTPrefixedEventAttribute & {
@@ -1164,11 +1268,11 @@ declare namespace JSX {
     /**
      * Make a reference to the created element
      */
-    ref?: KTRef<any>;
+    ref?: KTRefLike<any>;
 
     /**
      * Conditional rendering
-     * - Provide a `KTRef` to make it reactive
+     * - Provide a `KTRefLike` to make it reactive
      */
     'k-if'?: any;
 
@@ -1189,9 +1293,9 @@ declare namespace JSX {
     'k-key'?: any;
 
     /**
-     * 2-way binding. Must provide a `KTRef`
+     * 2-way binding. Must provide a `KTRefLike`
      */
-    'k-model'?: KTRef<any>;
+    'k-model'?: KTRefLike<any>;
 
     /**
      * Raw HTML escape hatch.
@@ -1209,123 +1313,6 @@ declare namespace JSX {
   }
 }
 
-declare class KTComputed<T> extends KTReactive<T> {
-    readonly ktType = KTReactiveType.Computed;
-    constructor(_calculator: () => T, dependencies: Array<KTReactive<unknown>>);
-    /**
-     * If new value and old value are both nodes, the old one will be replaced in the DOM
-     */
-    get value(): T;
-    set value(_newValue: T);
-    /**
-     * Force listeners to run once with the latest computed result.
-     */
-    notify(): this;
-}
-/**
- * Create a reactive computed value
- * @param computeFn
- * @param dependencies refs and computeds that this computed depends on
- */
-declare function computed<T = JSX.Element>(computeFn: () => T, dependencies: Array<KTReactive<any>>): KTComputed<T>;
-
-type ChangeHandler<T> = (newValue: T, oldValue: T) => void;
-type ChangeHandlerKey = string | number;
-declare class KTReactive<T> {
-    /**
-     * Indicates that this is a KTRef instance
-     */
-    readonly isKT: true;
-    readonly ktType: KTReactiveType;
-    /**
-     * & Here we trust developers using addOnChange properly. `ChangeHandler<any>` is aimed to mute some unnecessary type errors.
-     */
-    protected _changeHandlers: Map<ChangeHandlerKey, ChangeHandler<any>>;
-    constructor(_value: T);
-    /**
-     * 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(): T;
-    set value(_newValue: T);
-    /**
-     * Force all listeners to run even when reference identity has not changed.
-     *
-     * Useful for in-place array/object mutations.
-     */
-    notify(): this;
-    /**
-     * Ccreate a computed value based on this `KTReactive` instance.
-     * @param calculator A function that calculates the computed value based on the current value of this `KTReactive` instance.
-     * @param dependencies Optional additional dependencies that the computed value relies on.
-     * @returns A `KTComputed` instance
-     *
-     * @see ./computed.ts implemented in `KTComputed`
-     */
-    map<R>(calculator: (currentValue: T) => R, dependencies?: Array<KTReactive<any>>): KTComputed<R>;
-    /**
-     * 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.
-     */
-    addOnChange(callback: ChangeHandler<T>, key?: ChangeHandlerKey): this;
-    removeOnChange(key: ChangeHandlerKey): ChangeHandler<any> | undefined;
-    /**
-     * Generate a computed value based on this ref, using keys to access nested properties.
-     * - `ref.get('a', 'b')` is equivalent to `ref.map((v) => v.a.b)`, but simpler to write.
-     * @returns A `KTComputed` object
-     * @throws when `a.b.c` throws error(e.g. `a.b` is undefined, then it throws when calling `undefined.c`).
-     */
-    get<K0 extends keyof T, K1 extends keyof T[K0], K2 extends keyof T[K0][K1], K3 extends keyof T[K0][K1][K2], K4 extends keyof T[K0][K1][K2][K3]>(key0: K0, key1: K1, key2: K2, key3: K3, key4: K4): KTComputed<T[K0][K1][K2][K3][K4]>;
-    /**
-     * Generate a computed value based on this ref, using keys to access nested properties.
-     * - `ref.get('a', 'b')` is equivalent to `ref.map((v) => v.a.b)`, but simpler to write.
-     * @returns A `KTComputed` object
-     * @throws when `a.b.c` throws error(e.g. `a.b` is undefined, then it throws when calling `undefined.c`).
-     */
-    get<K0 extends keyof T, K1 extends keyof T[K0], K2 extends keyof T[K0][K1], K3 extends keyof T[K0][K1][K2]>(key0: K0, key1: K1, key2: K2, key3: K3): KTComputed<T[K0][K1][K2][K3]>;
-    /**
-     * Generate a computed value based on this ref, using keys to access nested properties.
-     * - `ref.get('a', 'b')` is equivalent to `ref.map((v) => v.a.b)`, but simpler to write.
-     * @returns A `KTComputed` object
-     * @throws when `a.b.c` throws error(e.g. `a.b` is undefined, then it throws when calling `undefined.c`).
-     */
-    get<K0 extends keyof T, K1 extends keyof T[K0], K2 extends keyof T[K0][K1]>(key0: K0, key1: K1, key2: K2): KTComputed<T[K0][K1][K2]>;
-    /**
-     * Generate a computed value based on this ref, using keys to access nested properties.
-     * - `ref.get('a', 'b')` is equivalent to `ref.map((v) => v.a.b)`, but simpler to write.
-     * @returns A `KTComputed` object
-     * @throws when `a.b.c` throws error(e.g. `a.b` is undefined, then it throws when calling `undefined.c`).
-     */
-    get<K0 extends keyof T, K1 extends keyof T[K0]>(key0: K0, key1: K1): KTComputed<T[K0][K1]>;
-    /**
-     * Generate a computed value based on this ref, using keys to access nested properties.
-     * - `ref.get('a', 'b')` is equivalent to `ref.map((v) => v.a.b)`, but simpler to write.
-     * @returns A `KTComputed` object
-     * @throws when `a.b.c` throws error(e.g. `a.b` is undefined, then it throws when calling `undefined.c`).
-     */
-    get<K0 extends keyof T>(key0: K0): KTComputed<T[K0]>;
-}
-/**
- * Makes `KTReactify<'a' | 'b'> to be KTReactive<'a'> | KTReactive<'b'>`
- */
-type KTReactifySplit<T> = T extends boolean ? KTReactive<boolean> : T extends any ? KTReactive<T> : never;
-type KTReactifyObject<T extends object> = {
-    [K in keyof T]: KTReactifySplit<T[K]>;
-};
-type KTReactifyProps<T extends object> = {
-    [K in keyof T]: KTReactifySplit<Exclude<T[K], undefined>> | T[K];
-};
-/**
- * Makes `KTReactify<'a' | 'b'>` to be `KTReactive<'a' | 'b'>`
- */
-type KTReactify<T> = [T] extends [KTReactive<infer U>] ? KTReactive<U> : KTReactive<T>;
-type KTMaybeReactive<T> = T | KTReactify<T>;
-type KTMaybeReactiveProps<T extends object> = {
-    [K in keyof T]: K extends `on:${string}` ? T[K] : KTMaybeReactive<Exclude<T[K], undefined>> | T[K];
-};
-
 type HTML<T extends (HTMLTag | SVGTag | MathMLTag) & otherstring> = T extends SVGTag
   ? SVGElementTagNameMap[T]
   : T extends HTMLTag
@@ -1334,7 +1321,7 @@ type HTML<T extends (HTMLTag | SVGTag | MathMLTag) & otherstring> = T extends SV
       ? MathMLElementTagNameMap[T]
       : HTMLElement;
 
-type SingleContent = KTReactive<any> | HTMLElement | Element | Node | string | number | boolean | null | undefined;
+type SingleContent = KTReactiveLike<any> | HTMLElement | Element | Node | string | number | boolean | null | undefined;
 type KTAvailableContent = SingleContent | KTAvailableContent[];
 type KTRawContent = KTAvailableContent | Promise<KTAvailableContent>;
 type KTRawAttr = KTAttribute | null | undefined | '' | false;
@@ -1357,18 +1344,18 @@ interface KTBaseAttribute {
   [k: string]: any;
 
   // # kt-specific attributes
-  ref?: KTRef<any>;
+  ref?: KTRefLike<any>;
 
   /**
-   * If a `KTRef` is bound, it will be reactive; otherwise, it will be static.
+   * If a `KTRefLike` is bound, it will be reactive; otherwise, it will be static.
    */
   'k-if'?: any;
 
   /**
-   * Register two-way data binding between an input element and a KTRef.
+   * Register two-way data binding between an input element and a KTRefLike.
    * - Default to regist `input` event and `value` property(`checked` for checkboxes and radios).
    */
-  'k-model'?: KTRef<any>;
+  'k-model'?: KTRefLike<any>;
 
   /**
    * Raw HTML escape hatch. Directly assigns to `innerHTML`.
@@ -1381,9 +1368,9 @@ interface KTBaseAttribute {
 
   // # normal HTML attributes
   id?: string;
-  class?: string;
-  className?: string;
-  style?: string | Partial<CSSStyleDeclaration>;
+  class?: string; // KTMaybeReactive<string>;
+  className?: string; // KTMaybeReactive<string>;
+  style?: string | Partial<CSSStyleDeclaration>; //  | KTReactiveLike<string | KTReactiveLike<Partial<CSSStyleDeclaration>>>;
 
   type?:
     | 'text'
@@ -1444,7 +1431,7 @@ type KTAttribute = KTBaseAttribute & KTPrefixedEventAttribute;
 
 type KTComponent = (
   props: {
-    ref?: KTRef<JSX.Element>;
+    ref?: KTRefLike<JSX.Element>;
     children?: KTRawContent;
   } & KTAttribute &
     any,
@@ -1486,6 +1473,39 @@ declare const jsxDEV: typeof jsx;
  */
 declare const jsxs: (tag: JSXTag, props: KTAttribute) => JSX.Element;
 
+declare function isKT<T = any>(obj: any): obj is KTReactiveLike<T>;
+declare function isReactiveLike<T = any>(obj: any): obj is KTReactiveLike<T>;
+declare function isRef<T = any>(obj: any): obj is KTRef<T>;
+declare function isSubRef<T = any>(obj: any): obj is KTSubRef<T>;
+declare function isRefLike<T = any>(obj: any): obj is KTRefLike<T>;
+declare function isComputed<T = any>(obj: any): obj is KTComputed<T>;
+declare function isSubComputed<T = any>(obj: any): obj is KTSubComputed<T>;
+declare function isComputedLike<T = any>(obj: any): obj is KTComputedLike<T>;
+declare function isReactive<T = any>(obj: any): obj is KTReactive<T>;
+
+interface KTEffectOptions {
+    lazy: boolean;
+    onCleanup: () => void;
+    debugName: string;
+}
+/**
+ * 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
+ */
+declare function effect(effectFn: () => void, reactives: Array<KTReactiveLike<any>>, options?: Partial<KTEffectOptions>): () => void;
+
+/**
+ * Ensure a value is reactive. If it's already `KTReactiveLike`, return it as is; otherwise, wrap it in a `ref`.
+ */
+declare const toReactive: <T>(o: T | KTReactiveLike<T>) => KTReactiveLike<T>;
+/**
+ * Extracts the value from a KTReactive, or returns the value directly if it's not reactive.
+ */
+declare const dereactive: <T>(value: T | KTReactiveLike<T>) => T;
+
 /**
  * Extract component props type (excluding ref and children)
  */
@@ -1499,8 +1519,8 @@ declare function KTAsync<T extends KTComponent>(props: {
 
 type KTForElement = JSX.Element;
 interface KTForProps<T> {
-    ref?: KTRef<KTForElement>;
-    list: T[] | KTReactive<T[]>;
+    ref?: KTRefLike<KTForElement>;
+    list: T[] | KTReactiveLike<T[]>;
     key?: (item: T, index: number, array: T[]) => any;
     map?: (item: T, index: number, array: T[]) => JSX.Element;
 }
@@ -1510,7 +1530,7 @@ interface KTForProps<T> {
  */
 declare function KTFor<T>(props: KTForProps<T>): KTForElement;
 
-declare function KTConditional(condition: any | KTReactive<any>, tagIf: JSXTag, propsIf: KTAttribute, tagElse?: JSXTag, propsElse?: KTAttribute): Element;
+declare function KTConditional(condition: any | KTReactiveLike<any>, tagIf: JSXTag, propsIf: KTAttribute, tagElse?: JSXTag, propsElse?: KTAttribute): Element;
 
-export { $initRef, $modelOrRef, Fragment, JSX, KTAsync, KTComputed, KTConditional, KTFor, KTReactive, KTReactiveType, 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 };
-export type { AliasElement, ChangeHandler, ChangeHandlerKey, EventHandler, HTML, KTAttribute, KTForElement, KTForProps, KTMaybeReactive, KTMaybeReactiveProps, KTPrefixedEventAttribute, KTRawAttr, KTRawContent, KTRawContents, KTReactify, KTReactifyObject, KTReactifyProps, KTReactifySplit };
+export { Fragment, JSX, KTAsync, KTComputed, KTConditional, KTFor, KTReactive, KTReactiveLike, KTReactiveType, KTRef, KTSubComputed, KTSubReactive, KTSubRef, applyAttr, assertModel, computed, h as createElement, mathml$1 as createMathMLElement, svg$1 as createSVGElement, dereactive, effect, h, isComputed, isComputedLike, isKT, isReactive, isReactiveLike, isRef, isRefLike, isSubComputed, isSubRef, jsx, jsxDEV, jsxs, mathml, mathml as mathmlRuntime, ref, svg, svg as svgRuntime, toReactive };
+export type { AliasElement, ChangeHandler, EventHandler, HTML, KTAttribute, KTComputedLike, KTForElement, KTForProps, KTMaybeReactive, KTMaybeReactiveProps, KTPrefixedEventAttribute, KTRawAttr, KTRawContent, KTRawContents, KTReactify, KTReactifyObject, KTReactifyProps, KTReactifySplit, KTRefLike };

package/dist/index.mjs

@@ -1,6 +1,42 @@
-import { $isArray, $isThenable, $isNode, $emptyFn, $is, $stringify, $applyModel, $forEach, $identity } from "@ktjs/shared";
+import { $isArray, $isThenable, $isNode, $stringify, $is, $emptyFn, $forEach, $identity } from "@ktjs/shared";
 
-const isKT = obj => obj?.isKT, isRef = obj => void 0 !== obj.ktType && 3 === obj.ktType, isComputed = obj => 2 === obj?.ktType, booleanHandler = (element, key, value) => {
+function isKT(obj) {
+    return "number" == typeof obj?.kid;
+}
+
+function isReactiveLike(obj) {
+    return "number" == typeof obj.ktype && !!(1 & obj.ktype);
+}
+
+function isRef(obj) {
+    return "number" == typeof obj.ktype && 2 === obj.ktype;
+}
+
+function isSubRef(obj) {
+    return "number" == typeof obj.ktype && 4 === obj.ktype;
+}
+
+function isRefLike(obj) {
+    return "number" == typeof obj.ktype && !!(6 & obj.ktype);
+}
+
+function isComputed(obj) {
+    return "number" == typeof obj.ktype && 8 === obj.ktype;
+}
+
+function isSubComputed(obj) {
+    return "number" == typeof obj.ktype && 16 === obj.ktype;
+}
+
+function isComputedLike(obj) {
+    return "number" == typeof obj.ktype && !!(24 & obj.ktype);
+}
+
+function isReactive(obj) {
+    return "number" == typeof obj.ktype && !!(10 & obj.ktype);
+}
+
+const _getters = new Map, _setters = new Map, 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);
@@ -89,45 +125,114 @@ function applyContent(element, content) {
     if ($isArray(content)) for (let i = 0; i < content.length; i++) apd(element, content[i]); else apd(element, content);
 }
 
-const IdGenerator = {
-    _refOnChangeId: 1,
-    get refOnChangeId() {
-        return this._refOnChangeId++;
-    }
+function applyKModel(element, valueRef) {
+    if (!isRefLike(valueRef)) throw new Error("[@ktjs/core error] k-model value must be a KTRefLike.");
+    if ("INPUT" !== element.tagName) return "SELECT" === element.tagName || "TEXTAREA" === element.tagName ? (element.value = valueRef.value ?? "", 
+    element.addEventListener("change", () => valueRef.value = element.value), void valueRef.addOnChange(newValue => element.value = newValue)) : void console.warn("[@ktjs/core warn]", "not supported element for k-model:");
+    "radio" === element.type || "checkbox" === element.type ? (element.checked = Boolean(valueRef.value), 
+    element.addEventListener("change", () => valueRef.value = element.checked), valueRef.addOnChange(newValue => element.checked = newValue)) : (element.value = valueRef.value ?? "", 
+    element.addEventListener("input", () => valueRef.value = element.value), valueRef.addOnChange(newValue => element.value = newValue));
+}
+
+/**
+ * Create an enhanced HTMLElement.
+ * - Only supports HTMLElements, **NOT** SVGElements or other Elements.
+ * @param tag tag of an `HTMLElement`
+ * @param attr attribute object or className
+ * @param content a string or an array of HTMLEnhancedElement as child nodes
+ *
+ * ## About
+ * @package @ktjs/core
+ * @author Kasukabe Tsumugi <futami16237@gmail.com>
+ * @version 0.36.1 (Last Update: 2026.03.28 21:55:27.416)
+ * @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 ("string" != typeof tag) throw new Error("[@ktjs/core error] tagName must be a string.");
+    const element = document.createElement(tag);
+    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;
 };
 
-class KTReactive {
-    isKT=!0;
-    ktType=1;
+let kid = 1, handlerId = 1;
+
+class KTReactiveLike {
+    kid=kid++;
+    map(calculator, dependencies) {
+        return null;
+    }
+}
+
+class KTReactive extends KTReactiveLike {
     _value;
     _changeHandlers=new Map;
-    _emit(newValue, oldValue) {
-        return this._changeHandlers.forEach(c => c(newValue, oldValue)), this;
-    }
-    constructor(_value) {
-        this._value = _value, this._changeHandlers = new Map;
+    constructor(value) {
+        super(), this._value = value;
     }
     get value() {
         return this._value;
     }
-    set value(_newValue) {}
-    notify() {
-        return this._emit(this._value, this._value);
+    set value(_newValue) {
+        console.warn("[@ktjs/core warn]", "Setting value to a non-ref instance takes no effect.");
     }
-    map(..._args) {
-        throw new Error("This is meant to be override in computed.ts");
+    _emit(newValue, oldValue) {
+        return this._changeHandlers.forEach(handler => handler(newValue, oldValue)), this;
     }
-    addOnChange(callback, key) {
-        if ("function" != typeof callback) throw new Error("[@ktjs/core error] KTRef.addOnChange: callback must be a function");
-        const k = key ?? IdGenerator.refOnChangeId;
-        return this._changeHandlers.set(k, callback), this;
+    addOnChange(handler, key) {
+        if (key ??= handlerId++, this._changeHandlers.has(key)) throw new Error(`[@ktjs/core error] Overriding existing change handler with key ${$stringify(key)}.`);
+        return this._changeHandlers.set(key, handler), this;
     }
     removeOnChange(key) {
-        const callback = this._changeHandlers.get(key);
-        return this._changeHandlers.delete(key), callback;
+        return this._changeHandlers.delete(key), this;
+    }
+    clearOnChange() {
+        return this._changeHandlers.clear(), this;
+    }
+    notify() {
+        return this._emit(this._value, this._value);
     }
     get(..._keys) {
-        return {};
+        return null;
+    }
+}
+
+class KTSubReactive extends KTReactiveLike {
+    source;
+    _getter;
+    constructor(source, paths) {
+        super(), this.source = source, this._getter = (path => {
+            const exist = _getters.get(path);
+            if (exist) return exist;
+            {
+                const cache = new Function("s", `return s${path}`);
+                return _getters.set(path, cache), cache;
+            }
+        })(paths);
+    }
+    get value() {
+        return this._getter(this.source._value);
+    }
+    addOnChange(handler, key) {
+        return this.source.addOnChange((newSourceValue, oldSourceValue) => {
+            const oldValue = this._getter(oldSourceValue), newValue = this._getter(newSourceValue);
+            handler(newValue, oldValue);
+        }, key), this;
+    }
+    removeOnChange(key) {
+        return this.source.removeOnChange(key), this;
     }
 }
 
@@ -135,8 +240,22 @@ const reactiveToOldValue = new Map;
 
 let scheduled = !1;
 
+const markMutation = 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();
+        });
+    }
+};
+
 class KTRef extends KTReactive {
-    ktType=3;
+    ktype=2;
+    constructor(_value) {
+        super(_value);
+    }
     get value() {
         return this._value;
     }
@@ -146,63 +265,88 @@ class KTRef extends KTReactive {
         this._value = newValue, this._emit(newValue, oldValue);
     }
     get draft() {
-        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();
-                });
+        return markMutation(this), this._value;
+    }
+    notify() {
+        return this._emit(this._value, this._value);
+    }
+    subref(...keys) {
+        if (0 === keys.length) throw new Error("[@ktjs/core error] At least one key is required to get a sub-ref.");
+        return new KTSubRef(this, keys.map(key => `[${$stringify(key)}]`).join(""));
+    }
+}
+
+class KTSubRef extends KTSubReactive {
+    ktype=4;
+    _setter;
+    constructor(source, paths) {
+        super(source, paths), this._setter = (path => {
+            const exist = _setters.get(path);
+            if (exist) return exist;
+            {
+                const cache = new Function("s", "v", `s${path}=v`);
+                return _setters.set(path, cache), cache;
             }
-        })(this), this._value;
+        })(paths);
+    }
+    get value() {
+        return this._getter(this.source._value);
+    }
+    set value(newValue) {
+        this._setter(this.source._value, newValue), this.source.notify();
+    }
+    get draft() {
+        return markMutation(this.source), this._getter(this.source._value);
     }
 }
 
-const ref = value => new KTRef(value), $modelOrRef = (props, defaultValue) => {
+const ref = value => new KTRef(value), assertModel = (props, defaultValue) => {
     if ("k-model" in props) {
         const kmodel = props["k-model"];
-        if (isRef(kmodel)) return kmodel;
+        if (isRefLike(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);
 }, $refSetter = (props, node) => props.ref.value = node, $initRef = (props, node) => {
     if (!("ref" in props)) return $emptyFn;
     const r = props.ref;
-    if (isRef(r)) return r.value = node, $refSetter;
+    if (isRefLike(r)) return r.value = node, $refSetter;
     throw new Error("[@ktjs/core error] Fragment: ref must be a KTRef");
 };
 
 class KTComputed extends KTReactive {
-    ktType=2;
+    ktype=8;
     _calculator;
-    _recalculate(forceEmit = !1) {
-        const oldValue = this._value, newValue = this._calculator();
-        return $is(oldValue, newValue) ? (forceEmit && this._emit(newValue, oldValue), this) : (this._value = newValue, 
-        this._emit(newValue, oldValue), this);
-    }
-    constructor(_calculator, dependencies) {
-        super(_calculator()), this._calculator = _calculator;
-        for (let i = 0; i < dependencies.length; i++) dependencies[i].addOnChange(() => this._recalculate());
-    }
-    get value() {
-        return this._value;
+    _recalculate(forced = !1) {
+        const newValue = this._calculator(), oldValue = this._value;
+        return $is(oldValue, newValue) && !forced || (this._value = newValue, this._emit(newValue, oldValue)), 
+        this;
     }
-    set value(_newValue) {
-        console.warn("[@ktjs/core warn]", "'value' of Computed are read-only.");
+    constructor(calculator, dependencies) {
+        super(calculator()), this._calculator = calculator;
+        const recalculate = () => this._recalculate();
+        for (let i = 0; i < dependencies.length; i++) dependencies[i].addOnChange(recalculate);
     }
     notify() {
         return this._recalculate(!0);
     }
 }
 
-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);
+KTReactiveLike.prototype.map = function(c, dep) {
+    return new KTComputed(() => c(this.value), dep ? [ this, ...dep ] : [ this ]);
+}, KTReactive.prototype.get = function(...keys) {
+    if (0 === keys.length) throw new Error("[@ktjs/core error] At least one key is required to get a sub-computed.");
+    return new KTSubComputed(this, keys.map(key => `[${$stringify(key)}]`).join(""));
+};
+
+class KTSubComputed extends KTSubReactive {
+    ktype=16;
 }
 
+const computed = (calculator, dependencies) => new KTComputed(calculator, dependencies);
+
 function effect(effectFn, reactives, options) {
-    const {lazy: lazy = !1, onCleanup: onCleanup = $emptyFn, debugName: debugName = ""} = Object(options), listenerKeys = [];
+    const {lazy: lazy = !1, onCleanup: onCleanup = $emptyFn, debugName: debugName = ""} = Object(options);
     let active = !0;
     const run = () => {
         if (active) {
@@ -214,71 +358,17 @@ function effect(effectFn, reactives, options) {
             }
         }
     };
-    for (let i = 0; i < reactives.length; i++) listenerKeys[i] = i, reactives[i].addOnChange(run, i);
+    for (let i = 0; i < reactives.length; i++) reactives[i].addOnChange(run, effectFn);
     return lazy || run(), () => {
         if (active) {
             active = !1;
-            for (let i = 0; i < reactives.length; i++) reactives[i].removeOnChange(listenerKeys[i]);
+            for (let i = 0; i < reactives.length; i++) reactives[i].removeOnChange(effectFn);
             onCleanup();
         }
     };
 }
 
-KTReactive.prototype.map = function(calculator, dependencies) {
-    return new KTComputed(() => calculator(this._value), dependencies ? [ this, ...dependencies ] : [ this ]);
-}, KTReactive.prototype.get = function(...keys) {
-    const reader = new Function("v", `return v${keys.map(k => `[${$stringify(k)}]`).join("")}`);
-    return new KTComputed(() => reader(this._value), [ 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 ("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:");
-}
-
-/**
- * Create an enhanced HTMLElement.
- * - Only supports HTMLElements, **NOT** SVGElements or other Elements.
- * @param tag tag of an `HTMLElement`
- * @param attr attribute object or className
- * @param content a string or an array of HTMLEnhancedElement as child nodes
- *
- * ## About
- * @package @ktjs/core
- * @author Kasukabe Tsumugi <futami16237@gmail.com>
- * @version 0.35.0 (Last Update: 2026.03.24 22:42:03.373)
- * @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 ("string" != typeof tag) throw new Error("[@ktjs/core error] tagName must be a string.");
-    const element = document.createElement(tag);
-    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 toReactive = o => isKT(o) ? o : ref(o), dereactive = value => isKT(value) ? value.value : value;
 
 if ("undefined" != typeof Node && !globalThis.__kt_fragment_mount_patched__) {
     globalThis.__kt_fragment_mount_patched__ = !0;
@@ -297,7 +387,7 @@ if ("undefined" != typeof Node && !globalThis.__kt_fragment_mount_patched__) {
 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 && isComputedLike(props.ref)) throw new Error("[@ktjs/core error] Cannot assign a computed value to an element.");
     const el = creator(tag, props, props.children);
     return $initRef(props, el), el;
 }
@@ -314,7 +404,7 @@ function Fragment(props) {
                     const span = document.createElement("span");
                     return span.textContent = String(child), void elements.push(span);
                 }
-                if (child instanceof HTMLElement) elements.push(child); else {
+                if (child instanceof Element) 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);
@@ -377,7 +467,7 @@ function KTAsync(props) {
 }
 
 function KTFor(props) {
-    const {key: currentKey = item => item, map: currentMap = $identity} = props, listRef = toReactive(props.list).addOnChange(() => {
+    const currentKey = props.key ?? (item => item), currentMap = props.map ?? (item => $identity(item)), listRef = toReactive(props.list).addOnChange(() => {
         const newList = listRef.value, parent = anchor.parentNode;
         if (!parent) {
             const newElements = [];
@@ -448,5 +538,5 @@ function KTConditional(condition, tagIf, propsIf, tagElse, propsElse) {
     }
 }
 
-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 };
+export { Fragment, KTAsync, KTConditional, KTFor, applyAttr, assertModel, computed, h as createElement, mathml$1 as createMathMLElement, svg$1 as createSVGElement, dereactive, effect, h, isComputed, isComputedLike, isKT, isReactive, isReactiveLike, isRef, isRefLike, isSubComputed, isSubRef, jsx, jsxDEV, jsxs, mathml, mathml as mathmlRuntime, ref, svg, svg as svgRuntime, toReactive };
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":["../src/reactive/common.ts","../src/h/attr-helpers.ts","../src/h/attr.ts","../src/h/content.ts","../src/common.ts","../src/reactive/reactive.ts","../src/reactive/scheduler.ts","../src/reactive/ref.ts","../src/reactive/computed.ts","../src/reactive/effect.ts","../src/reactive/index.ts","../src/h/model.ts","../src/h/index.ts","../src/jsx/fragment.ts","../src/jsx/common.ts","../src/jsx/jsx-runtime.ts","../src/jsx/async.ts","../src/jsx/for.ts","../src/jsx/if.ts"],"sourcesContent":["import type { KTReactive } from './reactive.js';\nimport type { KTComputed } from './index.js';\nimport type { KTRef } from './ref.js';\n\nexport const enum KTReactiveType {\n  Reative = 1,\n  Computed,\n  Ref,\n}\n\nexport const isKT = <T = any>(obj: any): obj is KTReactive<T> => obj?.isKT;\nexport const isRef = <T = any>(obj: any): obj is KTRef<T> => {\n  // & This is tested to be the fastest way.\n  // faster than includes, arrayindex, if or.\n  if (obj.ktType === undefined) {\n    return false;\n  }\n  return obj.ktType === KTReactiveType.Ref;\n};\nexport const isComputed = <T = any>(obj: any): obj is KTComputed<T> => obj?.ktType === KTReactiveType.Computed;\n","const booleanHandler = (element: HTMLElement | SVGElement | MathMLElement, key: string, value: any) => {\n  if (key in element) {\n    (element as any)[key] = !!value;\n  } else {\n    element.setAttribute(key, value);\n  }\n};\n\nconst valueHandler = (element: HTMLElement | SVGElement | MathMLElement, key: string, value: any) => {\n  if (key in element) {\n    (element as any)[key] = value;\n  } else {\n    element.setAttribute(key, value);\n  }\n};\n\n// Attribute handlers map for optimized lookup\nexport const handlers: Record<\n  string,\n  (element: HTMLElement | SVGElement | MathMLElement, key: string, value: any) => void\n> = {\n  checked: booleanHandler,\n  selected: booleanHandler,\n  value: valueHandler,\n  valueAsDate: valueHandler,\n  valueAsNumber: valueHandler,\n  defaultValue: valueHandler,\n  defaultChecked: booleanHandler,\n  defaultSelected: booleanHandler,\n  disabled: booleanHandler,\n  readOnly: booleanHandler,\n  multiple: booleanHandler,\n  required: booleanHandler,\n  autofocus: booleanHandler,\n  open: booleanHandler,\n  controls: booleanHandler,\n  autoplay: booleanHandler,\n  loop: booleanHandler,\n  muted: booleanHandler,\n  defer: booleanHandler,\n  async: booleanHandler,\n  hidden: (element, _key, value) => ((element as HTMLElement).hidden = !!value),\n};\n","import type { KTReactifyProps } from '../reactive/reactive.js';\nimport type { KTRawAttr, KTAttribute } from '../types/h.js';\nimport { isKT } from '../reactive/common.js';\nimport { handlers } from './attr-helpers.js';\n\nconst defaultHandler = (element: HTMLElement | SVGElement | MathMLElement, key: string, value: any) =>\n  element.setAttribute(key, value);\n\nconst setElementStyle = (\n  element: HTMLElement | SVGElement | MathMLElement,\n  style: Partial<CSSStyleDeclaration> | string,\n) => {\n  if (typeof style === 'string') {\n    (element as HTMLElement).style.cssText = style;\n    return;\n  }\n\n  for (const key in style) {\n    (element as any).style[key as any] = style[key];\n  }\n};\n\nfunction attrIsObject(element: HTMLElement | SVGElement | MathMLElement, attr: KTReactifyProps<KTAttribute>) {\n  const classValue = attr.class || attr.className;\n  if (classValue !== undefined) {\n    if (isKT<string>(classValue)) {\n      element.setAttribute('class', classValue.value);\n      classValue.addOnChange((v) => element.setAttribute('class', v));\n    } else {\n      element.setAttribute('class', classValue);\n    }\n  }\n\n  const style = attr.style;\n  if (style) {\n    if (typeof style === 'string') {\n      element.setAttribute('style', style);\n    } else if (typeof style === 'object') {\n      if (isKT(style)) {\n        setElementStyle(element, style.value);\n        style.addOnChange((v: Partial<CSSStyleDeclaration> | string) => setElementStyle(element, v));\n      } else {\n        setElementStyle(element, style as Partial<CSSStyleDeclaration>);\n      }\n    }\n  }\n\n  // ! Security: `k-html` is an explicit raw HTML escape hatch. kt.js intentionally does not sanitize here; callers must pass only trusted HTML.\n  if ('k-html' in attr) {\n    const html = attr['k-html'];\n    if (isKT(html)) {\n      element.innerHTML = html.value;\n      html.addOnChange((v) => (element.innerHTML = v));\n    } else {\n      element.innerHTML = html;\n    }\n  }\n\n  for (const key in attr) {\n    // & Arranged in order of usage frequency\n    if (\n      // key === 'k-if' ||\n      // key === 'k-else' ||\n      key === 'k-model' ||\n      key === 'k-for' ||\n      key === 'k-key' ||\n      key === 'ref' ||\n      key === 'class' ||\n      key === 'className' ||\n      key === 'style' ||\n      key === 'children' ||\n      key === 'k-html'\n    ) {\n      continue;\n    }\n\n    const o = attr[key];\n\n    // normal event handler\n    if (key.startsWith('on:')) {\n      if (o) {\n        element.addEventListener(key.slice(3), o); // chop off the `on:`\n      }\n      continue;\n    }\n\n    // normal attributes\n    // Security: all non-`on:` attributes are forwarded as-is.\n    // Dangerous values such as raw `on*`, `href`, `src`, `srcdoc`, SVG href, etc.\n    // remain the caller's responsibility.\n    const handler = handlers[key] || defaultHandler;\n    if (isKT(o)) {\n      handler(element, key, o.value);\n      o.addOnChange((v) => handler(element, key, v));\n    } else {\n      handler(element, key, o);\n    }\n  }\n}\n\nexport function applyAttr(element: HTMLElement | SVGElement | MathMLElement, attr: KTRawAttr) {\n  if (!attr) {\n    return;\n  }\n  if (typeof attr === 'object' && attr !== null) {\n    attrIsObject(element, attr as KTAttribute);\n  } else {\n    $throw('attr must be an object.');\n  }\n}\n","import { $isArray, $isNode, $isThenable } from '@ktjs/shared';\nimport type { KTAvailableContent, KTRawContent } from '../types/h.js';\nimport { isKT } from '../reactive/common.js';\n\nconst assureNode = (o: any) => ($isNode(o) ? o : document.createTextNode(o));\n\nfunction apdSingle(element: HTMLElement | DocumentFragment | SVGElement | MathMLElement, c: KTAvailableContent) {\n  // & Ignores falsy values, consistent with React's behavior\n  if (c === undefined || c === null || c === false) {\n    return;\n  }\n\n  if (isKT(c)) {\n    let node = assureNode(c.value);\n    element.appendChild(node);\n    c.addOnChange((newValue, _oldValue) => {\n      const oldNode = node;\n      node = assureNode(newValue);\n      oldNode.replaceWith(node);\n    });\n  } else {\n    const node = assureNode(c);\n    element.appendChild(node);\n    // Handle KTFor anchor\n    const list = (node as any).__kt_for_list__ as any[];\n    if ($isArray(list)) {\n      apd(element, list);\n    }\n  }\n}\n\nfunction apd(element: HTMLElement | DocumentFragment | SVGElement | MathMLElement, c: KTAvailableContent) {\n  if ($isThenable(c)) {\n    c.then((r) => apd(element, r));\n  } else if ($isArray(c)) {\n    for (let i = 0; i < c.length; i++) {\n      // & might be thenable here too\n      const ci = c[i];\n      if ($isThenable(ci)) {\n        const comment = document.createComment('ktjs-promise-placeholder');\n        element.appendChild(comment);\n        ci.then((awaited) => comment.replaceWith(awaited));\n      } else {\n        apdSingle(element, ci);\n      }\n    }\n  } else {\n    // & here is thened, so must be a simple elementj\n    apdSingle(element, c);\n  }\n}\n\nexport function applyContent(element: HTMLElement | SVGElement | MathMLElement, content: KTRawContent): void {\n  if ($isArray(content)) {\n    for (let i = 0; i < content.length; i++) {\n      apd(element, content[i]);\n    }\n  } else {\n    apd(element, content as KTAvailableContent);\n  }\n}\n","// # internal methods that cannot be placed in @ktjs/shared\n\nexport const IdGenerator = {\n  _refOnChangeId: 1,\n  get refOnChangeId() {\n    return this._refOnChangeId++;\n  },\n  _computedOnChangeId: 1,\n  get computedOnChangeId() {\n    return this._computedOnChangeId++;\n  },\n  _kid: 1,\n  get kid() {\n    return this._kid++;\n  },\n};\n","import type { KTComputed } from './computed.js';\n\nimport { IdGenerator } from '../common.js';\nimport { KTReactiveType } from './common.js';\n\nexport type ChangeHandler<T> = (newValue: T, oldValue: T) => void;\nexport type ChangeHandlerKey = string | number;\nexport class KTReactive<T> {\n  /**\n   * Indicates that this is a KTRef instance\n   */\n  public readonly isKT: true = true;\n\n  public readonly ktType: KTReactiveType = KTReactiveType.Reative;\n\n  /**\n   * @internal\n   */\n  protected _value: T;\n\n  /**\n   * & Here we trust developers using addOnChange properly. `ChangeHandler<any>` is aimed to mute some unnecessary type errors.\n   */\n  protected _changeHandlers: Map<ChangeHandlerKey, ChangeHandler<any>> = new Map();\n\n  /**\n   * @internal\n   */\n  protected _emit(newValue: T, oldValue: T) {\n    this._changeHandlers.forEach((c) => c(newValue, oldValue));\n    return this;\n  }\n\n  constructor(_value: T) {\n    this._value = _value;\n    this._changeHandlers = new Map();\n  }\n\n  /**\n   * If new value and old value are both nodes, the old one will be replaced in the DOM\n   * - Use `.mutable` to modify the value.\n   * @readonly\n   */\n  get value() {\n    return this._value;\n  }\n\n  set value(_newValue: T) {\n    // Only allow KTRef to be set.\n  }\n\n  /**\n   * Force all listeners to run even when reference identity has not changed.\n   *\n   * Useful for in-place array/object mutations.\n   */\n  notify(): this {\n    return this._emit(this._value, this._value);\n  }\n\n  /**\n   * Ccreate a computed value based on this `KTReactive` instance.\n   * @param calculator A function that calculates the computed value based on the current value of this `KTReactive` instance.\n   * @param dependencies Optional additional dependencies that the computed value relies on.\n   * @returns A `KTComputed` instance\n   *\n   * @see ./computed.ts implemented in `KTComputed`\n   */\n  map<R>(calculator: (currentValue: T) => R, dependencies?: Array<KTReactive<any>>): KTComputed<R>;\n  map<R>(..._args: unknown[]): KTComputed<R> {\n    throw new Error('This is meant to be override in computed.ts');\n  }\n\n  /**\n   * Register a callback when the value changes\n   * @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.\n   * @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.\n   */\n  addOnChange(callback: ChangeHandler<T>, key?: ChangeHandlerKey): this {\n    if (typeof callback !== 'function') {\n      $throw('KTRef.addOnChange: callback must be a function');\n    }\n    const k = key ?? IdGenerator.refOnChangeId;\n    this._changeHandlers.set(k, callback);\n    return this;\n  }\n\n  removeOnChange(key: ChangeHandlerKey): ChangeHandler<any> | undefined {\n    const callback = this._changeHandlers.get(key);\n    this._changeHandlers.delete(key);\n    return callback;\n  }\n\n  /**\n   * Generate a computed value based on this ref, using keys to access nested properties.\n   * - `ref.get('a', 'b')` is equivalent to `ref.map((v) => v.a.b)`, but simpler to write.\n   * @returns A `KTComputed` object\n   * @throws when `a.b.c` throws error(e.g. `a.b` is undefined, then it throws when calling `undefined.c`).\n   */\n  get<\n    K0 extends keyof T,\n    K1 extends keyof T[K0],\n    K2 extends keyof T[K0][K1],\n    K3 extends keyof T[K0][K1][K2],\n    K4 extends keyof T[K0][K1][K2][K3],\n  >(key0: K0, key1: K1, key2: K2, key3: K3, key4: K4): KTComputed<T[K0][K1][K2][K3][K4]>;\n  /**\n   * Generate a computed value based on this ref, using keys to access nested properties.\n   * - `ref.get('a', 'b')` is equivalent to `ref.map((v) => v.a.b)`, but simpler to write.\n   * @returns A `KTComputed` object\n   * @throws when `a.b.c` throws error(e.g. `a.b` is undefined, then it throws when calling `undefined.c`).\n   */\n  get<K0 extends keyof T, K1 extends keyof T[K0], K2 extends keyof T[K0][K1], K3 extends keyof T[K0][K1][K2]>(\n    key0: K0,\n    key1: K1,\n    key2: K2,\n    key3: K3,\n  ): KTComputed<T[K0][K1][K2][K3]>;\n  /**\n   * Generate a computed value based on this ref, using keys to access nested properties.\n   * - `ref.get('a', 'b')` is equivalent to `ref.map((v) => v.a.b)`, but simpler to write.\n   * @returns A `KTComputed` object\n   * @throws when `a.b.c` throws error(e.g. `a.b` is undefined, then it throws when calling `undefined.c`).\n   */\n  get<K0 extends keyof T, K1 extends keyof T[K0], K2 extends keyof T[K0][K1]>(\n    key0: K0,\n    key1: K1,\n    key2: K2,\n  ): KTComputed<T[K0][K1][K2]>;\n  /**\n   * Generate a computed value based on this ref, using keys to access nested properties.\n   * - `ref.get('a', 'b')` is equivalent to `ref.map((v) => v.a.b)`, but simpler to write.\n   * @returns A `KTComputed` object\n   * @throws when `a.b.c` throws error(e.g. `a.b` is undefined, then it throws when calling `undefined.c`).\n   */\n  get<K0 extends keyof T, K1 extends keyof T[K0]>(key0: K0, key1: K1): KTComputed<T[K0][K1]>;\n  /**\n   * Generate a computed value based on this ref, using keys to access nested properties.\n   * - `ref.get('a', 'b')` is equivalent to `ref.map((v) => v.a.b)`, but simpler to write.\n   * @returns A `KTComputed` object\n   * @throws when `a.b.c` throws error(e.g. `a.b` is undefined, then it throws when calling `undefined.c`).\n   */\n  get<K0 extends keyof T>(key0: K0): KTComputed<T[K0]>;\n  get(..._keys: PropertyKey[]) {\n    // & It is implemented in computed.ts since it depends on KTComputed.\n    return {} as any;\n  }\n}\n\n// & Shockingly, If T is boolean, KTReactify<T> becomes KTReactive<true> | KTReactive<false>. It causes @ktjs/mui that disabledRefs not assignable.\n/**\n * Makes `KTReactify<'a' | 'b'> to be KTReactive<'a'> | KTReactive<'b'>`\n */\nexport type KTReactifySplit<T> = T extends boolean ? KTReactive<boolean> : T extends any ? KTReactive<T> : never;\n\nexport type KTReactifyObject<T extends object> = {\n  [K in keyof T]: KTReactifySplit<T[K]>;\n};\n\nexport type KTReactifyProps<T extends object> = {\n  [K in keyof T]: KTReactifySplit<Exclude<T[K], undefined>> | T[K];\n};\n\n/**\n * Makes `KTReactify<'a' | 'b'>` to be `KTReactive<'a' | 'b'>`\n */\nexport type KTReactify<T> = [T] extends [KTReactive<infer U>] ? KTReactive<U> : KTReactive<T>;\nexport type KTMaybeReactive<T> = T | KTReactify<T>;\nexport type KTMaybeReactiveProps<T extends object> = {\n  [K in keyof T]: K extends `on:${string}` ? T[K] : KTMaybeReactive<Exclude<T[K], undefined>> | T[K];\n};\n","// Use microqueue to schedule the flush of pending reactions\n\nimport type { KTRef } from './ref.js';\n\nconst reactiveToOldValue = new Map<KTRef<any>, any>();\n\nlet scheduled = false;\n\nexport const markMutation = (reactive: KTRef<any>) => {\n  if (!reactiveToOldValue.has(reactive)) {\n    // @ts-expect-error accessing protected property\n    reactiveToOldValue.set(reactive, reactive._value);\n\n    // # schedule by microqueue\n    if (scheduled) {\n      return;\n    }\n\n    scheduled = true;\n    Promise.resolve().then(() => {\n      scheduled = false;\n      reactiveToOldValue.forEach((oldValue, reactive) => {\n        // @ts-expect-error accessing protected property\n        reactive._changeHandlers.forEach((handler) => handler(reactive.value, oldValue));\n      });\n      reactiveToOldValue.clear();\n    });\n  }\n};\n","import type { JSX } from '../types/jsx.js';\n\nimport { $emptyFn, $is } from '@ktjs/shared';\nimport { isRef, KTReactiveType } from './common.js';\nimport { KTReactive } from './reactive.js';\nimport { markMutation } from './scheduler.js';\nimport { KTComputed } from './computed.js';\n\nexport class KTRef<T> extends KTReactive<T> {\n  public readonly ktType = KTReactiveType.Ref;\n\n  // ! Cannot be omitted, otherwise this will override `KTReactive` with only setter. And getter will return undefined.\n  get value() {\n    return this._value;\n  }\n\n  set value(newValue: T) {\n    if ($is(newValue, this._value)) {\n      return;\n    }\n    const oldValue = this._value;\n    this._value = newValue;\n    this._emit(newValue, oldValue);\n  }\n\n  /**\n   * Used to mutate the value in-place.\n   * - internal value is changed instantly, but the change handlers will be called in the next microtask.\n   */\n  get draft() {\n    markMutation(this);\n    return this._value;\n  }\n}\n\n/**\n * Create a `KTRef` object.\n * - use `refObject.state` to get plain data\n * - use `refObject.map(calculator)` to create a computed value based on this ref\n * - use `refObject.mutable` to set too, but it will recalculate in the next microtask. Useful for deep objects, `Map`, `Set` or other custom objects\n *\n * @param value any data\n * @param onChange event handler triggered when the value changes, with signature `(newValue, oldValue) => void`\n * @returns\n */\nexport const ref = <T = JSX.Element>(value?: T) => new KTRef<T>(value as any);\n\n/**\n * Assert k-model to be a ref object\n */\nexport const $modelOrRef = <T = any>(props: any, defaultValue?: T): KTRef<T> => {\n  // & props is an object. Won't use it in any other place\n  if ('k-model' in props) {\n    const kmodel = props['k-model'];\n    if (isRef(kmodel)) {\n      return kmodel;\n    } else {\n      $throw(`k-model data must be a KTRef object, please use 'ref(...)' to wrap it.`);\n    }\n  }\n  return ref(defaultValue) as KTRef<T>;\n};\n\nconst $refSetter = <T>(props: { ref?: KTRef<T> }, node: T) => (props.ref!.value = node);\ntype RefSetter<T> = (props: { ref?: KTRef<T> }, node: T) => void;\n\n/**\n * Whether `props.ref` is a `KTRef` only needs to be checked in the initial render\n */\nexport const $initRef = <T extends Node>(props: { ref?: KTRef<T> }, node: T): RefSetter<T> => {\n  if (!('ref' in props)) {\n    return $emptyFn;\n  }\n\n  const r = props.ref;\n  if (isRef(r)) {\n    r.value = node;\n    return $refSetter;\n  } else {\n    $throw('Fragment: ref must be a KTRef');\n  }\n};\n","import type { JSX } from '../types/jsx.js';\n\nimport { $is, $stringify } from '@ktjs/shared';\nimport { isKT, KTReactiveType } from './common.js';\nimport { KTReactive } from './reactive.js';\n\nexport class KTComputed<T> extends KTReactive<T> {\n  public readonly ktType = KTReactiveType.Computed;\n\n  /**\n   * @internal\n   */\n  private _calculator: () => T;\n\n  /**\n   * @internal\n   */\n  private _recalculate(forceEmit: boolean = false): this {\n    const oldValue = this._value;\n    const newValue = this._calculator();\n    if ($is(oldValue, newValue)) {\n      if (forceEmit) {\n        this._emit(newValue, oldValue);\n      }\n      return this;\n    }\n    this._value = newValue;\n    this._emit(newValue, oldValue);\n    return this;\n  }\n\n  constructor(_calculator: () => T, dependencies: Array<KTReactive<unknown>>) {\n    super(_calculator());\n    this._calculator = _calculator;\n\n    for (let i = 0; i < dependencies.length; i++) {\n      dependencies[i].addOnChange(() => this._recalculate());\n    }\n  }\n\n  /**\n   * If new value and old value are both nodes, the old one will be replaced in the DOM\n   */\n  get value() {\n    return this._value;\n  }\n\n  set value(_newValue: T) {\n    $warn(`'value' of Computed are read-only.`);\n  }\n\n  /**\n   * Force listeners to run once with the latest computed result.\n   */\n  notify(): this {\n    return this._recalculate(true);\n  }\n}\n\nKTReactive.prototype.map = function <R>(calculator: (v: unknown) => R, dependencies?: Array<KTReactive<any>>) {\n  return new KTComputed(() => calculator(this._value), dependencies ? [this, ...dependencies] : [this]);\n};\n\nKTReactive.prototype.get = function (...keys: string[]) {\n  // # This method is 10 times faster than `for v=v[keys[i]]`\n  const reader = new Function('v', `return v${keys.map((k) => `[${$stringify(k)}]`).join('')}`);\n  return new KTComputed(() => reader(this._value), [this]) as any;\n};\n\n/**\n * Create a reactive computed value\n * @param computeFn\n * @param dependencies refs and computeds that this computed depends on\n */\nexport function computed<T = JSX.Element>(computeFn: () => T, dependencies: Array<KTReactive<any>>): KTComputed<T> {\n  if (dependencies.some((v) => !isKT(v))) {\n    $throw('computed: all reactives must be KTRef or KTComputed instances');\n  }\n  return new KTComputed<T>(computeFn, dependencies);\n}\n","import { $emptyFn } from '@ktjs/shared';\nimport type { KTReactive } from './reactive.js';\n\ninterface KTEffectOptions {\n  lazy: boolean;\n  onCleanup: () => void;\n  debugName: string;\n}\n\n/**\n * Register a reactive effect with options.\n * @param effectFn The effect function to run when dependencies change\n * @param reactives The reactive dependencies\n * @param options Effect options: lazy, onCleanup, debugName\n * @returns stop function to remove all listeners\n */\nexport function effect(effectFn: () => void, reactives: Array<KTReactive<any>>, options?: Partial<KTEffectOptions>) {\n  const { lazy = false, onCleanup = $emptyFn, debugName = '' } = Object(options);\n  const listenerKeys: Array<string | number> = [];\n\n  let active = true;\n\n  const run = () => {\n    if (!active) {\n      return;\n    }\n\n    // cleanup before rerun\n    onCleanup();\n\n    try {\n      effectFn();\n    } catch (err) {\n      $debug('effect error:', debugName, err);\n    }\n  };\n\n  // subscribe to dependencies\n  for (let i = 0; i < reactives.length; i++) {\n    listenerKeys[i] = i;\n    reactives[i].addOnChange(run, i);\n  }\n\n  // auto run unless lazy\n  if (!lazy) {\n    run();\n  }\n\n  // stop function\n  return () => {\n    if (!active) {\n      return;\n    }\n    active = false;\n\n    for (let i = 0; i < reactives.length; i++) {\n      reactives[i].removeOnChange(listenerKeys[i]);\n    }\n\n    // final cleanup\n    onCleanup();\n  };\n}\n","import type { KTReactive } from './reactive.js';\nimport type { JSX } from '../types/jsx.js';\nimport { isKT } from './common.js';\nimport { ref } from './ref.js';\n\n/**\n *\n * @param value\n * @returns\n */\nexport const toReactive = <T>(value: T | KTReactive<T>): KTReactive<T> =>\n  isKT(value) ? value : (ref(value as T) as KTReactive<T>);\n\n/**\n * Extracts the value from a KTReactive, or returns the value directly if it's not reactive.\n */\nexport function dereactive<T = JSX.Element>(value: T | KTReactive<T>): T {\n  return isKT<T>(value) ? value.value : value;\n}\n\nexport * from './common.js';\nexport * from './ref.js';\nexport * from './computed.js';\nexport * from './effect.js';\nexport type * from './reactive.js';\n","import { $applyModel, type InputElementTag } from '@ktjs/shared';\nimport type { KTRef } from '../reactive/ref.js';\nimport { isKT } from '../reactive/index.js';\n\nexport function applyKModel(element: HTMLElementTagNameMap[InputElementTag], valueRef: KTRef<any>) {\n  if (!isKT(valueRef)) {\n    $throw('k-model value must be a KTRef.');\n  }\n\n  if (element.tagName === 'INPUT') {\n    if (element.type === 'radio' || element.type === 'checkbox') {\n      $applyModel(element, valueRef, 'checked', 'change');\n      return;\n    }\n\n    if (element.type === 'number') {\n      $applyModel(element, valueRef, 'checked', 'change', Number);\n      return;\n    }\n\n    if (element.type === 'date') {\n      $applyModel(element, valueRef, 'checked', 'change', (v: any) => new Date(v));\n      return;\n    }\n\n    $applyModel(element, valueRef, 'value', 'input');\n  } else if (element.tagName === 'SELECT') {\n    $applyModel(element, valueRef, 'value', 'change');\n  } else if (element.tagName === 'TEXTAREA') {\n    $applyModel(element, valueRef, 'value', 'input');\n  } else {\n    $warn('not supported element for k-model:');\n  }\n}\n","import type { HTMLTag, MathMLTag, SVGTag } from '@ktjs/shared';\nimport type { KTRawAttr, KTRawContent, HTML } from '../types/h.js';\n\nimport { applyAttr } from './attr.js';\nimport { applyContent } from './content.js';\nimport { applyKModel } from './model.js';\n\n/**\n * Create an enhanced HTMLElement.\n * - Only supports HTMLElements, **NOT** SVGElements or other Elements.\n * @param tag tag of an `HTMLElement`\n * @param attr attribute object or className\n * @param content a string or an array of HTMLEnhancedElement as child nodes\n *\n * __PKG_INFO__\n */\nexport const h = <T extends HTMLTag | SVGTag | MathMLTag>(\n  tag: T,\n  attr?: KTRawAttr,\n  content?: KTRawContent,\n): HTML<T> => {\n  if (typeof tag !== 'string') {\n    $throw('tagName must be a string.');\n  }\n\n  // * start creating the element\n  const element = document.createElement(tag) as HTML<T>;\n  if (typeof attr === 'object' && attr !== null && 'k-model' in attr) {\n    applyKModel(element as any, attr['k-model'] as any);\n  }\n\n  // * Handle content\n  applyAttr(element, attr);\n  applyContent(element, content);\n\n  return element;\n};\n\nexport const svg = <T extends SVGTag>(tag: T, attr?: KTRawAttr, content?: KTRawContent): HTML<T> => {\n  if (typeof tag !== 'string') {\n    $throw('tagName must be a string.');\n  }\n\n  // * start creating the element\n  const element = document.createElementNS('http://www.w3.org/2000/svg', tag) as HTML<T>;\n\n  // * Handle content\n  applyAttr(element, attr);\n  applyContent(element, content);\n\n  if (typeof attr === 'object' && attr !== null && 'k-model' in attr) {\n    applyKModel(element as any, attr['k-model'] as any);\n  }\n\n  return element;\n};\n\nexport const mathml = <T extends MathMLTag>(tag: T, attr?: KTRawAttr, content?: KTRawContent): HTML<T> => {\n  if (typeof tag !== 'string') {\n    $throw('tagName must be a string.');\n  }\n\n  // * start creating the element\n  const element = document.createElementNS('http://www.w3.org/1998/Math/MathML', tag) as HTML<T>;\n\n  // * Handle content\n  applyAttr(element, attr);\n  applyContent(element, content);\n\n  if (typeof attr === 'object' && attr !== null && 'k-model' in attr) {\n    applyKModel(element as any, attr['k-model'] as any);\n  }\n\n  return element;\n};\n","import type { KTReactive } from '../reactive/reactive.js';\nimport type { KTRawContent } from '../types/h.js';\nimport type { JSX } from '../types/jsx.js';\nimport type { KTRef } from '../reactive/ref.js';\n\nimport { $forEach, $isArray } from '@ktjs/shared';\nimport { $initRef, isKT, toReactive } from '../reactive/index.js';\n\nconst FRAGMENT_MOUNT_PATCHED = '__kt_fragment_mount_patched__';\nconst FRAGMENT_MOUNT = '__kt_fragment_mount__';\n\nif (typeof Node !== 'undefined' && !(globalThis as any)[FRAGMENT_MOUNT_PATCHED]) {\n  (globalThis as any)[FRAGMENT_MOUNT_PATCHED] = true;\n\n  const originAppendChild = Node.prototype.appendChild;\n  Node.prototype.appendChild = function (node) {\n    const result = originAppendChild.call(this, node);\n    const mount = (node as any)[FRAGMENT_MOUNT];\n    if (typeof mount === 'function') {\n      mount();\n    }\n    return result as any;\n  };\n\n  const originInsertBefore = Node.prototype.insertBefore;\n  Node.prototype.insertBefore = function (node: Node, child: Node | null) {\n    const result = originInsertBefore.call(this, node, child);\n    const mount = (node as any)[FRAGMENT_MOUNT];\n    if (typeof mount === 'function') {\n      mount();\n    }\n    return result as any;\n  };\n}\n\nexport interface FragmentProps<T extends JSX.Element = JSX.Element> {\n  /** Array of child elements, supports reactive arrays */\n  children: T[] | KTReactive<T[]>;\n\n  /** element key function for optimization (future enhancement) */\n  key?: (element: T, index: number, array: T[]) => any;\n\n  /** ref to get the anchor node */\n  ref?: KTRef<JSX.Element>;\n}\n\n/**\n * Fragment - Container component for managing arrays of child elements\n *\n * Features:\n * 1. Returns a comment anchor node, child elements are inserted after the anchor\n * 2. Supports reactive arrays, automatically updates DOM when array changes\n * 3. Basic version uses simple replacement algorithm (remove all old elements, insert all new elements)\n * 4. Future enhancement: key-based optimization\n *\n * Usage example:\n * ```tsx\n * const children = ref([<div>A</div>, <div>B</div>]);\n * const fragment = <Fragment children={children} />;\n * document.body.appendChild(fragment);\n *\n * // Automatic update\n * children.value = [<div>C</div>, <div>D</div>];\n * ```\n */\nexport function Fragment<T extends JSX.Element = JSX.Element>(props: FragmentProps<T>): JSX.Element {\n  const elements: T[] = [];\n  const anchor = document.createComment('kt-fragment') as unknown as JSX.Element;\n  let inserted = false;\n  let observer: MutationObserver | undefined;\n\n  const redraw = () => {\n    const newElements = childrenRef.value;\n    const parent = anchor.parentNode;\n\n    if (!parent) {\n      elements.length = 0;\n      for (let i = 0; i < newElements.length; i++) {\n        elements.push(newElements[i]);\n      }\n      (anchor as any).__kt_fragment_list__ = elements;\n      return;\n    }\n\n    for (let i = 0; i < elements.length; i++) {\n      elements[i].remove();\n    }\n\n    const fragment = document.createDocumentFragment();\n    elements.length = 0;\n\n    for (let i = 0; i < newElements.length; i++) {\n      const element = newElements[i];\n      elements.push(element);\n      fragment.appendChild(element);\n    }\n\n    parent.insertBefore(fragment, anchor.nextSibling);\n    inserted = true;\n    delete (anchor as any)[FRAGMENT_MOUNT];\n    observer?.disconnect();\n    observer = undefined;\n    (anchor as any).__kt_fragment_list__ = elements;\n  };\n\n  const childrenRef = toReactive(props.children).addOnChange(redraw);\n\n  const renderInitial = () => {\n    const current = childrenRef.value;\n    elements.length = 0;\n\n    const fragment = document.createDocumentFragment();\n    for (let i = 0; i < current.length; i++) {\n      const element = current[i];\n      elements.push(element);\n      fragment.appendChild(element);\n    }\n\n    (anchor as any).__kt_fragment_list__ = elements;\n\n    const parent = anchor.parentNode;\n    if (parent && !inserted) {\n      parent.insertBefore(fragment, anchor.nextSibling);\n      inserted = true;\n    }\n  };\n\n  renderInitial();\n\n  (anchor as any)[FRAGMENT_MOUNT] = () => {\n    if (!inserted && anchor.parentNode) {\n      redraw();\n    }\n  };\n\n  observer = new MutationObserver(() => {\n    if (anchor.parentNode && !inserted) {\n      redraw();\n      observer?.disconnect();\n      observer = undefined;\n    }\n  });\n\n  observer.observe(document.body, { childList: true, subtree: true });\n\n  $initRef(props, anchor);\n\n  return anchor;\n}\n\n/**\n * Convert KTRawContent to HTMLElement array\n */\nexport function convertChildrenToElements(children: KTRawContent): HTMLElement[] {\n  const elements: HTMLElement[] = [];\n\n  const processChild = (child: any): void => {\n    if (child === undefined || child === null || child === false || child === true) {\n      // Ignore null, undefined, false, true\n      return;\n    }\n\n    if ($isArray(child)) {\n      // Recursively process array\n      $forEach(child, processChild);\n      return;\n    }\n\n    if (typeof child === 'string' || typeof child === 'number') {\n      const span = document.createElement('span');\n      span.textContent = String(child);\n      elements.push(span);\n      return;\n    }\n\n    if (child instanceof HTMLElement) {\n      elements.push(child);\n      return;\n    }\n\n    if (isKT(child)) {\n      processChild(child.value);\n      return;\n    }\n\n    $warn('Fragment: unsupported child type', child);\n    if (process.env.IS_DEV) {\n      throw new Error(`Fragment: unsupported child type`);\n    }\n  };\n\n  processChild(children);\n  return elements;\n}\n","import type { JSXTag } from '@ktjs/shared';\nimport type { KTAttribute } from '../types/h.js';\nimport type { JSX } from '../types/jsx.js';\nimport { h } from '../h/index';\n\nexport const jsxh = (tag: JSXTag, props: KTAttribute): JSX.Element =>\n  (typeof tag === 'function' ? tag(props) : h(tag, props, props.children)) as JSX.Element;\n\nexport const placeholder = (data: string): JSX.Element => document.createComment(data) as unknown as JSX.Element;\n","import type { JSXTag, MathMLTag, SVGTag } from '@ktjs/shared';\nimport type { KTAttribute, KTRawContent } from '../types/h.js';\nimport type { JSX } from '../types/jsx.js';\n\nimport { h, mathml as _mathml, svg as _svg } from '../h/index.js';\nimport { $initRef, isComputed } from '../reactive/index.js';\nimport { convertChildrenToElements, Fragment as FragmentArray } from './fragment.js';\nimport { jsxh, placeholder } from './common.js';\n\nfunction create(\n  creator: (tag: any, props: KTAttribute, content?: KTRawContent) => JSX.Element,\n  tag: any,\n  props: KTAttribute,\n) {\n  if (props.ref && isComputed(props.ref)) {\n    $throw('Cannot assign a computed value to an element.');\n  }\n  const el = creator(tag, props, props.children);\n  $initRef(props, el);\n  return el;\n}\n\nexport const jsx = (tag: JSXTag, props: KTAttribute): JSX.Element => create(jsxh, tag, props);\nexport const svg = (tag: SVGTag, props: KTAttribute): JSX.Element => create(_svg, tag, props);\nexport const mathml = (tag: MathMLTag, props: KTAttribute): JSX.Element => create(_mathml, tag, props);\nexport { svg as svgRuntime, mathml as mathmlRuntime };\n\n/**\n * Fragment support - returns an array of children\n * Enhanced Fragment component that manages arrays of elements\n */\nexport function Fragment(props: { children?: KTRawContent }): JSX.Element {\n  const { children } = props ?? {};\n\n  if (!children) {\n    return placeholder('kt-fragment-empty');\n  }\n\n  const elements = convertChildrenToElements(children);\n\n  return FragmentArray({ children: elements });\n}\n\n/**\n * JSX Development runtime - same as jsx but with additional dev checks\n */\nexport const jsxDEV: typeof jsx = (...args) => {\n  // console.log('JSX DEV called:', ...args);\n  // console.log('children', (args[1] as any)?.children);\n  return jsx(...args);\n};\n\n/**\n * JSX runtime for React 17+ automatic runtime\n * This is called when using jsx: \"react-jsx\" or \"react-jsxdev\"\n */\nexport const jsxs = jsx;\n\n// Export h as the classic JSX factory for backward compatibility\nexport { h, h as createElement };\n","import { $isThenable } from '@ktjs/shared';\nimport type { KTComponent, KTRawContent } from '../types/h.js';\nimport type { JSX } from '../types/jsx.js';\nimport type { KTRef } from '../reactive/ref.js';\n\n/**\n * Extract component props type (excluding ref and children)\n */\ntype ExtractComponentProps<T> = T extends (props: infer P) => any ? Omit<P, 'ref' | 'children'> : {};\n\nexport function KTAsync<T extends KTComponent>(\n  props: {\n    ref?: KTRef<JSX.Element>;\n    skeleton?: JSX.Element;\n    component: T;\n    children?: KTRawContent;\n  } & ExtractComponentProps<T>,\n): JSX.Element {\n  const raw = props.component(props);\n  let comp: JSX.Element =\n    props.skeleton ?? (document.createComment('ktjs-suspense-placeholder') as unknown as JSX.Element);\n\n  if ($isThenable(raw)) {\n    raw.then((resolved) => comp.replaceWith(resolved));\n  } else {\n    comp = raw as JSX.Element;\n  }\n\n  return comp;\n}\n","import type { KTRef } from '../reactive/ref.js';\nimport type { KTReactive } from '../reactive/reactive.js';\nimport type { JSX } from '../types/jsx.js';\nimport { $initRef, toReactive } from '../reactive/index.js';\nimport { $identity } from '@ktjs/shared';\n\nexport type KTForElement = JSX.Element;\n\nexport interface KTForProps<T> {\n  ref?: KTRef<KTForElement>;\n  list: T[] | KTReactive<T[]>;\n  key?: (item: T, index: number, array: T[]) => any;\n  map?: (item: T, index: number, array: T[]) => JSX.Element;\n}\n\n// task 对于template标签的for和if，会编译为fragment，可特殊处理，让它们保持原样\n/**\n * KTFor - List rendering component with key-based optimization\n * Returns a Comment anchor node with rendered elements in __kt_for_list__\n */\nexport function KTFor<T>(props: KTForProps<T>): KTForElement {\n  const redraw = () => {\n    const newList = listRef.value;\n\n    const parent = anchor.parentNode;\n    if (!parent) {\n      // If not in DOM yet, just rebuild the list\n      const newElements: HTMLElement[] = [];\n      nodeMap.clear();\n      for (let index = 0; index < newList.length; index++) {\n        const item = newList[index];\n        const itemKey = currentKey(item, index, newList);\n        const node = currentMap(item, index, newList);\n        nodeMap.set(itemKey, node);\n        newElements.push(node);\n      }\n      (anchor as any).__kt_for_list__ = newElements;\n      return anchor;\n    }\n\n    const oldLength = (anchor as any).__kt_for_list__.length;\n    const newLength = newList.length;\n\n    // Fast path: empty list\n    if (newLength === 0) {\n      nodeMap.forEach((node) => node.remove());\n      nodeMap.clear();\n      (anchor as any).__kt_for_list__ = [];\n      return anchor;\n    }\n\n    // Fast path: all new items\n    if (oldLength === 0) {\n      const newElements: HTMLElement[] = [];\n      const fragment = document.createDocumentFragment();\n      for (let i = 0; i < newLength; i++) {\n        const item = newList[i];\n        const itemKey = currentKey(item, i, newList);\n        const node = currentMap(item, i, newList);\n        nodeMap.set(itemKey, node);\n        newElements.push(node);\n        fragment.appendChild(node);\n      }\n      parent.insertBefore(fragment, anchor.nextSibling);\n      (anchor as any).__kt_for_list__ = newElements;\n      return anchor;\n    }\n\n    // Build key index map and new elements array in one pass\n    const newKeyToNewIndex = new Map<any, number>();\n    const newElements: HTMLElement[] = new Array(newLength);\n    for (let i = 0; i < newLength; i++) {\n      const item = newList[i];\n      const itemKey = currentKey(item, i, newList);\n      newKeyToNewIndex.set(itemKey, i);\n\n      if (nodeMap.has(itemKey)) {\n        // Reuse existing node\n        newElements[i] = nodeMap.get(itemKey)!;\n      } else {\n        // Create new node\n        newElements[i] = currentMap(item, i, newList);\n      }\n    }\n\n    // Remove nodes not in new list\n    const toRemove: HTMLElement[] = [];\n    nodeMap.forEach((node, key) => {\n      if (!newKeyToNewIndex.has(key)) {\n        toRemove.push(node);\n      }\n    });\n    for (let i = 0; i < toRemove.length; i++) {\n      toRemove[i].remove();\n    }\n\n    // Reorder existing nodes and insert new nodes in a single pass.\n    let currentNode = anchor.nextSibling;\n    for (let i = 0; i < newLength; i++) {\n      const node = newElements[i];\n      if (currentNode !== node) {\n        parent.insertBefore(node, currentNode);\n      } else {\n        currentNode = currentNode.nextSibling;\n      }\n    }\n\n    // Update maps\n    nodeMap.clear();\n    for (let i = 0; i < newLength; i++) {\n      const itemKey = currentKey(newList[i], i, newList);\n      nodeMap.set(itemKey, newElements[i]);\n    }\n    (anchor as any).__kt_for_list__ = newElements;\n    return anchor;\n  };\n\n  const { key: currentKey = (item: T) => item, map: currentMap = $identity } = props;\n  const listRef = toReactive(props.list).addOnChange(redraw);\n  const anchor = document.createComment('kt-for') as unknown as KTForElement;\n\n  // Map to track rendered nodes by key\n  const nodeMap = new Map<any, HTMLElement>();\n\n  // Render initial list\n  const elements: HTMLElement[] = [];\n  for (let index = 0; index < listRef.value.length; index++) {\n    const item = listRef.value[index];\n    const itemKey = currentKey(item, index, listRef.value);\n    const node = currentMap(item, index, listRef.value);\n    nodeMap.set(itemKey, node);\n    elements.push(node);\n  }\n\n  (anchor as any).__kt_for_list__ = elements;\n\n  $initRef(props, anchor);\n\n  return anchor;\n}\n","import type { JSXTag } from '@ktjs/shared';\nimport type { KTAttribute } from '../types/h.js';\nimport type { KTReactive } from '../reactive/reactive.js';\n\nimport { isKT } from '../reactive/index.js';\nimport { jsxh, placeholder } from './common.js';\n\nexport function KTConditional(\n  condition: any | KTReactive<any>,\n  tagIf: JSXTag,\n  propsIf: KTAttribute,\n  tagElse?: JSXTag,\n  propsElse?: KTAttribute,\n) {\n  if (!isKT(condition)) {\n    return condition ? jsxh(tagIf, propsIf) : tagElse ? jsxh(tagElse, propsElse!) : placeholder('kt-conditional');\n  }\n\n  if (tagElse) {\n    let current = condition.value ? jsxh(tagIf, propsIf) : jsxh(tagElse!, propsElse!);\n    condition.addOnChange((newValue) => {\n      const old = current;\n      current = newValue ? jsxh(tagIf, propsIf) : jsxh(tagElse!, propsElse!);\n      old.replaceWith(current);\n    });\n    return current;\n  } else {\n    const dummy = placeholder('kt-conditional') as HTMLElement;\n    let current = condition.value ? jsxh(tagIf, propsIf) : dummy;\n    condition.addOnChange((newValue) => {\n      const old = current;\n      current = newValue ? jsxh(tagIf, propsIf) : dummy;\n      old.replaceWith(current);\n    });\n    return current;\n  }\n}\n"],"names":["isKT","obj","isRef","undefined","ktType","isComputed","booleanHandler","element","key","value","setAttribute","valueHandler","handlers","checked","selected","valueAsDate","valueAsNumber","defaultValue","defaultChecked","defaultSelected","disabled","readOnly","multiple","required","autofocus","open","controls","autoplay","loop","muted","defer","async","hidden","_key","defaultHandler","setElementStyle","style","cssText","applyAttr","attr","Error","classValue","class","className","addOnChange","v","html","innerHTML","o","startsWith","addEventListener","slice","handler","attrIsObject","assureNode","$isNode","document","createTextNode","apdSingle","c","node","appendChild","newValue","_oldValue","oldNode","replaceWith","list","__kt_for_list__","$isArray","apd","$isThenable","then","r","i","length","ci","comment","createComment","awaited","applyContent","content","IdGenerator","_refOnChangeId","refOnChangeId","this","KTReactive","_value","_changeHandlers","Map","_emit","oldValue","forEach","constructor","_newValue","notify","map","_args","callback","k","set","removeOnChange","get","delete","_keys","reactiveToOldValue","scheduled","KTRef","$is","draft","reactive","has","Promise","resolve","clear","markMutation","ref","$modelOrRef","props","kmodel","$refSetter","$initRef","$emptyFn","KTComputed","_calculator","_recalculate","forceEmit","dependencies","super","console","computed","computeFn","some","effect","effectFn","reactives","options","lazy","onCleanup","debugName","Object","listenerKeys","active","run","err","debug","prototype","calculator","keys","reader","Function","$stringify","join","toReactive","dereactive","applyKModel","valueRef","tagName","type","$applyModel","Number","Date","h","tag","createElement","svg","createElementNS","mathml","Node","globalThis","originAppendChild","result","call","mount","originInsertBefore","insertBefore","child","jsxh","children","placeholder","data","create","creator","el","jsx","_svg","_mathml","Fragment","elements","processChild","$forEach","span","textContent","String","push","HTMLElement","warn","convertChildrenToElements","anchor","observer","inserted","redraw","newElements","childrenRef","parent","parentNode","__kt_fragment_list__","remove","fragment","createDocumentFragment","nextSibling","disconnect","current","renderInitial","MutationObserver","observe","body","childList","subtree","FragmentArray","jsxDEV","args","jsxs","KTAsync","raw","component","comp","skeleton","resolved","KTFor","currentKey","item","currentMap","$identity","listRef","newList","nodeMap","index","itemKey","oldLength","newLength","newKeyToNewIndex","Array","toRemove","currentNode","KTConditional","condition","tagIf","propsIf","tagElse","propsElse","old","dummy"],"mappings":"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"}
+{"version":3,"file":"index.mjs","sources":["../src/reactable/common.ts","../src/h/attr-helpers.ts","../src/h/attr.ts","../src/h/content.ts","../src/h/model.ts","../src/h/index.ts","../src/reactable/reactive.ts","../src/reactable/scheduler.ts","../src/reactable/ref.ts","../src/reactable/computed.ts","../src/reactable/effect.ts","../src/reactable/index.ts","../src/jsx/fragment.ts","../src/jsx/common.ts","../src/jsx/jsx-runtime.ts","../src/jsx/async.ts","../src/jsx/for.ts","../src/jsx/if.ts"],"sourcesContent":["import { KTReactiveLike, KTReactiveType, type KTReactive } from './reactive.js';\nimport type { KTRef, KTRefLike, KTSubRef } from './ref.js';\nimport type { KTComputed, KTComputedLike, KTSubComputed } from './computed.js';\n\n// # type guards\nexport function isKT<T = any>(obj: any): obj is KTReactiveLike<T> {\n  return typeof obj?.kid === 'number';\n}\nexport function isReactiveLike<T = any>(obj: any): obj is KTReactiveLike<T> {\n  if (typeof obj.ktype === 'number') {\n    return (obj.ktype & KTReactiveType.ReactiveLike) !== 0;\n  } else {\n    return false;\n  }\n}\n\nexport function isRef<T = any>(obj: any): obj is KTRef<T> {\n  if (typeof obj.ktype === 'number') {\n    return obj.ktype === KTReactiveType.Ref;\n  } else {\n    return false;\n  }\n}\n\nexport function isSubRef<T = any>(obj: any): obj is KTSubRef<T> {\n  if (typeof obj.ktype === 'number') {\n    return obj.ktype === KTReactiveType.SubRef;\n  } else {\n    return false;\n  }\n}\n\nexport function isRefLike<T = any>(obj: any): obj is KTRefLike<T> {\n  if (typeof obj.ktype === 'number') {\n    return (obj.ktype & KTReactiveType.RefLike) !== 0;\n  } else {\n    return false;\n  }\n}\n\nexport function isComputed<T = any>(obj: any): obj is KTComputed<T> {\n  if (typeof obj.ktype === 'number') {\n    return obj.ktype === KTReactiveType.Computed;\n  } else {\n    return false;\n  }\n}\n\nexport function isSubComputed<T = any>(obj: any): obj is KTSubComputed<T> {\n  if (typeof obj.ktype === 'number') {\n    return obj.ktype === KTReactiveType.SubComputed;\n  } else {\n    return false;\n  }\n}\n\nexport function isComputedLike<T = any>(obj: any): obj is KTComputedLike<T> {\n  if (typeof obj.ktype === 'number') {\n    return (obj.ktype & KTReactiveType.ComputedLike) !== 0;\n  } else {\n    return false;\n  }\n}\n\nexport function isReactive<T = any>(obj: any): obj is KTReactive<T> {\n  if (typeof obj.ktype === 'number') {\n    return (obj.ktype & KTReactiveType.Reactive) !== 0;\n  } else {\n    return false;\n  }\n}\n\n// # sub getter/setter factory\n\ntype SubGetter = (s: any) => any;\ntype SubSetter = (s: any, newValue: any) => void;\nconst _getters = new Map<string, SubGetter>();\nconst _setters = new Map<string, SubSetter>();\n\nexport const $createSubGetter = (path: string): SubGetter => {\n  const exist = _getters.get(path);\n  if (exist) {\n    return exist;\n  } else {\n    const cache = new Function('s', `return s${path}`) as SubGetter;\n    _getters.set(path, cache);\n    return cache;\n  }\n};\n\nexport const $createSubSetter = (path: string): SubSetter => {\n  const exist = _setters.get(path);\n  if (exist) {\n    return exist;\n  } else {\n    const cache = new Function('s', 'v', `s${path}=v`) as SubSetter;\n    _setters.set(path, cache);\n    return cache;\n  }\n};\n","const booleanHandler = (element: HTMLElement | SVGElement | MathMLElement, key: string, value: any) => {\n  if (key in element) {\n    (element as any)[key] = !!value;\n  } else {\n    element.setAttribute(key, value);\n  }\n};\n\nconst valueHandler = (element: HTMLElement | SVGElement | MathMLElement, key: string, value: any) => {\n  if (key in element) {\n    (element as any)[key] = value;\n  } else {\n    element.setAttribute(key, value);\n  }\n};\n\n// Attribute handlers map for optimized lookup\nexport const handlers: Record<\n  string,\n  (element: HTMLElement | SVGElement | MathMLElement, key: string, value: any) => void\n> = {\n  checked: booleanHandler,\n  selected: booleanHandler,\n  value: valueHandler,\n  valueAsDate: valueHandler,\n  valueAsNumber: valueHandler,\n  defaultValue: valueHandler,\n  defaultChecked: booleanHandler,\n  defaultSelected: booleanHandler,\n  disabled: booleanHandler,\n  readOnly: booleanHandler,\n  multiple: booleanHandler,\n  required: booleanHandler,\n  autofocus: booleanHandler,\n  open: booleanHandler,\n  controls: booleanHandler,\n  autoplay: booleanHandler,\n  loop: booleanHandler,\n  muted: booleanHandler,\n  defer: booleanHandler,\n  async: booleanHandler,\n  hidden: (element, _key, value) => ((element as HTMLElement).hidden = !!value),\n};\n","import type { KTReactifyProps } from '../reactable/types.js';\nimport type { KTRawAttr, KTAttribute } from '../types/h.js';\nimport { isKT } from '../reactable/common.js';\nimport { handlers } from './attr-helpers.js';\n\nconst defaultHandler = (element: HTMLElement | SVGElement | MathMLElement, key: string, value: any) =>\n  element.setAttribute(key, value);\n\nconst setElementStyle = (\n  element: HTMLElement | SVGElement | MathMLElement,\n  style: Partial<CSSStyleDeclaration> | string,\n) => {\n  if (typeof style === 'string') {\n    (element as HTMLElement).style.cssText = style;\n    return;\n  }\n\n  for (const key in style) {\n    (element as any).style[key as any] = style[key];\n  }\n};\n\nfunction attrIsObject(element: HTMLElement | SVGElement | MathMLElement, attr: KTReactifyProps<KTAttribute>) {\n  const classValue = attr.class || attr.className;\n  if (classValue !== undefined) {\n    if (isKT<string>(classValue)) {\n      element.setAttribute('class', classValue.value);\n      classValue.addOnChange((v) => element.setAttribute('class', v));\n    } else {\n      element.setAttribute('class', classValue);\n    }\n  }\n\n  const style = attr.style;\n  if (style) {\n    if (typeof style === 'string') {\n      element.setAttribute('style', style);\n    } else if (typeof style === 'object') {\n      if (isKT(style)) {\n        setElementStyle(element, style.value);\n        style.addOnChange((v: Partial<CSSStyleDeclaration> | string) => setElementStyle(element, v));\n      } else {\n        setElementStyle(element, style as Partial<CSSStyleDeclaration>);\n      }\n    }\n  }\n\n  // ! Security: `k-html` is an explicit raw HTML escape hatch. kt.js intentionally does not sanitize here; callers must pass only trusted HTML.\n  if ('k-html' in attr) {\n    const html = attr['k-html'];\n    if (isKT(html)) {\n      element.innerHTML = html.value;\n      html.addOnChange((v) => (element.innerHTML = v));\n    } else {\n      element.innerHTML = html;\n    }\n  }\n\n  for (const key in attr) {\n    // & Arranged in order of usage frequency\n    if (\n      // key === 'k-if' ||\n      // key === 'k-else' ||\n      key === 'k-model' ||\n      key === 'k-for' ||\n      key === 'k-key' ||\n      key === 'ref' ||\n      key === 'class' ||\n      key === 'className' ||\n      key === 'style' ||\n      key === 'children' ||\n      key === 'k-html'\n    ) {\n      continue;\n    }\n\n    const o = attr[key];\n\n    // normal event handler\n    if (key.startsWith('on:')) {\n      if (o) {\n        element.addEventListener(key.slice(3), o); // chop off the `on:`\n      }\n      continue;\n    }\n\n    // normal attributes\n    // Security: all non-`on:` attributes are forwarded as-is.\n    // Dangerous values such as raw `on*`, `href`, `src`, `srcdoc`, SVG href, etc.\n    // remain the caller's responsibility.\n    const handler = handlers[key] || defaultHandler;\n    if (isKT(o)) {\n      handler(element, key, o.value);\n      o.addOnChange((v) => handler(element, key, v));\n    } else {\n      handler(element, key, o);\n    }\n  }\n}\n\nexport function applyAttr(element: HTMLElement | SVGElement | MathMLElement, attr: KTRawAttr) {\n  if (!attr) {\n    return;\n  }\n  if (typeof attr === 'object' && attr !== null) {\n    attrIsObject(element, attr as KTAttribute);\n  } else {\n    $throw('attr must be an object.');\n  }\n}\n","import { $isArray, $isNode, $isThenable } from '@ktjs/shared';\nimport type { KTAvailableContent, KTRawContent } from '../types/h.js';\nimport { isKT } from '../reactable/common.js';\n\nconst assureNode = (o: any) => ($isNode(o) ? o : document.createTextNode(o));\n\nfunction apdSingle(element: HTMLElement | DocumentFragment | SVGElement | MathMLElement, c: KTAvailableContent) {\n  // & Ignores falsy values, consistent with React's behavior\n  if (c === undefined || c === null || c === false) {\n    return;\n  }\n\n  if (isKT(c)) {\n    let node = assureNode(c.value);\n    element.appendChild(node);\n    c.addOnChange((newValue, _oldValue) => {\n      const oldNode = node;\n      node = assureNode(newValue);\n      oldNode.replaceWith(node);\n    });\n  } else {\n    const node = assureNode(c);\n    element.appendChild(node);\n    // Handle KTFor anchor\n    const list = (node as any).__kt_for_list__ as any[];\n    if ($isArray(list)) {\n      apd(element, list);\n    }\n  }\n}\n\nfunction apd(element: HTMLElement | DocumentFragment | SVGElement | MathMLElement, c: KTAvailableContent) {\n  if ($isThenable(c)) {\n    c.then((r) => apd(element, r));\n  } else if ($isArray(c)) {\n    for (let i = 0; i < c.length; i++) {\n      // & might be thenable here too\n      const ci = c[i];\n      if ($isThenable(ci)) {\n        const comment = document.createComment('ktjs-promise-placeholder');\n        element.appendChild(comment);\n        ci.then((awaited) => comment.replaceWith(awaited));\n      } else {\n        apdSingle(element, ci);\n      }\n    }\n  } else {\n    // & here is thened, so must be a simple elementj\n    apdSingle(element, c);\n  }\n}\n\nexport function applyContent(element: HTMLElement | SVGElement | MathMLElement, content: KTRawContent): void {\n  if ($isArray(content)) {\n    for (let i = 0; i < content.length; i++) {\n      apd(element, content[i]);\n    }\n  } else {\n    apd(element, content as KTAvailableContent);\n  }\n}\n","import type { InputElementTag } from '@ktjs/shared';\nimport type { KTRefLike } from '../reactable/ref.js';\n\nimport { static_cast } from 'type-narrow';\nimport { isRefLike } from '../reactable/common.js';\n\nexport function applyKModel(element: HTMLElementTagNameMap[InputElementTag], valueRef: KTRefLike<any>) {\n  if (!isRefLike(valueRef)) {\n    $throw('k-model value must be a KTRefLike.');\n  }\n\n  if (element.tagName === 'INPUT') {\n    static_cast<HTMLInputElement>(element);\n    if (element.type === 'radio' || element.type === 'checkbox') {\n      element.checked = Boolean(valueRef.value);\n      element.addEventListener('change', () => (valueRef.value = element.checked));\n      valueRef.addOnChange((newValue) => (element.checked = newValue));\n    } else {\n      element.value = valueRef.value ?? '';\n      element.addEventListener('input', () => (valueRef.value = element.value));\n      valueRef.addOnChange((newValue) => (element.value = newValue));\n    }\n    return;\n  }\n\n  if (element.tagName === 'SELECT' || element.tagName === 'TEXTAREA') {\n    element.value = valueRef.value ?? '';\n    element.addEventListener('change', () => (valueRef.value = element.value));\n    valueRef.addOnChange((newValue) => (element.value = newValue));\n    return;\n  }\n\n  $warn('not supported element for k-model:');\n}\n","import type { HTMLTag, MathMLTag, SVGTag } from '@ktjs/shared';\nimport type { KTRawAttr, KTRawContent, HTML } from '../types/h.js';\n\nimport { applyAttr } from './attr.js';\nimport { applyContent } from './content.js';\nimport { applyKModel } from './model.js';\n\n/**\n * Create an enhanced HTMLElement.\n * - Only supports HTMLElements, **NOT** SVGElements or other Elements.\n * @param tag tag of an `HTMLElement`\n * @param attr attribute object or className\n * @param content a string or an array of HTMLEnhancedElement as child nodes\n *\n * __PKG_INFO__\n */\nexport const h = <T extends HTMLTag | SVGTag | MathMLTag>(\n  tag: T,\n  attr?: KTRawAttr,\n  content?: KTRawContent,\n): HTML<T> => {\n  if (typeof tag !== 'string') {\n    $throw('tagName must be a string.');\n  }\n\n  // * start creating the element\n  const element = document.createElement(tag) as HTML<T>;\n  if (typeof attr === 'object' && attr !== null && 'k-model' in attr) {\n    applyKModel(element as any, attr['k-model'] as any);\n  }\n\n  // * Handle content\n  applyAttr(element, attr);\n  applyContent(element, content);\n\n  return element;\n};\n\nexport const svg = <T extends SVGTag>(tag: T, attr?: KTRawAttr, content?: KTRawContent): HTML<T> => {\n  if (typeof tag !== 'string') {\n    $throw('tagName must be a string.');\n  }\n\n  // * start creating the element\n  const element = document.createElementNS('http://www.w3.org/2000/svg', tag) as HTML<T>;\n\n  // * Handle content\n  applyAttr(element, attr);\n  applyContent(element, content);\n\n  if (typeof attr === 'object' && attr !== null && 'k-model' in attr) {\n    applyKModel(element as any, attr['k-model'] as any);\n  }\n\n  return element;\n};\n\nexport const mathml = <T extends MathMLTag>(tag: T, attr?: KTRawAttr, content?: KTRawContent): HTML<T> => {\n  if (typeof tag !== 'string') {\n    $throw('tagName must be a string.');\n  }\n\n  // * start creating the element\n  const element = document.createElementNS('http://www.w3.org/1998/Math/MathML', tag) as HTML<T>;\n\n  // * Handle content\n  applyAttr(element, attr);\n  applyContent(element, content);\n\n  if (typeof attr === 'object' && attr !== null && 'k-model' in attr) {\n    applyKModel(element as any, attr['k-model'] as any);\n  }\n\n  return element;\n};\n","import type { KTComputed, KTSubComputed } from './computed.js';\n\nimport { $stringify } from '@ktjs/shared';\nimport { $createSubGetter } from './common.js';\n\nexport type ChangeHandler<T> = (newValue: T, oldValue: T) => void;\n\nexport const enum KTReactiveType {\n  ReactiveLike = 0b00001,\n  Ref = 0b00010,\n  SubRef = 0b00100,\n  RefLike = Ref | SubRef,\n  Computed = 0b01000,\n  SubComputed = 0b10000,\n  ComputedLike = Computed | SubComputed,\n  Reactive = Ref | Computed,\n}\n\nlet kid = 1;\nlet handlerId = 1;\n\nexport abstract class KTReactiveLike<T> {\n  readonly kid = kid++;\n\n  abstract readonly ktype: KTReactiveType;\n\n  abstract get value(): T;\n\n  abstract addOnChange(handler: ChangeHandler<T>, key?: any): this;\n\n  abstract removeOnChange(key: any): this;\n\n  /**\n   * Create a computed value via current reactive value.\n   * - No matter `this` is added to `dependencies` or not, it is always listened.\n   * @param calculator A function that generates a new value based on current value.\n   * @param dependencies optional other dependencies that the computed value depends on.\n   */\n  map<U>(calculator: (value: T) => U, dependencies?: Array<KTReactiveLike<any>>): KTComputed<U> {\n    return null as any;\n  }\n}\n\nexport abstract class KTReactive<T> extends KTReactiveLike<T> {\n  /**\n   * @internal\n   */\n  protected _value: T;\n\n  /**\n   * @internal\n   */\n  protected readonly _changeHandlers = new Map<any, ChangeHandler<any>>();\n\n  constructor(value: T) {\n    super();\n    this._value = value;\n  }\n\n  get value() {\n    return this._value;\n  }\n\n  set value(_newValue: T) {\n    $warn('Setting value to a non-ref instance takes no effect.');\n  }\n\n  /**\n   * @internal\n   */\n  protected _emit(newValue: T, oldValue: T): this {\n    this._changeHandlers.forEach((handler) => handler(newValue, oldValue));\n    return this;\n  }\n\n  addOnChange(handler: ChangeHandler<T>, key?: any): this {\n    key ??= handlerId++;\n    if (this._changeHandlers.has(key)) {\n      $throw(`Overriding existing change handler with key ${$stringify(key)}.`);\n    }\n    this._changeHandlers.set(key, handler);\n    return this;\n  }\n\n  removeOnChange(key: any): this {\n    this._changeHandlers.delete(key);\n    return this;\n  }\n\n  clearOnChange(): this {\n    this._changeHandlers.clear();\n    return this;\n  }\n\n  notify(): this {\n    return this._emit(this._value, this._value);\n  }\n\n  /**\n   * Generate a sub-computed value based on this reactive, using keys to access nested properties.\n   * - `reactive.get('a', 'b')` means a sub-computed value to `this.value.a.b`.\n   * - `KTSubComputed` is lighter than `KTComputed` because it only listens to changes on the source reactive, while `KTComputed` listens to all its dependencies. So it's better to use `get` when you only need to access nested properties without doing any calculation.\n   */\n  get<\n    K0 extends keyof T,\n    K1 extends keyof T[K0],\n    K2 extends keyof T[K0][K1],\n    K3 extends keyof T[K0][K1][K2],\n    K4 extends keyof T[K0][K1][K2][K3],\n  >(key0: K0, key1: K1, key2: K2, key3: K3, key4: K4): KTSubComputed<T[K0][K1][K2][K3][K4]>;\n  /**\n   * Generate a sub-computed value based on this reactive, using keys to access nested properties.\n   * - `reactive.get('a', 'b')` means a sub-computed value to `this.value.a.b`.\n   * - `KTSubComputed` is lighter than `KTComputed` because it only listens to changes on the source reactive, while `KTComputed` listens to all its dependencies. So it's better to use `get` when you only need to access nested properties without doing any calculation.\n   */\n  get<K0 extends keyof T, K1 extends keyof T[K0], K2 extends keyof T[K0][K1], K3 extends keyof T[K0][K1][K2]>(\n    key0: K0,\n    key1: K1,\n    key2: K2,\n    key3: K3,\n  ): KTSubComputed<T[K0][K1][K2][K3]>;\n  /**\n   * Generate a sub-computed value based on this reactive, using keys to access nested properties.\n   * - `reactive.get('a', 'b')` means a sub-computed value to `this.value.a.b`.\n   * - `KTSubComputed` is lighter than `KTComputed` because it only listens to changes on the source reactive, while `KTComputed` listens to all its dependencies. So it's better to use `get` when you only need to access nested properties without doing any calculation.\n   */\n  get<K0 extends keyof T, K1 extends keyof T[K0], K2 extends keyof T[K0][K1]>(\n    key0: K0,\n    key1: K1,\n    key2: K2,\n  ): KTSubComputed<T[K0][K1][K2]>;\n  /**\n   * Generate a sub-computed value based on this reactive, using keys to access nested properties.\n   * - `reactive.get('a', 'b')` means a sub-computed value to `this.value.a.b`.\n   * - `KTSubComputed` is lighter than `KTComputed` because it only listens to changes on the source reactive, while `KTComputed` listens to all its dependencies. So it's better to use `get` when you only need to access nested properties without doing any calculation.\n   */\n  get<K0 extends keyof T, K1 extends keyof T[K0]>(key0: K0, key1: K1): KTSubComputed<T[K0][K1]>;\n  /**\n   * Generate a sub-computed value based on this reactive, using keys to access nested properties.\n   * - `reactive.get('a', 'b')` means a sub-computed value to `this.value.a.b`.\n   * - `KTSubComputed` is lighter than `KTComputed` because it only listens to changes on the source reactive, while `KTComputed` listens to all its dependencies. So it's better to use `get` when you only need to access nested properties without doing any calculation.\n   */\n  get<K0 extends keyof T>(key0: K0): KTSubComputed<T[K0]>;\n  /**\n   * Generate a sub-computed value based on this reactive, using keys to access nested properties.\n   * - `reactive.get('a', 'b')` means a sub-computed value to `this.value.a.b`.\n   * - `KTSubComputed` is lighter than `KTComputed` because it only listens to changes on the source reactive, while `KTComputed` listens to all its dependencies. So it's better to use `get` when you only need to access nested properties without doing any calculation.\n   */\n  get(..._keys: Array<string | number>): KTSubComputed<any> {\n    // & Will be implemented in computed.ts to avoid circular dependency\n    return null as any;\n  }\n}\n\nexport abstract class KTSubReactive<T> extends KTReactiveLike<T> {\n  readonly source: KTReactive<any>;\n\n  /**\n   * @internal\n   */\n  protected readonly _getter: (sv: KTReactive<any>['value']) => T;\n\n  constructor(source: KTReactive<any>, paths: string) {\n    super();\n    this.source = source;\n    this._getter = $createSubGetter(paths);\n  }\n\n  get value() {\n    // @ts-expect-error _value is private\n    return this._getter(this.source._value);\n  }\n\n  addOnChange(handler: ChangeHandler<T>, key?: any): this {\n    this.source.addOnChange((newSourceValue, oldSourceValue) => {\n      const oldValue = this._getter(oldSourceValue);\n      const newValue = this._getter(newSourceValue);\n      handler(newValue, oldValue);\n    }, key);\n    return this;\n  }\n\n  removeOnChange(key: any): this {\n    this.source.removeOnChange(key);\n    return this;\n  }\n}\n","// Use microqueue to schedule the flush of pending reactions\n\nimport type { KTRef } from './ref.js';\n\nconst reactiveToOldValue = new Map<KTRef<any>, any>();\n\nlet scheduled = false;\n\nexport const markMutation = (reactive: KTRef<any>) => {\n  if (!reactiveToOldValue.has(reactive)) {\n    // @ts-expect-error accessing protected property\n    reactiveToOldValue.set(reactive, reactive._value);\n\n    // # schedule by microqueue\n    if (scheduled) {\n      return;\n    }\n\n    scheduled = true;\n    Promise.resolve().then(() => {\n      scheduled = false;\n      reactiveToOldValue.forEach((oldValue, reactive) => {\n        // @ts-expect-error accessing protected property\n        reactive._changeHandlers.forEach((handler) => handler(reactive.value, oldValue));\n      });\n      reactiveToOldValue.clear();\n    });\n  }\n};\n","import { $emptyFn, $is, $stringify } from '@ktjs/shared';\nimport { KTReactive, KTReactiveType, KTSubReactive } from './reactive.js';\nimport { KTComputed } from './computed.js';\nimport { markMutation } from './scheduler.js';\nimport { $createSubSetter, isRefLike } from './common.js';\n\nexport class KTRef<T> extends KTReactive<T> {\n  readonly ktype = KTReactiveType.Ref;\n\n  constructor(_value: T) {\n    super(_value);\n  }\n\n  // ! Cannot be omitted, otherwise this will override `KTReactive` with only setter. And getter will return undefined.\n  get value() {\n    return this._value;\n  }\n\n  set value(newValue: T) {\n    if ($is(newValue, this._value)) {\n      return;\n    }\n    const oldValue = this._value;\n    this._value = newValue;\n    this._emit(newValue, oldValue);\n  }\n\n  /**\n   * Used to mutate the value in-place.\n   * - internal value is changed instantly, but the change handlers will be called in the next microtask.\n   */\n  get draft() {\n    markMutation(this);\n    return this._value;\n  }\n\n  notify(): this {\n    return this._emit(this._value, this._value);\n  }\n\n  /**\n   * Derive a lighter sub-ref from this ref, using keys to access nested properties.\n   * - `ref.subref('a', 'b')` means a sub-ref to `this.value.a.b`. Change it will also change `this.value` and trigger the handlers.\n   * - `KTSubRef` is lighter than `KTRef`.\n   */\n  subref<\n    K0 extends keyof T,\n    K1 extends keyof T[K0],\n    K2 extends keyof T[K0][K1],\n    K3 extends keyof T[K0][K1][K2],\n    K4 extends keyof T[K0][K1][K2][K3],\n  >(key0: K0, key1: K1, key2: K2, key3: K3, key4: K4): KTSubRef<T[K0][K1][K2][K3][K4]>;\n  /**\n   * Derive a lighter sub-ref from this ref, using keys to access nested properties.\n   * - `ref.subref('a', 'b')` means a sub-ref to `this.value.a.b`. Change it will also change `this.value` and trigger the handlers.\n   * - `KTSubRef` is lighter than `KTRef`.\n   */\n  subref<K0 extends keyof T, K1 extends keyof T[K0], K2 extends keyof T[K0][K1], K3 extends keyof T[K0][K1][K2]>(\n    key0: K0,\n    key1: K1,\n    key2: K2,\n    key3: K3,\n  ): KTSubRef<T[K0][K1][K2][K3]>;\n  /**\n   * Derive a lighter sub-ref from this ref, using keys to access nested properties.\n   * - `ref.subref('a', 'b')` means a sub-ref to `this.value.a.b`. Change it will also change `this.value` and trigger the handlers.\n   * - `KTSubRef` is lighter than `KTRef`.\n   */\n  subref<K0 extends keyof T, K1 extends keyof T[K0], K2 extends keyof T[K0][K1]>(\n    key0: K0,\n    key1: K1,\n    key2: K2,\n  ): KTSubRef<T[K0][K1][K2]>;\n  /**\n   * Derive a lighter sub-ref from this ref, using keys to access nested properties.\n   * - `ref.subref('a', 'b')` means a sub-ref to `this.value.a.b`. Change it will also change `this.value` and trigger the handlers.\n   * - `KTSubRef` is lighter than `KTRef`.\n   */\n  subref<K0 extends keyof T, K1 extends keyof T[K0]>(key0: K0, key1: K1): KTSubRef<T[K0][K1]>;\n  /**\n   * Derive a lighter sub-ref from this ref, using keys to access nested properties.\n   * - `ref.subref('a', 'b')` means a sub-ref to `this.value.a.b`. Change it will also change `this.value` and trigger the handlers.\n   * - `KTSubRef` is lighter than `KTRef`.\n   */\n  subref<K0 extends keyof T>(key0: K0): KTSubRef<T[K0]>;\n  /**\n   * Derive a lighter sub-ref from this ref, using keys to access nested properties.\n   * - `ref.subref('a', 'b')` means a sub-ref to `this.value.a.b`. Change it will also change `this.value` and trigger the handlers.\n   * - `KTSubRef` is lighter than `KTRef`.\n   */\n  subref(...keys: Array<string | number>): KTSubRef<any> {\n    if (keys.length === 0) {\n      $throw('At least one key is required to get a sub-ref.');\n    }\n    return new KTSubRef(this, keys.map((key) => `[${$stringify(key)}]`).join(''));\n  }\n}\n\nexport class KTSubRef<T> extends KTSubReactive<T> {\n  readonly ktype = KTReactiveType.SubRef;\n  declare readonly source: KTRef<any>;\n\n  /**\n   * @internal\n   */\n  protected readonly _setter: (s: object, newValue: T) => void;\n\n  constructor(source: KTRef<any>, paths: string) {\n    super(source, paths);\n    this._setter = $createSubSetter(paths);\n  }\n\n  get value() {\n    // @ts-expect-error _value is private\n    return this._getter(this.source._value);\n  }\n\n  set value(newValue: T) {\n    // @ts-expect-error _value is private\n    this._setter(this.source._value, newValue);\n    this.source.notify();\n  }\n\n  get draft() {\n    // Same implementation as `draft` in `KTRef`\n    markMutation(this.source);\n    // @ts-expect-error _value is private\n    return this._getter(this.source._value);\n  }\n}\n\n/**\n * Create a reactive reference to a value. The returned object has a single property `value` that holds the internal value.\n * @param value listened value\n */\nexport const ref = <T>(value?: T): KTRef<T> => new KTRef(value as any);\n\n/**\n * Assert `k-model` to be a ref-like object\n */\nexport const assertModel = <T = any>(props: any, defaultValue?: T): KTRefLike<T> => {\n  // & props is an object. Won't use it in any other place\n  if ('k-model' in props) {\n    const kmodel = props['k-model'];\n    if (isRefLike(kmodel)) {\n      return kmodel;\n    } else {\n      $throw(`k-model data must be a KTRef object, please use 'ref(...)' to wrap it.`);\n    }\n  }\n  return ref(defaultValue) as KTRef<T>;\n};\n\nconst $refSetter = <T>(props: { ref?: KTRef<T> }, node: T) => (props.ref!.value = node);\ntype RefSetter<T> = (props: { ref?: KTRef<T> }, node: T) => void;\n\nexport type KTRefLike<T> = KTRef<T> | KTSubRef<T>;\n\n/**\n * Whether `props.ref` is a `KTRef` only needs to be checked in the initial render\n */\nexport const $initRef = <T extends Node>(props: { ref?: KTRefLike<T> }, node: T): RefSetter<T> => {\n  if (!('ref' in props)) {\n    return $emptyFn;\n  }\n\n  const r = props.ref;\n  if (isRefLike(r)) {\n    r.value = node;\n    return $refSetter;\n  } else {\n    $throw('Fragment: ref must be a KTRef');\n  }\n};\n","import { $is, $stringify } from '@ktjs/shared';\nimport { KTReactive, KTReactiveLike, KTReactiveType, KTSubReactive } from './reactive.js';\n\nexport class KTComputed<T> extends KTReactive<T> {\n  readonly ktype = KTReactiveType.Computed;\n\n  private readonly _calculator: () => T;\n\n  private _recalculate(forced: boolean = false): this {\n    const newValue = this._calculator();\n    const oldValue = this._value;\n    if (!$is(oldValue, newValue) || forced) {\n      this._value = newValue;\n      this._emit(newValue, oldValue);\n    }\n    return this;\n  }\n\n  constructor(calculator: () => T, dependencies: Array<KTReactiveLike<any>>) {\n    super(calculator());\n    this._calculator = calculator;\n    const recalculate = () => this._recalculate();\n    for (let i = 0; i < dependencies.length; i++) {\n      dependencies[i].addOnChange(recalculate);\n    }\n  }\n\n  notify(): this {\n    return this._recalculate(true);\n  }\n}\n\nKTReactiveLike.prototype.map = function <U>(\n  this: KTReactive<unknown>,\n  c: (value: unknown) => U,\n  dep?: Array<KTReactiveLike<any>>,\n) {\n  return new KTComputed(() => c(this.value), dep ? [this, ...dep] : [this]);\n};\n\nKTReactive.prototype.get = function <T>(this: KTReactive<T>, ...keys: Array<string | number>) {\n  if (keys.length === 0) {\n    $throw('At least one key is required to get a sub-computed.');\n  }\n  return new KTSubComputed(this, keys.map((key) => `[${$stringify(key)}]`).join(''));\n};\n\nexport class KTSubComputed<T> extends KTSubReactive<T> {\n  readonly ktype = KTReactiveType.SubComputed;\n}\n\nexport type KTComputedLike<T> = KTComputed<T> | KTSubComputed<T>;\n\n/**\n * Create a computed value that automatically updates when its dependencies change.\n * @param calculator synchronous function that calculates the value of the computed. It should not have side effects.\n * @param dependencies an array of reactive dependencies that the computed value depends on. The computed value will automatically update when any of these dependencies change.\n */\nexport const computed = <T>(calculator: () => T, dependencies: Array<KTReactiveLike<any>>): KTComputed<T> =>\n  new KTComputed(calculator, dependencies);\n","import { $emptyFn } from '@ktjs/shared';\nimport type { KTReactiveLike } from './reactive.js';\n\ninterface KTEffectOptions {\n  lazy: boolean;\n  onCleanup: () => void;\n  debugName: string;\n}\n\n/**\n * Register a reactive effect with options.\n * @param effectFn The effect function to run when dependencies change\n * @param reactives The reactive dependencies\n * @param options Effect options: lazy, onCleanup, debugName\n * @returns stop function to remove all listeners\n */\nexport function effect(\n  effectFn: () => void,\n  reactives: Array<KTReactiveLike<any>>,\n  options?: Partial<KTEffectOptions>,\n) {\n  const { lazy = false, onCleanup = $emptyFn, debugName = '' } = Object(options);\n  const listenerKeys: Array<string | number> = [];\n\n  let active = true;\n\n  const run = () => {\n    if (!active) {\n      return;\n    }\n\n    // cleanup before rerun\n    onCleanup();\n\n    try {\n      effectFn();\n    } catch (err) {\n      $debug('effect error:', debugName, err);\n    }\n  };\n\n  // subscribe to dependencies\n  for (let i = 0; i < reactives.length; i++) {\n    listenerKeys[i] = i;\n    reactives[i].addOnChange(run, effectFn);\n  }\n\n  // auto run unless lazy\n  if (!lazy) {\n    run();\n  }\n\n  // stop function\n  return () => {\n    if (!active) {\n      return;\n    }\n    active = false;\n\n    for (let i = 0; i < reactives.length; i++) {\n      reactives[i].removeOnChange(effectFn);\n    }\n\n    // final cleanup\n    onCleanup();\n  };\n}\n","import type { KTReactive, KTReactiveLike } from './reactive.js';\nimport { isKT } from './common.js';\nimport { ref } from './ref.js';\n\n/**\n * Ensure a value is reactive. If it's already `KTReactiveLike`, return it as is; otherwise, wrap it in a `ref`.\n */\nexport const toReactive = <T>(o: T | KTReactiveLike<T>): KTReactiveLike<T> =>\n  isKT(o) ? o : (ref(o as T) as KTReactive<T>);\n\n/**\n * Extracts the value from a KTReactive, or returns the value directly if it's not reactive.\n */\nexport const dereactive = <T>(value: T | KTReactiveLike<T>): T => (isKT<T>(value) ? value.value : value);\n\nexport type { KTRef, KTSubRef, KTRefLike } from './ref.js';\nexport { ref, assertModel } from './ref.js';\nexport type { KTComputed, KTSubComputed, KTComputedLike } from './computed.js';\nexport { computed } from './computed.js';\nexport { KTReactiveType } from './reactive.js';\nexport type * from './reactive.js';\n\nexport {\n  isKT,\n  isReactiveLike,\n  isRef,\n  isSubRef,\n  isRefLike,\n  isComputed,\n  isSubComputed,\n  isComputedLike,\n  isReactive,\n} from './common.js';\nexport { effect } from './effect.js';\nexport type * from './types.js';\n","import type { KTReactiveLike } from '../reactable/reactive.js';\nimport type { KTRawContent } from '../types/h.js';\nimport type { JSX } from '../types/jsx.js';\nimport { $initRef, type KTRefLike } from '../reactable/ref.js';\n\nimport { $forEach, $isArray } from '@ktjs/shared';\nimport { isKT, toReactive } from '../reactable/index.js';\n\nconst FRAGMENT_MOUNT_PATCHED = '__kt_fragment_mount_patched__';\nconst FRAGMENT_MOUNT = '__kt_fragment_mount__';\n\nif (typeof Node !== 'undefined' && !(globalThis as any)[FRAGMENT_MOUNT_PATCHED]) {\n  (globalThis as any)[FRAGMENT_MOUNT_PATCHED] = true;\n\n  const originAppendChild = Node.prototype.appendChild;\n  Node.prototype.appendChild = function (node) {\n    const result = originAppendChild.call(this, node);\n    const mount = (node as any)[FRAGMENT_MOUNT];\n    if (typeof mount === 'function') {\n      mount();\n    }\n    return result as any;\n  };\n\n  const originInsertBefore = Node.prototype.insertBefore;\n  Node.prototype.insertBefore = function (node: Node, child: Node | null) {\n    const result = originInsertBefore.call(this, node, child);\n    const mount = (node as any)[FRAGMENT_MOUNT];\n    if (typeof mount === 'function') {\n      mount();\n    }\n    return result as any;\n  };\n}\n\nexport interface FragmentProps<T extends JSX.Element = JSX.Element> {\n  /** Array of child elements, supports reactive arrays */\n  children: T[] | KTReactiveLike<T[]>;\n\n  /** element key function for optimization (future enhancement) */\n  key?: (element: T, index: number, array: T[]) => any;\n\n  /** ref to get the anchor node */\n  ref?: KTRefLike<JSX.Element>;\n}\n\n/**\n * Fragment - Container component for managing arrays of child elements\n *\n * Features:\n * 1. Returns a comment anchor node, child elements are inserted after the anchor\n * 2. Supports reactive arrays, automatically updates DOM when array changes\n * 3. Basic version uses simple replacement algorithm (remove all old elements, insert all new elements)\n * 4. Future enhancement: key-based optimization\n *\n * Usage example:\n * ```tsx\n * const children = ref([<div>A</div>, <div>B</div>]);\n * const fragment = <Fragment children={children} />;\n * document.body.appendChild(fragment);\n *\n * // Automatic update\n * children.value = [<div>C</div>, <div>D</div>];\n * ```\n */\nexport function Fragment<T extends JSX.Element = JSX.Element>(props: FragmentProps<T>): JSX.Element {\n  const elements: T[] = [];\n  const anchor = document.createComment('kt-fragment') as unknown as JSX.Element;\n  let inserted = false;\n  let observer: MutationObserver | undefined;\n\n  const redraw = () => {\n    const newElements = childrenRef.value;\n    const parent = anchor.parentNode;\n\n    if (!parent) {\n      elements.length = 0;\n      for (let i = 0; i < newElements.length; i++) {\n        elements.push(newElements[i]);\n      }\n      (anchor as any).__kt_fragment_list__ = elements;\n      return;\n    }\n\n    for (let i = 0; i < elements.length; i++) {\n      elements[i].remove();\n    }\n\n    const fragment = document.createDocumentFragment();\n    elements.length = 0;\n\n    for (let i = 0; i < newElements.length; i++) {\n      const element = newElements[i];\n      elements.push(element);\n      fragment.appendChild(element);\n    }\n\n    parent.insertBefore(fragment, anchor.nextSibling);\n    inserted = true;\n    delete (anchor as any)[FRAGMENT_MOUNT];\n    observer?.disconnect();\n    observer = undefined;\n    (anchor as any).__kt_fragment_list__ = elements;\n  };\n\n  const childrenRef = toReactive(props.children).addOnChange(redraw);\n\n  const renderInitial = () => {\n    const current = childrenRef.value;\n    elements.length = 0;\n\n    const fragment = document.createDocumentFragment();\n    for (let i = 0; i < current.length; i++) {\n      const element = current[i];\n      elements.push(element);\n      fragment.appendChild(element);\n    }\n\n    (anchor as any).__kt_fragment_list__ = elements;\n\n    const parent = anchor.parentNode;\n    if (parent && !inserted) {\n      parent.insertBefore(fragment, anchor.nextSibling);\n      inserted = true;\n    }\n  };\n\n  renderInitial();\n\n  (anchor as any)[FRAGMENT_MOUNT] = () => {\n    if (!inserted && anchor.parentNode) {\n      redraw();\n    }\n  };\n\n  observer = new MutationObserver(() => {\n    if (anchor.parentNode && !inserted) {\n      redraw();\n      observer?.disconnect();\n      observer = undefined;\n    }\n  });\n\n  observer.observe(document.body, { childList: true, subtree: true });\n\n  $initRef(props, anchor);\n\n  return anchor;\n}\n\n/**\n * Convert KTRawContent to HTMLElement array\n */\nexport function convertChildrenToElements(children: KTRawContent): Element[] {\n  const elements: Element[] = [];\n\n  const processChild = (child: any): void => {\n    if (child === undefined || child === null || child === false || child === true) {\n      // Ignore null, undefined, false, true\n      return;\n    }\n\n    if ($isArray(child)) {\n      // Recursively process array\n      $forEach(child, processChild);\n      return;\n    }\n\n    if (typeof child === 'string' || typeof child === 'number') {\n      const span = document.createElement('span');\n      span.textContent = String(child);\n      elements.push(span);\n      return;\n    }\n\n    if (child instanceof Element) {\n      elements.push(child);\n      return;\n    }\n\n    if (isKT(child)) {\n      processChild(child.value);\n      return;\n    }\n\n    $warn('Fragment: unsupported child type', child);\n    if (process.env.IS_DEV) {\n      throw new Error(`Fragment: unsupported child type`);\n    }\n  };\n\n  processChild(children);\n  return elements;\n}\n","import type { JSXTag } from '@ktjs/shared';\nimport type { KTAttribute } from '../types/h.js';\nimport type { JSX } from '../types/jsx.js';\nimport { h } from '../h/index';\n\nexport const jsxh = (tag: JSXTag, props: KTAttribute): JSX.Element =>\n  (typeof tag === 'function' ? tag(props) : h(tag, props, props.children)) as JSX.Element;\n\nexport const placeholder = (data: string): JSX.Element => document.createComment(data) as unknown as JSX.Element;\n","import type { JSXTag, MathMLTag, SVGTag } from '@ktjs/shared';\nimport type { KTAttribute, KTRawContent } from '../types/h.js';\nimport type { JSX } from '../types/jsx.js';\n\nimport { h, mathml as _mathml, svg as _svg } from '../h/index.js';\nimport { $initRef } from '../reactable/ref.js';\nimport { isComputedLike } from '../reactable/common.js';\n\nimport { convertChildrenToElements, Fragment as FragmentArray } from './fragment.js';\nimport { jsxh, placeholder } from './common.js';\n\nfunction create(\n  creator: (tag: any, props: KTAttribute, content?: KTRawContent) => JSX.Element,\n  tag: any,\n  props: KTAttribute,\n) {\n  if (props.ref && isComputedLike(props.ref)) {\n    $throw('Cannot assign a computed value to an element.');\n  }\n  const el = creator(tag, props, props.children);\n  $initRef(props, el);\n  return el;\n}\n\nexport const jsx = (tag: JSXTag, props: KTAttribute): JSX.Element => create(jsxh, tag, props);\nexport const svg = (tag: SVGTag, props: KTAttribute): JSX.Element => create(_svg, tag, props);\nexport const mathml = (tag: MathMLTag, props: KTAttribute): JSX.Element => create(_mathml, tag, props);\nexport { svg as svgRuntime, mathml as mathmlRuntime };\n\n/**\n * Fragment support - returns an array of children\n * Enhanced Fragment component that manages arrays of elements\n */\nexport function Fragment(props: { children?: KTRawContent }): JSX.Element {\n  const { children } = props ?? {};\n\n  if (!children) {\n    return placeholder('kt-fragment-empty');\n  }\n\n  const elements = convertChildrenToElements(children);\n\n  return FragmentArray({ children: elements });\n}\n\n/**\n * JSX Development runtime - same as jsx but with additional dev checks\n */\nexport const jsxDEV: typeof jsx = (...args) => {\n  // console.log('JSX DEV called:', ...args);\n  // console.log('children', (args[1] as any)?.children);\n  return jsx(...args);\n};\n\n/**\n * JSX runtime for React 17+ automatic runtime\n * This is called when using jsx: \"react-jsx\" or \"react-jsxdev\"\n */\nexport const jsxs = jsx;\n\n// Export h as the classic JSX factory for backward compatibility\nexport { h, h as createElement };\n","import { $isThenable } from '@ktjs/shared';\nimport type { KTComponent, KTRawContent } from '../types/h.js';\nimport type { JSX } from '../types/jsx.js';\nimport type { KTRef } from '../reactable/ref.js';\n\n/**\n * Extract component props type (excluding ref and children)\n */\ntype ExtractComponentProps<T> = T extends (props: infer P) => any ? Omit<P, 'ref' | 'children'> : {};\n\nexport function KTAsync<T extends KTComponent>(\n  props: {\n    ref?: KTRef<JSX.Element>;\n    skeleton?: JSX.Element;\n    component: T;\n    children?: KTRawContent;\n  } & ExtractComponentProps<T>,\n): JSX.Element {\n  const raw = props.component(props);\n  let comp: JSX.Element =\n    props.skeleton ?? (document.createComment('ktjs-suspense-placeholder') as unknown as JSX.Element);\n\n  if ($isThenable(raw)) {\n    raw.then((resolved) => comp.replaceWith(resolved));\n  } else {\n    comp = raw as JSX.Element;\n  }\n\n  return comp;\n}\n","import type { JSX } from '../types/jsx.js';\nimport type { KTRefLike } from '../reactable/ref.js';\nimport type { KTReactiveLike } from '../reactable/reactive.js';\n\nimport { $identity } from '@ktjs/shared';\nimport { toReactive } from '../reactable/index.js';\nimport { $initRef } from '../reactable/ref.js';\n\nexport type KTForElement = JSX.Element;\n\nexport interface KTForProps<T> {\n  ref?: KTRefLike<KTForElement>;\n  list: T[] | KTReactiveLike<T[]>;\n  key?: (item: T, index: number, array: T[]) => any;\n  map?: (item: T, index: number, array: T[]) => JSX.Element;\n}\n\n// TASK 对于template标签的for和if，会编译为fragment，可特殊处理，让它们保持原样\n/**\n * KTFor - List rendering component with key-based optimization\n * Returns a Comment anchor node with rendered elements in __kt_for_list__\n */\nexport function KTFor<T>(props: KTForProps<T>): KTForElement {\n  const redraw = () => {\n    const newList = listRef.value;\n\n    const parent = anchor.parentNode;\n    if (!parent) {\n      // If not in DOM yet, just rebuild the list\n      const newElements: KTForElement[] = [];\n      nodeMap.clear();\n      for (let index = 0; index < newList.length; index++) {\n        const item = newList[index];\n        const itemKey = currentKey(item, index, newList);\n        const node = currentMap(item, index, newList);\n        nodeMap.set(itemKey, node);\n        newElements.push(node);\n      }\n      (anchor as any).__kt_for_list__ = newElements;\n      return anchor;\n    }\n\n    const oldLength = (anchor as any).__kt_for_list__.length;\n    const newLength = newList.length;\n\n    // Fast path: empty list\n    if (newLength === 0) {\n      nodeMap.forEach((node) => node.remove());\n      nodeMap.clear();\n      (anchor as any).__kt_for_list__ = [];\n      return anchor;\n    }\n\n    // Fast path: all new items\n    if (oldLength === 0) {\n      const newElements: KTForElement[] = [];\n      const fragment = document.createDocumentFragment();\n      for (let i = 0; i < newLength; i++) {\n        const item = newList[i];\n        const itemKey = currentKey(item, i, newList);\n        const node = currentMap(item, i, newList);\n        nodeMap.set(itemKey, node);\n        newElements.push(node);\n        fragment.appendChild(node);\n      }\n      parent.insertBefore(fragment, anchor.nextSibling);\n      (anchor as any).__kt_for_list__ = newElements;\n      return anchor;\n    }\n\n    // Build key index map and new elements array in one pass\n    const newKeyToNewIndex = new Map<any, number>();\n    const newElements: KTForElement[] = new Array(newLength);\n    for (let i = 0; i < newLength; i++) {\n      const item = newList[i];\n      const itemKey = currentKey(item, i, newList);\n      newKeyToNewIndex.set(itemKey, i);\n\n      if (nodeMap.has(itemKey)) {\n        // Reuse existing node\n        newElements[i] = nodeMap.get(itemKey)!;\n      } else {\n        // Create new node\n        newElements[i] = currentMap(item, i, newList);\n      }\n    }\n\n    // Remove nodes not in new list\n    const toRemove: KTForElement[] = [];\n    nodeMap.forEach((node, key) => {\n      if (!newKeyToNewIndex.has(key)) {\n        toRemove.push(node);\n      }\n    });\n    for (let i = 0; i < toRemove.length; i++) {\n      toRemove[i].remove();\n    }\n\n    // Reorder existing nodes and insert new nodes in a single pass.\n    let currentNode = anchor.nextSibling;\n    for (let i = 0; i < newLength; i++) {\n      const node = newElements[i];\n      if (currentNode !== node) {\n        parent.insertBefore(node, currentNode);\n      } else {\n        currentNode = currentNode.nextSibling;\n      }\n    }\n\n    // Update maps\n    nodeMap.clear();\n    for (let i = 0; i < newLength; i++) {\n      const itemKey = currentKey(newList[i], i, newList);\n      nodeMap.set(itemKey, newElements[i]);\n    }\n    (anchor as any).__kt_for_list__ = newElements;\n    return anchor;\n  };\n\n  const currentKey: NonNullable<KTForProps<T>['key']> = props.key ?? ((item: T) => item);\n  const currentMap: NonNullable<KTForProps<T>['map']> =\n    props.map ?? ((item: T) => $identity(item) as unknown as KTForElement);\n  const listRef = toReactive(props.list).addOnChange(redraw);\n  const anchor = document.createComment('kt-for') as unknown as KTForElement;\n\n  // Map to track rendered nodes by key\n  const nodeMap = new Map<any, KTForElement>();\n\n  // Render initial list\n  const elements: KTForElement[] = [];\n  for (let index = 0; index < listRef.value.length; index++) {\n    const item = listRef.value[index];\n    const itemKey = currentKey(item, index, listRef.value);\n    const node = currentMap(item, index, listRef.value);\n    nodeMap.set(itemKey, node);\n    elements.push(node);\n  }\n\n  (anchor as any).__kt_for_list__ = elements;\n\n  $initRef(props, anchor);\n\n  return anchor;\n}\n","import type { JSXTag } from '@ktjs/shared';\nimport type { KTAttribute } from '../types/h.js';\nimport type { KTReactiveLike } from '../reactable/reactive.js';\n\nimport { isKT } from '../reactable/index.js';\nimport { jsxh, placeholder } from './common.js';\n\nexport function KTConditional(\n  condition: any | KTReactiveLike<any>,\n  tagIf: JSXTag,\n  propsIf: KTAttribute,\n  tagElse?: JSXTag,\n  propsElse?: KTAttribute,\n) {\n  if (!isKT(condition)) {\n    return condition ? jsxh(tagIf, propsIf) : tagElse ? jsxh(tagElse, propsElse!) : placeholder('kt-conditional');\n  }\n\n  if (tagElse) {\n    let current = condition.value ? jsxh(tagIf, propsIf) : jsxh(tagElse!, propsElse!);\n    condition.addOnChange((newValue) => {\n      const old = current;\n      current = newValue ? jsxh(tagIf, propsIf) : jsxh(tagElse!, propsElse!);\n      old.replaceWith(current);\n    });\n    return current;\n  } else {\n    const dummy = placeholder('kt-conditional') as HTMLElement;\n    let current = condition.value ? jsxh(tagIf, propsIf) : dummy;\n    condition.addOnChange((newValue) => {\n      const old = current;\n      current = newValue ? jsxh(tagIf, propsIf) : dummy;\n      old.replaceWith(current);\n    });\n    return current;\n  }\n}\n"],"names":["isKT","obj","kid","isReactiveLike","ktype","isRef","isSubRef","isRefLike","isComputed","isSubComputed","isComputedLike","isReactive","_getters","Map","_setters","booleanHandler","element","key","value","setAttribute","valueHandler","handlers","checked","selected","valueAsDate","valueAsNumber","defaultValue","defaultChecked","defaultSelected","disabled","readOnly","multiple","required","autofocus","open","controls","autoplay","loop","muted","defer","async","hidden","_key","defaultHandler","setElementStyle","style","cssText","applyAttr","attr","Error","classValue","class","className","undefined","addOnChange","v","html","innerHTML","o","startsWith","addEventListener","slice","handler","attrIsObject","assureNode","$isNode","document","createTextNode","apdSingle","c","node","appendChild","newValue","_oldValue","oldNode","replaceWith","list","__kt_for_list__","$isArray","apd","$isThenable","then","r","i","length","ci","comment","createComment","awaited","applyContent","content","applyKModel","valueRef","tagName","console","type","Boolean","h","tag","createElement","svg","createElementNS","mathml","handlerId","KTReactiveLike","map","calculator","dependencies","KTReactive","_value","_changeHandlers","constructor","super","this","_newValue","warn","_emit","oldValue","forEach","has","$stringify","set","removeOnChange","delete","clearOnChange","clear","notify","get","_keys","KTSubReactive","source","_getter","paths","path","exist","cache","Function","$createSubGetter","newSourceValue","oldSourceValue","reactiveToOldValue","scheduled","markMutation","reactive","Promise","resolve","KTRef","$is","draft","subref","keys","KTSubRef","join","_setter","$createSubSetter","ref","assertModel","props","kmodel","$refSetter","$initRef","$emptyFn","KTComputed","_calculator","_recalculate","forced","recalculate","prototype","dep","KTSubComputed","computed","effect","effectFn","reactives","options","lazy","onCleanup","debugName","Object","active","run","err","debug","toReactive","dereactive","Node","globalThis","originAppendChild","result","call","mount","originInsertBefore","insertBefore","child","jsxh","children","placeholder","data","create","creator","el","jsx","_svg","_mathml","Fragment","elements","processChild","$forEach","span","textContent","String","push","Element","convertChildrenToElements","anchor","observer","inserted","redraw","newElements","childrenRef","parent","parentNode","__kt_fragment_list__","remove","fragment","createDocumentFragment","nextSibling","disconnect","current","renderInitial","MutationObserver","observe","body","childList","subtree","FragmentArray","jsxDEV","args","jsxs","KTAsync","raw","component","comp","skeleton","resolved","KTFor","currentKey","item","currentMap","$identity","listRef","newList","nodeMap","index","itemKey","oldLength","newLength","newKeyToNewIndex","Array","toRemove","currentNode","KTConditional","condition","tagIf","propsIf","tagElse","propsElse","old","dummy"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ktjs/core",
-  "version": "0.35.0",
+  "version": "0.36.1",
   "description": "Core functionality for kt.js - DOM manipulation utilities with JSX/TSX support",
   "description_zh": "kt.js 的核心功能，提供支持 JSX/TSX 的 DOM 操作工具。",
   "type": "module",
@@ -45,7 +45,8 @@
     "directory": "packages/core"
   },
   "dependencies": {
-    "@ktjs/shared": "^*"
+    "@ktjs/shared": "^*",
+    "composition-ts": "^0.1.2"
   },
   "scripts": {
     "build": "rollup -c rollup.config.mjs",