hyperscript-rxjs 1.3.14 → 1.3.16

package/dist/hyperscript-rxjs.d.ts

@@ -1,672 +1,731 @@
 import { BehaviorSubject } from 'rxjs';
+import { HyperscriptExtensions as HyperscriptExtensions_2 } from './HyperscriptExtensions.d.ts';
 import { Observable } from 'rxjs';
-import { Observer } from 'rxjs';
+import { Observer as Observer_2 } from 'rxjs';
 import { Subject } from 'rxjs';
 import { Subscription } from 'rxjs';
 
-export declare function a(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLAnchorElement>;
+export declare function a(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLAnchorElement>;
 
-export declare function a(...childNodes: any[]): HyperscriptExtensions<HTMLAnchorElement>;
+export declare function abbr(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
-export declare function abbr(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function abbr(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function address(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function address(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function address(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
 /**
- * Splits an array into two parts: the first `n` elements (in reverse order) and the remaining elements.
- * 
- * @param array - The input array to process.
- * @param n - The number of elements to take from the start of the array.
- * @returns A tuple where the first element is an array of the first `n` elements (in reverse order),
- *          and the second element is the remaining elements of the array.
+ * @template T
+ * @param {Array<T>} array - 要处理的原数组
+ * @param {number} n - 要取出的元素个数
+ * @returns {[Array<T>, Array<T>]} - [已取出的元素数组, 剩余元素数组]
  */
-export declare function advance<T>(array: T[], n: number): [T[], T[]];
-
-export declare function area(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLAreaElement>;
+export declare function advance<T>(array: Array<T>, n: number): [Array<T>, Array<T>];
 
-export declare function area(...childNodes: any[]): HyperscriptExtensions<HTMLAreaElement>;
+export declare function area(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLAreaElement>;
 
 /**
- * Inserts an element into an array at the specified position in place.
- * 
- * @param array - The array to modify.
- * @param item - The element to insert.
- * @param index - The position at which to insert the element (default is the end of the array).
+ * insert a element at position in place.
+ * @param {any} array
+ * @param {any} item
+ * @param {any} index
  */
-export declare function arrayInsert<T>(array: T[], item: T, index?: number): void;
+export declare function arrayInsert(array: any, item: any, index?: any): void;
 
 /**
- * Removes an element from an array at the specified position in place.
- * 
- * @param array - The array to modify.
- * @param index - The position of the element to remove (default is the last element).
+ * remove a element in place
+ *
+ * @template T
+ * @param {T[]} array
+ * @param {number} index
  */
 export declare function arrayRemove<T>(array: T[], index?: number): void;
 
-export declare function article(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function article(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function aside(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function aside(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-/**
- * 将 RxJS 订阅对象附加到 DOM 节点上，便于管理。
- * @private
- * @param elem - 要附加订阅的 DOM 节点。
- * @param subscription - 要附加的 RxJS Subscription 对象。
- * @throws 如果参数无效会抛出错误。
- */
-export declare function attachSubscriptionToNode(
-elem: Node & { subscription?: Subscription },
-subscription: Subscription
-): void;
-
-export declare function audio(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLAudioElement>;
+export declare function article(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
-export declare function audio(...childNodes: any[]): HyperscriptExtensions<HTMLAudioElement>;
+export declare function aside(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
-export declare function b(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function b(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function attachSubscriptionToNode(elem: Node & {
+    subscription?: Subscription;
+}, subscription: Subscription): void;
 
-export declare function bdi(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function audio(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLAudioElement>;
 
-export declare function bdi(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function b(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
-export declare function bdo(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function bdi(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
-export declare function bdo(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function bdo(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
 /**
- * 绑定选项卡的激活状态到 tabIndex，实现动态切换选项卡的功能。
- * 
- * @param tabRoot - 选项卡的根容器，包含导航栏和内容面板。
- * @param tabIndex$ - 表示当前激活选项卡索引的 BehaviorSubject。
+ * 绑定选项卡的激活状态到 `tabIndex`。
+ *
+ * `bindTabIndex` 函数将选项卡的导航按钮和内容面板与 `tabIndex` 绑定，
+ * 实现动态切换选项卡的功能。
+ *
+ * @param {HTMLElement} tabRoot - 选项卡的根容器，包含导航栏和内容面板。
+ * @param {BehaviorSubject<number>} tabIndex$ - 表示当前激活选项卡索引的 BehaviorSubject。
+ *
  */
-export declare function bindTabIndex(
-tabRoot: HTMLElement,
-tabIndex$: BehaviorSubject<number>
-): void;
+export declare function bindTabIndex(tabRoot: HTMLElement, tabIndex$: BehaviorSubject<number>): void;
 
 /**
- * 一个包含所有 HTML 块级元素标签名称（大写）的集合。
- * 用于判断某个标签是否为块级元素。
+ * 一个包含所有 HTML 块级元素标签名称的集合。
+ *
+ * 块级元素是 HTML 中的一类元素，它们通常会独占一行，并且可以包含内联元素或其他块级元素。
+ * 该集合中的标签名称均为大写，便于快速判断某个元素是否为块级元素。
+ *
+ * 常见的块级元素包括：
+ * - 文本结构元素：`P`、`H1`-`H6`、`ADDRESS` 等。
+ * - 列表元素：`UL`、`OL`、`LI`、`DL`、`DT`、`DD`。
+ * - 容器元素：`DIV`、`SECTION`、`ARTICLE`、`ASIDE`、`NAV` 等。
+ * - 表单元素：`FORM`、`FIELDSET`。
+ * - 表格元素：`TABLE`。
+ * - 其他：`BLOCKQUOTE`、`PRE`、`FIGURE` 等。
+ *
+ * @constant {Set<string>} blockLevelFamily
  */
 export declare const blockLevelFamily: Set<string>;
 
-export declare function blockquote(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLQuoteElement>;
+export declare function blockquote(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLQuoteElement>;
 
-export declare function blockquote(...childNodes: any[]): HyperscriptExtensions<HTMLQuoteElement>;
+export declare function br(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLBRElement>;
 
-export declare function br(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLBRElement>;
+export declare function button(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLButtonElement>;
 
-export declare function br(...childNodes: any[]): HyperscriptExtensions<HTMLBRElement>;
-
-export declare function button(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLButtonElement>;
-
-export declare function button(...childNodes: any[]): HyperscriptExtensions<HTMLButtonElement>;
-
-export declare function caption(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function caption(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function caption(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
 /**
- * 创建一个支持 RxJS 的复选框组件
- * @param props - 复选框的属性对象
- * @param props.checked - 可选的 RxJS BehaviorSubject，用于绑定复选框的选中状态
- * @returns 返回一个增强的复选框元素
+ * @typedef {import("./HyperscriptExtensions.d.ts").HyperscriptExtensions<HTMLInputElement>} HyperscriptInputElement
+ */
+/**
+ * 创建一个支持 RxJS 的复选框组件。
+ *
+ * @param {{checked?:BehaviorSubject<boolean>, [key: string]: any}} props - 复选框的属性对象。
+ * @returns {HyperscriptInputElement} - 返回一个复选框元素。
  */
 export declare function checkbox(props: {
-    checked?: BehaviorSubject<boolean>,
-    [key: string]: any
-}): HyperscriptExtensions<HTMLInputElement>;
+    checked?: BehaviorSubject<boolean>;
+    [key: string]: any;
+}): HyperscriptInputElement;
 
 /**
- * 根据 chosen$ 的字符值动态显示或隐藏一组不同字符标签的可能性元素块。
- * 
- * @param chosen$ - 一个可观察对象（如 BehaviorSubject），表示当前选中的可能性名称。
- * @param possibilities - 一个对象，键为可能性名称，值为对应的 HTML 元素或 HTML 元素数组。
- * @returns 包含所有可能性的 HTML 元素数组。
+ * @param {Observable<string>} chosen$
+ * @param {Record<string, HTMLElement | HTMLElement[]>} possibilities
+ * @returns {HTMLElement[]}
  */
-export declare function choice(
-chosen$: Observable<string>,
-possibilities: Record<string, HTMLElement | HTMLElement[]>
-): HTMLElement[];
-
-export declare function cite(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function cite(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function code(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function choice(chosen$: Observable<string>, possibilities: Record<string, HTMLElement | HTMLElement[]>): HTMLElement[];
 
-export declare function code(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function cite(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
-export declare function col(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLTableColElement>;
+export declare function code(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
-export declare function col(...childNodes: any[]): HyperscriptExtensions<HTMLTableColElement>;
+export declare function col(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLTableColElement>;
 
-export declare function colgroup(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLTableColElement>;
-
-export declare function colgroup(...childNodes: any[]): HyperscriptExtensions<HTMLTableColElement>;
+export declare function colgroup(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLTableColElement>;
 
 /**
- * 显示或隐藏包含的元素，通过绑定 hidden 属性实现动态显示或隐藏。
- * 
- * @param hidden$ - 一个可观察对象（如 BehaviorSubject），用于控制元素的 hidden 属性。
- * @param elements - 一个或多个 HTML 元素，或者包含 HTML 元素的数组。
- * @returns 处理后的元素数组。
- * @throws 如果 elements 中包含非 HTMLElement 节点会抛出错误。
+ * 显示或隐藏包含的元素。
+ *
+ * `collapse` 函数通过绑定 `hidden` 属性，实现一组 HTML 元素的动态显示或隐藏。
+ *
+ * @param {Observable<boolean>} hidden$ - 一个可观察对象（如 BehaviorSubject），用于控制元素的 `hidden` 属性。
+ * @param {...HTMLElement|HTMLElement[]} elements - 一个或多个 HTML 元素，或者包含 HTML 元素的数组。
+ * @returns {HTMLElement[]} - 处理后的元素数组。
+ *
+ * @throws {Error} 如果 `elements` 中包含非元素节点（如 TextNode）。
+ *
  */
-export declare function collapse(
-hidden$: Observable<boolean>,
-...elements: (HTMLElement | HTMLElement[])[]
-): HTMLElement[];
+export declare function collapse(hidden$: Observable<boolean>, ...elements: (HTMLElement | HTMLElement[])[]): HTMLElement[];
 
 /**
- * Compares two dates by their numeric value.
- * 
- * @param a - The first date to compare.
- * @param b - The second date to compare.
- * @returns A negative number if `a` is earlier than `b`, 0 if they are equal, or a positive number if `a` is later than `b`.
+ * 比较两个日期对象的大小。
+ *
+ * @public
+ * @param {Date} a - 第一个日期
+ * @param {Date} b - 第二个日期
+ * @returns {number} 如果 a > b 返回正数，a < b 返回负数，相等返回 0
  */
 export declare function compareDate(a: Date, b: Date): number;
 
 /**
- * Compares two entries (key-value pairs) based on their key paths.
- * 
- * - Uses `compareKeyPath` to compare the key paths of the two entries.
- * 
- * @param entry1 - The first entry, where the key is a key path (array of keys).
- * @param entry2 - The second entry, where the key is a key path (array of keys).
- * @returns A negative number if `entry1` is less than `entry2`, 0 if they are equal, or a positive number if `entry1` is greater than `entry2`.
+ * 比较两个 entries（key-value 对）。依据他们的 key path。
+ *
+ * @public
+ * @param {[(number|string)[], any]} entry1 - 第一个 entry，key 为 key path（键路径数组）
+ * @param {[(number|string)[], any]} entry2 - 第二个 entry，key 为 key path（键路径数组）
+ * @returns {number} 若 entry1 < entry2 返回负数，相等返回 0，大于返回正数
  */
-export declare function compareEntries(
-entry1: [(number | string)[], any],
-entry2: [(number | string)[], any]
-): number;
+export declare function compareEntries([keypath1]: [(number | string)[], any], [keypath2]: [(number | string)[], any]): number;
 
 /**
+ *
  * Compares two values and returns a number indicating their relative order.
- * 
- * - If both values are of the same type, it uses `defaultCompare` for comparison.
- * - Strings are considered greater than numbers.
- * 
- * @param a - The first value to compare (can be a `number` or `string`).
- * @param b - The second value to compare (can be a `number` or `string`).
- * @returns A negative number if `a` is less than `b`, 0 if they are equal, or a positive number if `a` is greater than `b`.
+ * @param {number|string} a - The first value to compare.
+ * @param {number|string} b - The second value to compare.
+ * @returns {number} -1 if a < b, 1 if a > b, or 0 if they are equal.
+ *
  */
 export declare function compareKey(a: number | string, b: number | string): number;
 
 /**
- * Compares two key paths (arrays of keys) lexicographically.
- * 
- * - Two empty arrays are considered equal.
- * - An empty array is considered less than a non-empty array.
- * - A non-empty array is considered greater than an empty array.
- * - If the first elements of both arrays are equal, the comparison continues recursively with the remaining elements.
- * 
- * @param a - The first key path (array of keys) to compare.
- * @param b - The second key path (array of keys) to compare.
- * @returns A negative number if `a` is less than `b`, 0 if they are equal, or a positive number if `a` is greater than `b`.
+ * 比较两个 key path（键路径数组）。
+ *
+ * @public
+ * @param {(number|string)[]} a - 第一个 key path
+ * @param {(number|string)[]} b - 第二个 key path
+ * @returns {number} 若 a < b 返回负数，相等返回 0，大于返回正数
  */
 export declare function compareKeyPath(a: (number | string)[], b: (number | string)[]): number;
 
 /**
- * Compares two numbers or bigints, including special handling for `NaN` and `Infinity`.
- * 
- * - `NaN` is considered the largest value.
- * - Supports comparison of `number` and `bigint` types.
- * 
- * @param a - The first value to compare (can be `number` or `bigint`).
- * @param b - The second value to compare (can be `number` or `bigint`).
- * @returns A negative number if `a` is less than `b`, 0 if they are equal, or a positive number if `a` is greater than `b`.
+ * 可以比较NaN,Infinity,number,bigint
+ * @param {number|bigint} a
+ * @param {number|bigint} b
  */
 export declare function compareNumber(a: number | bigint, b: number | bigint): number;
 
 /**
  * 用于比较和操作数组及集合的工具类。
+ *
+ * @public
  * @template T
  */
 export declare class Comparer<T> {
+    /**
+     * @param {(a: T, b: T) => number} compare - 比较函数
+     */
     constructor(compare: (a: T, b: T) => number);
-
+    compare: (a: T, b: T) => number;
     /**
      * 使用实例的比较函数对数组进行排序。
-     * @param array - 要排序的数组
-     * @returns 排序后的数组
+     * @param {T[]} array - 要排序的数组
+     * @returns {T[]} 排序后的数组
      */
     sort(array: T[]): T[];
-
     /**
      * 移除数组中的重复值。
-     * @param array - 要处理的数组
-     * @returns 去重后的新数组
+     * @param {T[]} array - 要处理的数组
+     * @returns {T[]} 去重后的新数组
      */
     distinct(array: T[]): T[];
-
+    /**
+     * 将已排序的数组转为集合（去重）。
+     * @param {T[]} array - 已排序的数组
+     * @returns {T[]} 唯一元素数组
+     */
+    sortedArrayToSet(array: T[]): T[];
     /**
      * 根据 getKey 生成的 key 对数组元素分组。
      * @template U
-     * @param array - 要分组的数组
-     * @param getKey - 生成分组 key 的函数
-     * @returns 分组后的对象或数组
+     * @param {U[]} array - 要分组的数组
+     * @param {(item:U) => T} getKey - 生成分组 key 的函数
+     * @returns {[T, U[]][]} 分组后的对象或数组
      */
     groupBy<U>(array: U[], getKey: (item: U) => T): [T, U[]][];
-
     /**
      * 对已排序的数组按 key 分组。
      * @template V
-     * @param array - 已排序的数组
-     * @returns 分组结果
+     * @param {[T,V][]} array - 已排序的数组
+     * @returns {[T, V[]][]} 分组结果
      */
     groupSortedEntries<V>(array: [T, V][]): [T, V[]][];
-
     /**
-     * 计算两个数组的差集。
-     * @param array1 - 第一个数组
-     * @param array2 - 第二个数组
-     * @returns array1 中有而 array2 中没有的元素
+     * 计算两个数组的差集。数组元素是升序排列
+     * @param {T[]} array1 - 第一个数组
+     * @param {T[]} array2 - 第二个数组
+     * @returns {T[]} array1 中有而 array2 中没有的元素
      */
     differenceSet(array1: T[], array2: T[]): T[];
-
-    /**
-     * 在集合（数组）中查找元素的索引。
-     * @param set - 要查找的数组
-     * @param element - 要查找的元素
-     * @returns 元素在集合中的索引，未找到返回 -1
-     */
-    findIndexInSet(set: T[], element: T): number;
-
     /**
      * 计算两个数组的交集。
-     * @param array1 - 第一个数组
-     * @param array2 - 第二个数组
-     * @returns 同时存在于 array1 和 array2 的元素
+     * @param {T[]} array1 - 第一个数组
+     * @param {T[]} array2 - 第二个数组
+     * @returns {T[]} 同时存在于 array1 和 array2 的元素
      */
     intersectSet(array1: T[], array2: T[]): T[];
-
+    /**
+     * 计算两个数组的并集（去重）。
+     * @param {T[]} array1 - 第一个数组
+     * @param {T[]} array2 - 第二个数组
+     * @returns {T[]} 两个数组的唯一元素合集
+     */
+    unionSet(array1: T[], array2: T[]): T[];
+    /**
+     * 在集合（数组）中查找元素的索引。
+     * @param {T[]} set - 要查找的数组
+     * @param {T} element - 要查找的元素
+     * @returns {number} 元素在集合中的索引，未找到返回 -1
+     */
+    findIndexInSet(set: T[], element: T): number;
     /**
      * 判断两个数组作为集合是否相等。
-     * @param array1 - 第一个数组
-     * @param array2 - 第二个数组
-     * @returns 如果集合相等返回 true，否则返回 false
+     * @param {T[]} array1 - 第一个数组
+     * @param {T[]} array2 - 第二个数组
+     * @returns {boolean} 如果集合相等返回 true，否则返回 false
      */
     isEqualset(array1: T[], array2: T[]): boolean;
-
     /**
      * 判断第一个数组是否为第二个数组的子集。
-     * @param array1 - 第一个数组
-     * @param array2 - 第二个数组
-     * @returns 如果 array1 是 array2 的子集返回 true，否则返回 false
+     * @param {T[]} array1 - 第一个数组
+     * @param {T[]} array2 - 第二个数组
+     * @returns {boolean} 如果 array1 是 array2 的子集返回 true，否则返回 false
      */
     isSubset(array1: T[], array2: T[]): boolean;
-
     /**
      * 判断第一个数组是否为第二个数组的超集。
-     * @param array1 - 第一个数组
-     * @param array2 - 第二个数组
-     * @returns 如果 array1 是 array2 的超集返回 true，否则返回 false
+     * @param {T[]} array1 - 第一个数组
+     * @param {T[]} array2 - 第二个数组
+     * @returns {boolean} 如果 array1 是 array2 的超集返回 true，否则返回 false
      */
     isSuperset(array1: T[], array2: T[]): boolean;
-
-    /**
-     * 计算两个数组的并集（去重）。
-     * @param array1 - 第一个数组
-     * @param array2 - 第二个数组
-     * @returns 两个数组的唯一元素合集
-     */
-    unionSet(array1: T[], array2: T[]): T[];
-
-    /**
-     * 将已排序的数组转为集合（去重）。
-     * @param array - 已排序的数组
-     * @returns 唯一元素数组
-     */
-    sortedArrayToSet(array: T[]): T[];
 }
 
-/**
- * 函数优先的管道组合工具（从右向左执行）。
- * @public
- * @param fns - 要组合的函数列表。
- * @returns 组合后的函数（无参数时返回恒等函数 x => x）。
- * @throws {TypeError} 当参数包含非函数时抛出错误。
- */
-export declare function compose(
-...fns: Array<(arg: any) => any>
-): (input: any) => any;
-
-/**
- * 条件分支函数，根据分支依次判断并执行。
- * @public
- * @param branches - 分支数组，每个分支可以是函数或 [predicate, action] 形式的数组。
- * @returns 一个函数，调用时会依次判断分支并返回第一个匹配的结果。
- */
-export declare function cond<T extends any[], R>(
-branches: (
-| ((...args: T) => R | undefined | void | null | false)
-| [ (...args: T) => any, (...args: [...T, any]) => R ]
-)[]
-): (...args: T) => R | undefined;
+export declare function compose(...fns: ((arg: any) => any)[]): (arg: any) => any;
 
-export declare function data(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLDataElement>;
+export declare function cond(branches: Array<Function | [Function, Function]>): (...args: any[]) => any;
 
-export declare function data(...childNodes: any[]): HyperscriptExtensions<HTMLDataElement>;
+export declare function data(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLDataElement>;
 
-export declare function datalist(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLDataListElement>;
+export declare function datalist(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLDataListElement>;
 
-export declare function datalist(...childNodes: any[]): HyperscriptExtensions<HTMLDataListElement>;
-
-export declare function dd(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function dd(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function dd(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
+/**
+ * 深度（嵌套）数据结构类，用于处理按键路径排序的键值对集合。
+ * 提供了多种操作方法，包括集合操作、序列操作和数据转换。
+ *
+ * @template T
+ *
+ */
 export declare class Deep<T> {
+    /**
+     *
+     * @param {{[_:string|number]:any}} obj
+     * @param {(value: any, key: string | number, keyPath: (string | number)[]) => boolean} [filter]
+     * @returns
+     */
+    static fromObject(obj: {
+        [_: string | number]: any;
+    }, filter?: (value: any, key: string | number, keyPath: (string | number)[]) => boolean): Deep<any>;
+    /**
+     * @template T
+     * @param {{[_:string|number]:any}} obj
+     * @returns {Deep<BehaviorSubject<T>>}
+     */
+    static fromBehaviorSubject<T_1>(obj: {
+        [_: string | number]: any;
+    }): Deep<BehaviorSubject<T_1>>;
+    /**
+     * @template T
+     * @param {{[_:string|number]:any}} obj
+     * @returns
+     */
+    static fromObservable<T_1>(obj: {
+        [_: string | number]: any;
+    }): Deep<any>;
+    /**
+     * 构造函数。
+     *
+     * @param {[(string|number)[], T][]} entries - 按键路径排序的键值对数组。键值对已经按keypath排序。
+     */
     constructor(entries: [(string | number)[], T][]);
-
-    readonly entries: [(string | number)[], T][];
-    readonly keys: (string | number)[][];
+    _entries: [(string | number)[], T][];
+    _keys: (string | number)[][];
+    get entries(): [(string | number)[], T][];
+    get keys(): (string | number)[][];
     getValues(): T[];
-
     /**
      * 将深度数据结构转换为普通对象。
-     * 
+     *
      * @returns {Record<string|number, any>} 转换后的普通对象。
      */
     toObject(): Record<string | number, any>;
-
+    /**
+     *
+     * @param {(string|number)[]} searchKeyPath
+     * @returns
+     */
     findIndex(searchKeyPath: (string | number)[]): number;
-
+    /**
+     *
+     * @param {(string|number)[][]} keys
+     * @returns
+     */
     structuralEqual(keys: (string | number)[][]): boolean;
+    /**
+     *
+     * @param {(string|number)[][]} keys
+     * @returns
+     */
     structuralSubset(keys: (string | number)[][]): boolean;
+    /**
+     *
+     * @param {(string|number)[][]} keys
+     * @returns
+     */
     structuralSuperset(keys: (string | number)[][]): boolean;
-
-    intersect(keys: (string | number)[][]): Deep<T>;
-    difference(keys: (string | number)[][]): Deep<T>;
+    /**
+     * @param {(string|number)[][]} keys
+     * @this {Deep<T>}
+     * @returns {Deep<T>}
+     */
+    intersect(this: Deep<T>, keys: (string | number)[][]): Deep<T>;
+    /**
+     *
+     * @param {(string|number)[][]} keys
+     * @this {Deep<T>}
+     * @returns {Deep<T>}
+     */
+    difference(this: Deep<T>, keys: (string | number)[][]): Deep<T>;
     /**
      * 后来者赢(参数赢)
-     * @param entries 
+     * @param {[(string | number)[], T][]} entries
+     * @returns
      */
-    union(entries: [(string | number)[], T][]): Deep<T>;
-
-    map<U>(
-    callbackfn: (value: [(string | number)[], T], index: number, array: [(string | number)[], T][]) => U,
-    thisArg?: any
-    ): Deep<U>;
-    filter(
-    predicate: (value: [(string | number)[], T], index: number, array: [(string | number)[], T][]) => boolean,
-    thisArg?: any
-    ): Deep<T>;
-    forEach(
-    callbackfn: (value: [(string | number)[], T], index: number, array: [(string | number)[], T][]) => void,
-    thisArg?: any
-    ): void;
-
-    freshValue(obj: Record<string | number, any>): Deep<any>;
-    replaceValue<U>(values: U[]): Deep<U>;
-    zipValue<U>(values: U[]): Deep<[T, U]>;
-
-    combineLatest<U>(): Observable<Deep<U>>;
-    merge<U>(): Observable<[(string | number)[], U]>;
-
-    static fromObject(
-    obj: Record<string | number, any>,
-    filter?: (value: any, key: string | number, keyPath: (string | number)[]) => boolean
-    ): Deep<any>;
-    static fromBehaviorSubject(obj: Record<string | number, any>): Deep<BehaviorSubject<any>>;
-    static fromObservable(obj: Record<string | number, any>): Deep<Observable<any>>;
+    union(entries: [(string | number)[], T][]): Deep<any>;
+    /**
+     *
+     * @template U
+     * @param {(value: [(string | number)[], T], index: number, array: [(string | number)[], T][]) => U} callbackfn 返回的是值，而不是键值对，KeyPath保持不变
+     * @param {Deep<T>} [thisArg]
+     * @this {Deep<T>}
+     * @returns {Deep<U>}
+     *
+     */
+    map<U>(this: Deep<T>, callbackfn: (value: [(string | number)[], T], index: number, array: [(string | number)[], T][]) => U, thisArg?: Deep<T>): Deep<U>;
+    /**
+     *
+     * @param {(value: [(string | number)[], T], index: number, array: [(string | number)[], T][]) => boolean} predicate
+     * @param {Deep<T>} [thisArg]
+     * @returns
+     */
+    filter(predicate: (value: [(string | number)[], T], index: number, array: [(string | number)[], T][]) => boolean, thisArg?: Deep<T>): Deep<T>;
+    /**
+     *
+     * @param { (value: [(string | number)[], T], index: number, array: [(string | number)[], T][]) => void} callbackfn
+     * @param {Deep<T>} [thisArg]
+     * @returns
+     */
+    forEach(callbackfn: (value: [(string | number)[], T], index: number, array: [(string | number)[], T][]) => void, thisArg?: Deep<T>): void;
+    /**
+     * 修改部分个别数值
+     * @param {Record<string|number,any>} obj
+     * @this {Deep<T>}
+     * @returns
+     */
+    freshValue(this: Deep<T>, obj: Record<string | number, any>): Deep<any>;
+    /**
+     * 按列替换数值
+     * @template U
+     * @param {U[]} values
+     * @this {Deep<T>}
+     * @returns {Deep<U>}
+     */
+    replaceValue<U>(this: Deep<T>, values: U[]): Deep<U>;
+    /**
+     * 按列替换数值，保留原有数值
+     * @template U
+     * @param {U[]} values
+     * @this {Deep<T>}
+     * @returns {Deep<[T,U]>}
+     */
+    zipValue<U>(this: Deep<T>, values: U[]): Deep<[T, U]>;
+    /**
+     * 返回Observable of 总体的当前值
+     * @template U
+     * @this {Deep<Observable<U>>}
+     * @returns {Observable<Deep<U>>}
+     */
+    combineLatest<U>(this: Deep<Observable<U>>): Observable<Deep<U>>;
+    /**
+     * 返回发射消息的那一个成员的路径以及新值。
+     * @template U
+     * @this {Deep<Observable<U>>}
+     * @returns {Observable<[(string|number)[], U]>}
+     */
+    merge<U>(this: Deep<Observable<U>>): Observable<[(string | number)[], U]>;
 }
 
 /**
- * Compares two values using the default comparison logic.
- * 
- * @param a - The first value to compare.
- * @param b - The second value to compare.
- * @returns A negative number if `a` is less than `b`, 0 if they are equal, or a positive number if `a` is greater than `b`.
+ * 默认比较函数，适用于可比较的基本类型。
+ *
+ * @public
+ * @template T
+ * @param {T} a - 第一个值
+ * @param {T} b - 第二个值
+ * @returns {number} 如果 a > b 返回 1，a < b 返回 -1，相等返回 0
  */
 export declare function defaultCompare<T>(a: T, b: T): number;
 
-/**
- * A comparer instance using the default comparison logic.
- */
 export declare const defaultComparer: Comparer<any>;
 
-export declare function del(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLModElement>;
-
-export declare function del(...childNodes: any[]): HyperscriptExtensions<HTMLModElement>;
-
-export declare function details(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLDetailsElement>;
+export declare function del(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLModElement>;
 
-export declare function details(...childNodes: any[]): HyperscriptExtensions<HTMLDetailsElement>;
+export declare function details(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLDetailsElement>;
 
-export declare function dfn(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function dfn(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
-export declare function dfn(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function dialog(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLDialogElement>;
 
-export declare function dialog(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLDialogElement>;
+export declare function div(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLDivElement>;
 
-export declare function dialog(...childNodes: any[]): HyperscriptExtensions<HTMLDialogElement>;
+export declare function dl(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLDListElement>;
 
-export declare function div(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLDivElement>;
+export declare function dt(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
-export declare function div(...childNodes: any[]): HyperscriptExtensions<HTMLDivElement>;
+export declare function em(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
-export declare function dl(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLDListElement>;
-
-export declare function dl(...childNodes: any[]): HyperscriptExtensions<HTMLDListElement>;
-
-export declare function dt(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function dt(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function em(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function em(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare const entryComparer: Comparer<[(string | number)[], any]>;
 
 /**
- * A comparer instance for comparing entries.
- */
-export declare const entryComparer: Comparer<[(number | string)[], any]>;
-
-/**
- * 从扁平化的数据集构建嵌套的 JavaScript 对象或数组。
- * 
- * @param entries - 扁平化的键值对数组。每个元素为 [keyPath, value]，keyPath 是 (string | number)[]。
- * @returns 嵌套的对象或数组。
+ * 从扁平化的数据集构建嵌套的 JavaScript 对象。
+ *
+ * @param {[ (string | number)[], any ][]} entries - 扁平化的键值对数组。
+ * 每个键值对的格式为 `[keyPath, value]`，其中 `keyPath` 是一个表示嵌套路径的数组。
+ * @returns {object | any[]} - 返回嵌套的 JavaScript 对象或数组。
  */
-export declare function erectObject(
-entries: [ (string | number)[], any ][]
-): object | any[];
-
-export declare function fieldset(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLFieldSetElement>;
-
-export declare function fieldset(...childNodes: any[]): HyperscriptExtensions<HTMLFieldSetElement>;
+export declare function erectObject(entries: [(string | number)[], any][]): object | any[];
 
-export declare function figcaption(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function fieldset(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLFieldSetElement>;
 
-export declare function figcaption(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function figcaption(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
-export declare function figure(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function figure(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function figure(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
 /**
- * Finds the last index in an array where the callback function returns `true`.
- * 
- * @param array - The array to search.
- * @param callbackFn - A function that is called for each element in the array. 
- *                     It should return `true` for the element to match.
- * @param lastIndex - The starting index for the search (default is the last index of the array).
- * @returns The index of the last element that satisfies the callback function, or -1 if no such element is found.
+ * 查找数组中最后一个满足条件的元素索引。
+ *
+ * @public
+ * @template T
+ * @param {T[]} array - 要查找的数组
+ * @param {(value: T, index: number) => boolean} callbackFn - 判断函数，返回 true 表示找到
+ * @param {number} [lastIndex=array.length-1] - 可选，查找的起始索引（从后往前）
+ * @returns {number} - 最后一个满足条件的元素索引，未找到返回 -1
  */
-export declare function findLastIndex<T>(
-array: T[],
-callbackFn: (value: T, index: number) => boolean,
-lastIndex?: number
-): number;
+export declare function findLastIndex<T>(array: T[], callbackFn: (value: T, index: number) => boolean, lastIndex?: number): number;
 
-/**
- * Flattens an object or array into an array of key paths and values.
- * 
- * @param data - The object or array to flatten.
- * @param isLeaf - A function that determines whether a property should be treated as a leaf node.
- *                 If the function returns true, the property is treated as a leaf node.
- *                 The function receives (value, key, keyPath) as arguments.
- * @returns An array of tuples, where each tuple contains a key path (array of string or number) and the corresponding value.
- */
-export declare function flat(
-data: Record<string | number, any>,
-isLeaf: (
-value: any,
-key: string | number,
-keyPath: (string | number)[]) => boolean
-): [(string | number)[], any][];
+export declare function flat(data: any, isLeaf?: (value: any, key: string | number, keyPath: (string | number)[]) => boolean): [(string | number)[], any][];
 
 /**
  * 动态切换两个元素或元素数组的显示状态。
- * 
- * @param yinHidden$ - 一个 Observable，表示 yin 是否隐藏。
- * @param yin - 需要动态控制显示状态的第一个元素或元素数组。
- * @param yang - 需要动态控制显示状态的第二个元素或元素数组。
- * @returns 包含所有元素的数组。
+ *
+ * `flip` 函数根据 `yinHidden$` 的值动态控制 `yinElement` 和 `yangElement` 的显示状态：
+ * - 当 `yinHidden$` 为 `true` 时，隐藏 `yinElement`，显示 `yangElement`。
+ * - 当 `yinHidden$` 为 `false` 时，显示 `yinElement`，隐藏 `yangElement`。
+ *
+ * @param {Observable<boolean>} yinHidden$ - 一个 Observable，表示 `yinElement` 是否隐藏。
+ * @param {HTMLElement|HTMLElement[]} yin - 需要动态控制显示状态的第一个元素或元素数组。
+ * @param {HTMLElement|HTMLElement[]} yang - 需要动态控制显示状态的第二个元素或元素数组。
+ * @returns {HTMLElement[]} - 包含所有元素的数组。
+ *
  */
-export declare function flip(
-yinHidden$: Observable<boolean>,
-yin: HTMLElement | HTMLElement[],
-yang: HTMLElement | HTMLElement[]
-): HTMLElement[];
+export declare function flip(yinHidden$: Observable<boolean>, yin: HTMLElement | HTMLElement[], yang: HTMLElement | HTMLElement[]): HTMLElement[];
 
 /**
- * 通用折叠（归约）函数，支持自定义迭代逻辑。
+ * 通用折叠（递归归约）函数。
+ *
  * @public
- * @param fn - 迭代函数，接收 (acc, seed)，返回 [newAcc, nextSeed] 或 [newAcc] 或 null/undefined 结束。
- * @param acc - 初始累加值。
- * @param seed - 初始种子值。
- * @returns 折叠后的累加结果。
+ * @param {(this:any, acc: any, seed: any) => [*, *]|[any]|[]|null|undefined} fn - 处理函数，返回 [新acc, 新seed] 或 [新acc]
+ * @param {*} acc - 初始累加值
+ * @param {*} seed - 初始种子
+ * @returns {*} 折叠后的结果
+ * @this *
  */
-export declare function fold<A, S>(
-fn: (acc: A, seed: S) => [A, S] | [A] | [] | null | undefined,
-acc: A,
-seed: S
-): A;
+export declare function fold(this: any, fn: (this: any, acc: any, seed: any) => [any, any] | [any] | [] | null | undefined, acc: any, seed: any): any;
 
-export declare function footer(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function footer(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
-export declare function footer(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function form(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLFormElement>;
-
-export declare function form(...childNodes: any[]): HyperscriptExtensions<HTMLFormElement>;
+export declare function form(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLFormElement>;
 
 /**
- * 插入一组元素，返回包含所有子节点的 DocumentFragment。
- * 
- * @param childNodes - 要插入的子节点，可以是单个节点、多个节点或节点数组。
- * @returns 包含所有子节点的 DocumentFragment。
- * @throws 如果传入的子节点不是有效的 DOM 节点会抛出错误。
+ * 用途：插入一组元素，不必使用循环语句，fragment 用后即弃。
+ *
+ * @param {...Node|Node[]} childNodes - 要插入的子节点，可以是单个节点、多个节点或节点数组。
+ * @returns {DocumentFragment} - 返回包含所有子节点的 DocumentFragment。
+ * @throws {Error} 如果传入的子节点不是有效的 DOM 节点。
  */
-export declare function fragment(
-...childNodes: (Node | Node[])[]
-): DocumentFragment;
+export declare function fragment(...childNodes: (Node | Node[])[]): DocumentFragment;
 
 /**
  * 获取 HTML 元素的默认 CSS `display` 值。
- * 
- * @param elem - 要获取 `display` 值的 HTML 元素。
- * @returns 元素的默认 `display` 值，如 'block'、'inline'、'table-row'、'unset' 等。
+ *
+ * 根据元素的标签名称 (`tagName`)，返回其对应的默认 `display` 属性值。
+ * 支持表格相关标签、块级元素、内联元素等常见 HTML 标签。
+ *
+ * @param {HTMLElement} elem - 要获取 `display` 值的 HTML 元素。
+ * @returns {string} - 元素的默认 `display` 值：
+ * - 表格相关标签：
+ *   - `TBODY` -> `'table-row-group'`
+ *   - `THEAD` -> `'table-header-group'`
+ *   - `TFOOT` -> `'table-footer-group'`
+ *   - `TR` -> `'table-row'`
+ *   - `TD`、`TH` -> `'table-cell'`
+ *   - `COLGROUP` -> `'table-column-group'`
+ *   - `COL` -> `'table-column'`
+ *   - `CAPTION` -> `'table-caption'`
+ * - 块级元素 -> `'block'`
+ * - 内联元素 -> `'inline'`
+ * - 未知标签 -> `'unset'`
+ *
  */
 export declare function getDisplay(elem: HTMLElement): string;
 
 /**
  * 根据属性路径数组读取对象的嵌套属性值。
- * 
- * @param obj - 要读取属性的对象。
- * @param keyPath - 属性路径数组，例如 ['a', 'b'] 表示 obj.a.b。
- * @returns 返回目标属性的值，如果路径为空数组，则返回对象本身。
- * @throws 如果路径中的某一级属性不存在或输入无效会抛出错误。
+ * @param {Record<string | number, any>} obj - 要读取属性的对象。
+ * @param {(string | number)[]} keyPath - 属性路径数组，例如 ['a', 'b'] 表示 obj.a.b。
+ * @returns {any} - 返回目标属性的值，如果路径为空数组，则返回对象本身。
+ * @throws {Error} 如果路径中的某一级属性不存在或输入无效。
  */
-export declare function getNestedProperty(
-obj: Record<string | number, any>,
-keyPath: (string | number)[]
-): any;
+export declare function getNestedProperty(obj: Record<string | number, any>, keyPath: (string | number)[]): any;
 
 /**
- * 按第一层 key 对扁平化 entries 分组。
- * 
- * @param flatEntries - 扁平化的键值对数组。每个元素为 [[key, ...keyPath], value]。
- * @returns 分组后的数组，每组为 [key, group]，group 是 [[keyPath, value]][]。
+ * Groups an array of flattened entries by their first level key.
+ * This function is memory-optimized and adapted from `groupArrayBy`.
+ *
+ * @param {[ (string | number)[], any ][]} flatEntries - Array of flattened entries to be grouped.
+ *        Each entry is of the form [[key, ...keyPath], value] where:
+ *        - The first element is an array representing the key path (first element is primary key)
+ *        - The second element is the associated value
+ * @returns {[ string | number, [ (string | number)[], any ][] ][]} An array of grouped entries where:
+ *        - Each entry is a tuple [key, group]
+ *        - key is the first-level grouping key (string|number)
+ *        - group is an array of entries sharing that key, each of form [keyPath, value]
+ *
  */
-export declare function groupByFirstLevelKey(
-flatEntries: [ (string | number)[], any ][]
-): [ string | number, [ (string | number)[], any ][] ][];
-
-export declare function h1(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLHeadingElement>;
-
-export declare function h1(...childNodes: any[]): HyperscriptExtensions<HTMLHeadingElement>;
-
-export declare function h2(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLHeadingElement>;
+export declare function groupByFirstLevelKey(flatEntries: [(string | number)[], any][]): [string | number, [(string | number)[], any][]][];
 
-export declare function h2(...childNodes: any[]): HyperscriptExtensions<HTMLHeadingElement>;
+export declare function h1(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLHeadingElement>;
 
-export declare function h3(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLHeadingElement>;
+export declare function h2(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLHeadingElement>;
 
-export declare function h3(...childNodes: any[]): HyperscriptExtensions<HTMLHeadingElement>;
+export declare function h3(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLHeadingElement>;
 
-export declare function h4(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLHeadingElement>;
+export declare function h4(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLHeadingElement>;
 
-export declare function h4(...childNodes: any[]): HyperscriptExtensions<HTMLHeadingElement>;
+export declare function h5(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLHeadingElement>;
 
-export declare function h5(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLHeadingElement>;
+export declare function h6(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLHeadingElement>;
 
-export declare function h5(...childNodes: any[]): HyperscriptExtensions<HTMLHeadingElement>;
+export declare function header(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
-export declare function h6(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLHeadingElement>;
+export declare function hgroup(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
-export declare function h6(...childNodes: any[]): HyperscriptExtensions<HTMLHeadingElement>;
-
-export declare function header(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function header(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function hgroup(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function hgroup(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function hr(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLHRElement>;
-
-export declare function hr(...childNodes: any[]): HyperscriptExtensions<HTMLHRElement>;
+export declare function hr(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLHRElement>;
 
+/**
+ * @typedef {import("./HyperscriptExtensions.d.ts").HyperscriptExtensions<HTMLElement>} HyperscriptElement
+ */
 /**
  * Creates an HTML element with extended event handling capabilities
  * @public
- * @param elemName The HTML element tag name
- * @param args Optional properties and child nodes
- * @returns The created element with extended methods
- * @throws If elemName is not a valid HTML element tag name
+ * @param {string} elemName - The HTML element tag name
+ * @param {...any} args - Optional properties and child nodes
+ * @returns {HyperscriptElement} The created element with extended methods
+ * @throws {Error} If elemName is not a valid HTML element tag name
  */
-export declare function hyperscript(
-elemName: string,
-...args: any[]
-): HyperscriptExtensions<HTMLElement>;
+export declare function hyperscript(elemName: string, ...args: any[]): HyperscriptElement;
+
+export declare type HyperscriptElement = HyperscriptExtensions_2<HTMLElement>;
 
-declare type HyperscriptExtensions<T extends HTMLElement> =
+export declare type HyperscriptExtensions<T extends HTMLElement> = HyperscriptExtensions_2<T>;
+
+declare type HyperscriptExtensions_3<T extends HTMLElement> =
 T & {
 
     pipeEvent(
     event: string,
     subscriber: (input$: Observable<Event>) => Subscription
-    ): HyperscriptExtensions<T>;
+    ): HyperscriptExtensions_3<T>;
 
     subscribeEvent(
     event: string,
-    observer: ((value: Event) => void) | Partial<Observer<Event>>
-    ): HyperscriptExtensions<T>;
+    observer: ((value: Event) => void) | Partial<Observer_2<Event>>
+    ): HyperscriptExtensions_3<T>;
 
     unsubscribe(): void;
 
@@ -674,66 +733,72 @@ T & {
 
 };
 
-export declare function i(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare type HyperscriptInputElement = HyperscriptExtensions_2<HTMLInputElement>;
+
+declare type HyperscriptInputElement_2 = HyperscriptExtensions_3<HTMLInputElement>;
 
-export declare function i(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare type HyperscriptSelectElement = HyperscriptExtensions_2<HTMLSelectElement>;
 
-export declare function img(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLImageElement>;
+declare type HyperscriptSelectElement_2 = HyperscriptExtensions_3<HTMLSelectElement>;
 
-export declare function img(...childNodes: any[]): HyperscriptExtensions<HTMLImageElement>;
+declare type HyperscriptTextAreaElement = HyperscriptExtensions_3<HTMLTextAreaElement>;
+
+export declare function i(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+
+export declare function img(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLImageElement>;
 
 /**
- * 一个包含所有 HTML 内联元素标签名称（大写）的集合。
- * 用于判断某个标签是否为内联元素。
+ * 一个包含所有 HTML 内联元素标签名称的集合。
+ *
+ * 内联元素是 HTML 中的一类元素，它们不会独占一行，通常用于包裹文本或其他内联元素。
+ * 该集合中的标签名称均为大写，便于快速判断某个元素是否为内联元素。
+ *
+ * 常见的内联元素包括：
+ * - 文本样式：`B`、`I`、`U`、`STRONG`、`EM`、`MARK` 等。
+ * - 链接和交互：`A`、`BUTTON`、`LABEL`、`INPUT`、`SELECT`、`TEXTAREA` 等。
+ * - 媒体和嵌入：`IMG`、`SVG`、`VIDEO`、`AUDIO`、`CANVAS` 等。
+ * - 其他：`SPAN`、`BR`、`WBR`、`CODE`、`Q` 等。
+ *
+ * @constant {Set<string>} inlineFamily
  */
 export declare const inlineFamily: Set<string>;
 
-export declare function input(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLInputElement>;
-
-export declare function input(...childNodes: any[]): HyperscriptExtensions<HTMLInputElement>;
+export declare function input(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLInputElement>;
 
-export declare function ins(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLModElement>;
-
-export declare function ins(...childNodes: any[]): HyperscriptExtensions<HTMLModElement>;
+export declare function ins(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLModElement>;
 
 /**
- * 创建一个新对象，仅包含指定 keys 的属性。
- * 
- * @param obj - 源对象。
- * @param keys - 要保留的属性名数组。
- * @returns 新对象，仅包含指定属性。
- * @throws 如果 obj 不是对象或 keys 不是数组会抛出 TypeError。
+ * Creates an object composed of the picked object properties.
+ * @param {Record<string,any>} obj - Source object
+ * @param {string[]} keys - Array of property keys to pick
+ * @returns {Record<string,any>} New object with picked properties
+ * @throws {TypeError} If obj is not an object or keys is not an array
  */
-export declare function intersectObject(
-obj: Record<string,any>,
-keys: string[]
-): Record<string,any>;
+export declare function intersectObject(obj: Record<string, any>, keys: string[]): Record<string, any>;
 
-/**
- * 判断对象是否为空对象（非数组、非 null，且无自有属性）。
- * 
- * @param obj - 要判断的对象。
- * @returns 如果是空对象返回 true，否则返回 false。
- */
-export declare function isEmptyObject(obj: unknown): boolean;
+export declare function isEmptyObject(obj: unknown): obj is Record<never, never>;
 
 /**
- * 
- * Type guard for plain objects (objects created via {} or Object.create(null))
- * 
- * @param value - The value to check
- * @returns True if the value is a plain object, false otherwise
- * 
+ * 检查一个值是否是普通对象（Plain Object）
+ * @param {unknown} value - 要检查的值
+ * @returns {value is object} - 返回是否是普通对象的类型谓词
  */
-export declare function isPlainObject(
-value: unknown
-): value is Record<string, any>;
+export declare function isPlainObject(value: unknown): value is object;
 
 /**
- * Checks if the input array represents a range of consecutive numbers starting from 0.
- * 
- * @param keys - An array of strings to check.
- * @returns `true` if the array represents a range of consecutive numbers starting from 0, otherwise `false`.
+ * 判断输入的字符串数组是否为从0开始的连续数字区间（如 ['0','1','2',...])。
+ *
+ * @public
+ * @param {string[]} keys - 要检查的字符串数组
+ * @returns {boolean} - 如果是从0开始的连续数字区间返回 true，否则返回 false
  */
 export declare function isRange(keys: string[]): boolean;
 
@@ -742,671 +807,632 @@ export declare function isRange(keys: string[]): boolean;
  *
  * `isRxType` 函数用于判断给定的对象是否为 RxJS 的 `Observable` 或 `Subscription` 类型。
  *
- * @param obj - 要检查的对象。
- * @returns 如果对象是 `Observable` 或 `Subscription`，返回 `true`；否则返回 `false`。
+ * @param {any} obj - 要检查的对象。
+ * @returns {boolean} - 如果对象是 `Observable` 或 `Subscription`，返回 `true`；否则返回 `false`。
+ *
  */
 export declare function isRxType(obj: any): boolean;
 
-export declare function kbd(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function kbd(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-/**
- * A comparer instance for comparing keys.
- */
-export declare const keyComparer: Comparer<number | string>;
-
-/**
- * A comparer instance for comparing key paths.
- */
-export declare const keyPathComparer: Comparer<(number | string)[]>;
-
-export declare function label(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLLabelElement>;
-
-export declare function label(...childNodes: any[]): HyperscriptExtensions<HTMLLabelElement>;
-
-export declare function legend(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLLegendElement>;
+export declare function kbd(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
-export declare function legend(...childNodes: any[]): HyperscriptExtensions<HTMLLegendElement>;
+export declare const keyComparer: Comparer<string | number>;
 
-export declare function li(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLLIElement>;
+export declare const keyPathComparer: Comparer<(string | number)[]>;
 
-export declare function li(...childNodes: any[]): HyperscriptExtensions<HTMLLIElement>;
+export declare function label(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLLabelElement>;
 
-export declare function main(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function legend(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLLegendElement>;
 
-export declare function main(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function li(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLLIElement>;
 
-export declare function mark(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function main(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
-export declare function mark(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function mark(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
-export declare function menu(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLMenuElement>;
+export declare function menu(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLMenuElement>;
 
-export declare function menu(...childNodes: any[]): HyperscriptExtensions<HTMLMenuElement>;
+export declare function menuitem(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
-export declare function menuitem(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function menuitem(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function meter(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLMeterElement>;
-
-export declare function meter(...childNodes: any[]): HyperscriptExtensions<HTMLMeterElement>;
+export declare function meter(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLMeterElement>;
 
 /**
- * 创建一个支持多选功能的 <select> 元素，并绑定选项的选中状态。
- * 必须手动添加控件更新 BehaviorSubject 的事件。
- * 
- * @param props - 配置对象，包含 <select> 元素的属性。
- * @param options - 一个或多个 <option> 元素，必须是 HTMLOptionElement 类型。
- * @returns 创建的 <select> 元素。
- * @throws 如果 props 不是对象，或者 options 中的选项未正确定义 selected 属性会抛出错误。
+ * @typedef {import("./HyperscriptExtensions.d.ts").HyperscriptExtensions<HTMLSelectElement>} HyperscriptSelectElement
  */
-export declare function multiselect(
-props: { 
-    oninput?: (e: Event) => void, 
-    onchange?: (e: Event) => void, 
-    [key: string]: any },
-...options: HTMLOptionElement[]
-): HyperscriptExtensions<HTMLSelectElement>;
-
-export declare function nav(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+/**
+ * 创建一个支持多选功能的 <select> 元素，并绑定选项的选中状态。必须手动添加控件更新BehaviorSubject的事件。
+ *
+ * @param {{oninput?: (e:Event)=>void, onchange?: (e:Event)=>void, [key: string]: any}} props - 配置对象，包含 <select> 元素的属性。
+ * @param {...HTMLOptionElement} options - 一个或多个 <option> 元素，必须是 HTMLOptionElement 类型。
+ * 每个选项需要包含一个 `selected` 属性，该属性是一个 BehaviorSubject ，用于绑定选中状态。
+ * @returns {HyperscriptSelectElement} - 创建的 <select> 元素。
+ * @throws {Error} 如果 `props` 不是对象，或者 `options` 中的选项未正确定义 `selected` 属性。
+ *
+ */
+export declare function multiselect(props: {
+    oninput?: (e: Event) => void;
+    onchange?: (e: Event) => void;
+    [key: string]: any;
+}, ...options: HTMLOptionElement[]): HyperscriptSelectElement;
 
-export declare function nav(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function nav(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
 /**
- * 将对象格式的 Observable 转换为扁平对象的 Observable。
- * 
- * @param model - 对象格式的 Observable。
- * @returns 一个 Observable，发出扁平化后的对象。
+ *
+ * @param {Record<string|number, any>} model
+ * @returns {Observable<Record<string|number, any>>}
  */
-export declare function nestedCombineLatest(
-model: Record<string|number, any>,
-): Observable<Record<string|number, any>>;
+export declare function nestedCombineLatest(model: Record<string | number, any>): Observable<Record<string | number, any>>;
 
 /**
- * 追踪对象属性的变化，返回变化属性的键路径和新值。
- * 
- * @param model - 任意对象或可观察对象。
- * @returns 合并后的 Observable。
+ *
+ * @param {Record<string|number, any>} model
+ * @returns {Observable<[(string | number)[], any]>}
  */
-export declare function nestedMerge(
-model: Record<string|number, any>
-): Observable<[ (string | number)[], any ]>;
+export declare function nestedMerge(model: Record<string | number, any>): Observable<[(string | number)[], any]>;
 
 /**
  * 规范化子节点，将非节点转换为文本节点。
- * 
- * @param childNodes - 子节点数组。
- * @returns 返回规范化后的节点数组。
+ *
+ * @param {any[]} childNodes - 子节点数组。
+ * @returns {Node[]} - 返回规范化后的节点数组。
  */
-export declare function normalizeChildNodes(
-childNodes: any[]
-): Node[];
+export declare function normalizeChildNodes(childNodes: any[]): Node[];
 
 /**
  * 创建一个支持双向绑定的数字输入框。
- * 
- * @param props - 配置对象，必须包含 number（BehaviorSubject<number>），其余为 <input> 元素属性。
- * @returns 创建的数字输入框元素。
- * @throws 如果 props 不是对象，或者 number 不是 BehaviorSubject 会抛出错误。
+ *
+ * `numberbox` 是一个自定义的输入框组件，支持通过 RxJS 的 `BehaviorSubject` 实现数字值的双向绑定。
+ * @public
+ * @param {{ number: BehaviorSubject<number>;  [key: string]: any;}} props - 配置对象，包含输入框的属性。
+ * @returns {HyperscriptInputElement} - 创建的数字输入框元素。
+ * @throws {Error} 如果 `props` 不是对象，或者 `number` 不是 `BehaviorSubject` 实例。
+ *
  */
 export declare function numberbox(props: {
     number: BehaviorSubject<number>;
     [key: string]: any;
-}): HyperscriptExtensions<HTMLInputElement>;
+}): HyperscriptInputElement_2;
 
 /**
  * ObservableArray 是一个可观察的数组，支持 insertBefore、removeChild、replaceChild 操作，
  * 并通过 RxJS Subject 通知变化，适用于响应式 DOM 操作场景。
+ *
+ * @template T
+ * @extends Array<T>
  */
-export declare class ObservableArray<T = any> extends Array<T> {
+export declare class ObservableArray<T> extends Array<T> {
+    /**
+     * @constructor 创建一个 ObservableArray 实例。禁止传参。
+     * @param {()=>T} newItem
+     * @throws {Error} 如果传入参数则抛出异常。
+     */
     constructor(newItem: () => T);
-
+    newitem: () => T;
     /**
      * 变化通知的 Subject。
-     * 事件元组类型: ['insertBefore', T, number] | ['removeChild', number] | ['replaceChild', T, number]
+     * @type {Subject<any[]>}
      */
-    action$: Subject<['insertBefore', T, number] | ['removeChild', number] | ['replaceChild', T, number]>;
-
+    action$: Subject<any[]>;
     /**
      * 插入元素事件流，发出 [item, index]。
+     * @type {import('rxjs').Observable<[T, number]>}
      */
     insertBefore$: Observable<[T, number]>;
-
     /**
      * 删除元素事件流，发出 index。
+     * @type {import('rxjs').Observable<number>}
      */
     removeChild$: Observable<number>;
-
     /**
      * 替换元素事件流，发出 [item, index]。
+     * @type {import('rxjs').Observable<[T, number]>}
      */
     replaceChild$: Observable<[T, number]>;
-
     /**
      * 在指定位置插入元素，并通知变化。
-     * @param item 要插入的元素
-     * @param index 插入位置，默认为数组末尾
+     * @param {T} item 要插入的元素
+     * @param {number} [index=this.length] 插入位置，默认为数组末尾
      */
     insertBefore(item: T, index?: number): void;
-
     /**
      * 删除指定位置的元素，并通知变化。
-     * @param index 删除位置，默认为数组末尾
+     * @param {number} [index=this.length-1] 删除位置，默认为数组末尾
      */
     removeChild(index?: number): void;
-
     /**
      * 替换指定位置的元素，并通知变化。
-     * @param item 新元素
-     * @param index 替换位置
+     * @param {T} item 新元素
+     * @param {number} index 替换位置
      */
     replaceChild(item: T, index: number): void;
-
     /**
      * 附加一个默认子元素
      */
     appendChild(): void;
 }
 
-export declare function ol(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLOListElement>;
-
-export declare function ol(...childNodes: any[]): HyperscriptExtensions<HTMLOListElement>;
-
-export declare function optgroup(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLOptGroupElement>;
-
-export declare function optgroup(...childNodes: any[]): HyperscriptExtensions<HTMLOptGroupElement>;
+export declare type ObservableTextNode = Text & {
+    subscription?: Subscription;
+    unsubscribe?: () => void;
+};
 
-export declare function option(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLOptionElement>;
+export declare type Observer<T> = Observer_2<T>;
 
-export declare function option(...childNodes: any[]): HyperscriptExtensions<HTMLOptionElement>;
+export declare function ol(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLOListElement>;
 
-export declare function output(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLOutputElement>;
+export declare function optgroup(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLOptGroupElement>;
 
-export declare function output(...childNodes: any[]): HyperscriptExtensions<HTMLOutputElement>;
+export declare function option(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLOptionElement>;
 
-export declare function p(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLParagraphElement>;
+export declare function output(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLOutputElement>;
 
-export declare function p(...childNodes: any[]): HyperscriptExtensions<HTMLParagraphElement>;
+export declare function p(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLParagraphElement>;
 
 /**
  * 解析 hyperscript 风格的参数，返回 props 和 childNodes。
- * 
- * @param args - hyperscript 风格的参数数组。
- * @returns 包含 props（对象）和 childNodes（数组）的对象。
+ *
+ * @param {any[]} args - hyperscript 风格的参数数组。
+ * @returns {{ props: Record<string, any>, childNodes: any[] }} 包含 props（对象）和 childNodes（数组）的对象。
  * @throws 如果参数不是数组会抛出错误。
  */
-export declare function parseHyperscriptArgs(
-args: any[]
-): { props: Record<string, any>, childNodes: any[] };
+export declare function parseHyperscriptArgs(args: any[]): {
+    props: Record<string, any>;
+    childNodes: any[];
+};
 
 /**
  * 解析嵌套的 DOM 属性路径，并返回目标对象和属性名。
- * 
- * @param props - 属性路径字符串，支持嵌套属性（如 "style.color"）。
- * @param obj - 起始对象，通常是一个 DOM 元素。
- * @returns [目标对象, 属性名]，如 [obj.style, "color"]。
- * @throws 如果路径中的某一级属性不存在或输入无效会抛出错误。
+ *
+ * @param {string} props - 属性路径，是 DOM API 的属性，不需要引号包裹，支持嵌套属性（如 "style.color"）。
+ * @param {Record<string, any>} obj - 起始对象，通常是一个 DOM 元素。
+ * @returns {[Record<string, any>, string]} - 返回一个数组，表示叶节点，其中第一个元素是目标对象，第二个元素是属性名。（如 [obj.style, "color"]）。
+ * @throws {Error} 如果路径中的某一级属性不存在或输入无效。
  */
-export declare function parsePropName(
-props: string,
-obj: Record<string, any>
-): [Record<string, any>, string];
+export declare function parsePropName(props: string, obj: Record<string, any>): [Record<string, any>, string];
 
 /**
- * 
- * 拾取对象中的 BehaviorSubject 值，作为叶子节点，忽略其他值。
- * 
- * @param model - 任意对象，内部递归查找 BehaviorSubject。
- * @returns 只包含 BehaviorSubject 当前值的对象或数组结构。
- * @throws 如果结构不符合预期会抛出错误。
- * 
+ *
+ * 拾取对象中的BehaviorSubject值，作爲葉子節點，忽略其他值。
+ *
+ * @param {Record<string|number,any> & { pickeys?: string [] }} model - 输入的数据结构，可以是对象、数组或BehaviorSubject
+ * @returns {Record<string|number,any>} - 返回只包含BehaviorSubject当前值的结构
+ * @throws {Error} 当输入不包含任何BehaviorSubject或结构不符合预期时抛出错误
  */
-export declare function pickBehaviorSubject(
-model: Record<string | number, any> & { pickeys?: string[] }
-): Record<string | number, any>;
+export declare function pickBehaviorSubject(model: Record<string | number, any> & {
+    pickeys?: string[];
+}): Record<string | number, any>;
 
-/**
- * 数据优先的管道处理工具（从左向右执行）。
- * 适合一次性数据处理流程。
- * @public
- * @param initialValue - 初始值。
- * @param fns - 要应用的函数管道（从左向右执行）。
- * @returns 经过管道处理后的结果。
- * @throws {TypeError} 当参数包含非函数时抛出错误。
- */
-export declare function pipe(
-initialValue: any,
-...fns: Array<(arg: any) => any>
-): any;
+export declare function pipe(initialValue: any, ...fns: ((arg: any) => any)[]): any;
 
 /**
  * 为指定的 DOM 元素订阅事件流，并通过 pipe 对事件流进行处理。
- * 
- * @param elem - 要订阅事件的 DOM 元素。
- * @returns 一个函数，接受事件名称和处理函数（接收事件流 Observable，返回 Subscription），用于订阅和处理事件，返回元素本身。
- * @throws 如果参数无效会抛出错误。
+ *
+ * @param {HTMLElement} elem - 要订阅事件的 DOM 元素。
+ * @returns {(e:string,s:(event$: Observable<Event>) => Subscription)=>HTMLElement} - 返回一个函数，该函数接受事件名称和处理函数，用于订阅和处理事件。
+ * @throws {Error} 如果参数无效。
  */
-export declare function pipeEvent(
-elem: HTMLElement
-): (
-event: string,
-subscriber: (event$: Observable<Event>) => Subscription
-) => HTMLElement;
+export declare function pipeEvent(elem: HTMLElement): (e: string, s: (event$: Observable<Event>) => Subscription) => HTMLElement;
 
 /**
- * 获取对象的嵌套属性。
- * 
- * @param obj - 源对象或数组。
- * @param keyPath - 属性访问路径数组。
- * @returns 路径对应的属性值。
- * @throws 当路径不存在时抛出 TypeError。
+ * 获取对象的嵌套属性
+ * @param {Record<string | number, any>} obj - 源对象/数组
+ * @param {(string|number)[]} keyPath - 属性访问路径数组
+ * @returns {any} 路径对应的属性值
+ * @throws {TypeError} 当路径不存在时抛出错误
  */
-export declare function pluckProperty(
-obj: Record<string | number, any>,
-keyPath: (string | number)[]
-): any;
-
-export declare function pre(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLPreElement>;
-
-export declare function pre(...childNodes: any[]): HyperscriptExtensions<HTMLPreElement>;
+export declare function pluckProperty(obj: Record<string | number, any>, keyPath: (string | number)[]): any;
 
-export declare function progress(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLProgressElement>;
+export declare function pre(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLPreElement>;
 
-export declare function progress(...childNodes: any[]): HyperscriptExtensions<HTMLProgressElement>;
+export declare function progress(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLProgressElement>;
 
-export declare function q(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLQuoteElement>;
-
-export declare function q(...childNodes: any[]): HyperscriptExtensions<HTMLQuoteElement>;
+export declare function q(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLQuoteElement>;
 
 /**
- * 将js对象序列化为 URL 查询字符串（?key=value&...），对象和数组字段会被序列化为字符串。
- * 
- * @param data - 需要序列化的普通对象（不能为数组或 null）。
- * @returns 查询字符串（如无有效字段则返回空字符串）。
- * @throws 如果输入不是普通对象会抛出错误。
+ * 将对象序列化为 URL 查询字符串（支持嵌套对象和多类型字段）。
+ *
+ * @public
+ * @param {Object} data - 要序列化的对象
+ * @returns {string} 查询字符串（如 "?a=1&b=2"），无有效字段时返回空字符串
  */
-export declare function queryStringify(data: Record<string, any>): string;
+export declare function queryStringify(data: Object): string;
 
 /**
- * 创建一个支持 RxJS 数据绑定的 <input type="radio"> 单选按钮。
- * 
- * @param props - 配置对象，必须包含 checked（BehaviorSubject<boolean>）。
- * @returns 创建的 <input type="radio"> 元素。
- * @throws 如果 props 不是对象，或者 checked 不是 BehaviorSubject 会抛出错误。
+ * 单选按钮
+ * @public
+ * @param {{checked: BehaviorSubject<boolean>; [key: string]: any}} props
+ * @returns {HyperscriptInputElement}
  */
 export declare function radio(props: {
-    checked: BehaviorSubject<boolean>,
-    [key: string]: any
-}): HyperscriptExtensions<HTMLInputElement>;
+    checked: BehaviorSubject<boolean>;
+    [key: string]: any;
+}): HyperscriptInputElement_2;
 
 /**
- * Creates an array of numbers from 0 to `length - 1`.
- * 
- * @param length - The length of the array to create.
- * @returns An array of numbers from 0 to `length - 1`.
+ * 创建一个从 0 到 length-1 的数字数组。
+ *
+ * @public
+ * @param {number} length - 要创建的数组长度
+ * @returns {number[]} - 从 0 到 length-1 的数字数组
  */
 export declare function rangeArray(length: number): number[];
 
-export declare function rb(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function rb(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function rb(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
 /**
- * 更新 ViewModel 为新值 src，递归同步 BehaviorSubject、ObservableArray、数组和对象的内容。
- * 
- * @param model - 需要更新的 ViewModel（可为 BehaviorSubject、ObservableArray、数组或对象）。
- * @param src - 新值，结构应与 model 对应。
- * @returns 返回更新后的 model。
+ * Updates a reactive model with new values from a source object.
+ * Recursively synchronizes BehaviorSubject, ObservableArray, array and object contents.
+ *
+ * @param {Record<string | number, any>} model - The reactive model to update (can be BehaviorSubject, ObservableArray, array or object)
+ * @param {Record<string | number, any>} src - The new values to restore, should match the structure of the model
+ * @returns
  */
-export declare function restore(
-model: Record<string | number, any>,
-src: Record<string | number, any>
-): Record<string | number, any>;
-
-export declare function rp(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function rp(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function restore(model: Record<string | number, any>, src: Record<string | number, any>): void;
 
-export declare function rt(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function rp(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
-export declare function rt(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function rt(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
-export declare function rtc(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function rtc(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
-export declare function rtc(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function ruby(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
-export declare function ruby(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function s(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
-export declare function ruby(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function samp(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
-export declare function s(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function s(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function samp(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function samp(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function section(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function section(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function section(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
 /**
- * 创建一个支持 RxJS 数据绑定的 <select> 元素（仅单选）。
- * 
- * @param props - 配置对象，包含 <select> 元素的属性，可选 selectedIndex/value（BehaviorSubject）。
- * @param options - 一个或多个 <option> 元素。
- * @returns 创建的 <select> 元素。
- * @throws 如果 props 不是对象，或者 selectedIndex/value 不是 BehaviorSubject 会抛出错误。
- */
-export declare function select(
-props: {
-    selectedIndex?: BehaviorSubject<number>,
-    value?: BehaviorSubject<string>,
-    [key: string]: any
-},
-...options: HTMLOptionElement[]
-): HyperscriptExtensions<HTMLSelectElement>;
-
-export declare function select(
-props: {
-    selectedIndex?: BehaviorSubject<number>,
-    value?: BehaviorSubject<string>,
-    [key: string]: any
-},
-options: HTMLOptionElement[]
-): HyperscriptExtensions<HTMLSelectElement>;
+ * 创建一个支持 RxJS 数据绑定的 <select> 元素。仅单选选择框。
+ *
+ * @param {{ selectedIndex?: BehaviorSubject<number>, value?: BehaviorSubject<string>, [key: string]: any }} props - 配置对象，包含 <select> 元素的属性。
+ * @param {...HTMLOptionElement} options - 一个或多个 <option> 元素，必须是 HTMLOptionElement 类型。
+ * @returns {HyperscriptSelectElement} - 创建的 <select> 元素。
+ * @throws {Error} 如果 `props` 不是对象，或者 `selectedIndex` 或 `value` 不是 BehaviorSubject。
+ */
+export declare function select(props: {
+    selectedIndex?: BehaviorSubject<number>;
+    value?: BehaviorSubject<string>;
+    [key: string]: any;
+}, ...options: HTMLOptionElement[]): HyperscriptSelectElement_2;
 
 /**
- * 设置一个元素对象的任意嵌套路径属性的值。
- * 如果是 CSS 类名，值为真则添加类名，值为假则移除类名。
- * 如果是普通属性或嵌套属性则设置该属性值。
- * 
- * @param root - 要设置属性的 DOM 元素。
- * @param key - 属性名称，支持普通属性、嵌套属性（如 "style.color"）或以 "." 开头的类名（如 ".active"）。
- * @param value - 要设置的属性值。如果是布尔值，用于控制类名的添加或移除。
- * @returns 返回元素本身，支持链式调用。
- * @throws 如果参数无效或设置失败会抛出错误。
+ *
+ * 设置一个元素对象的任意嵌套路径属性的值，如果是CSS类名，值为真则添加类名，值为假则移除类名。如果是普通属性或嵌套属性则设置改属性值。
+ *
+ * @param {HTMLElement} root - 要设置属性的 DOM 元素。
+ * @param {string} key - 属性名称，支持普通属性、嵌套属性（如 "style.color"）或以 "." 开头的类名（如 ".active"）。
+ * @param {*} value - 要设置的属性值。如果是布尔值，用于控制类名的添加或移除。
+ * @returns {HTMLElement} - 返回元素本身，支持链式调用。
+ * @throws {Error} 如果参数无效或设置失败。
+ *
  */
-export declare function setProp(
-root: HTMLElement,
-key: string,
-value: any
-): HTMLElement;
+export declare function setProp(root: HTMLElement, key: string, value: any): HTMLElement;
 
 /**
  * 为 DOM 元素设置属性，包括静态属性和动态属性（Observable）。
- * 
- * @param element - 要设置属性的 DOM 元素。
- * @param props - 包含属性键值对的对象，其中值可以是普通值或 Observable。
- * @returns 返回元素本身，支持链式调用。
- * @throws 如果参数无效或设置属性失败会抛出错误。
+ *
+ * @param {HTMLElement} element - 要设置属性的 DOM 元素。
+ * @param {Object} props - 包含属性键值对的对象，其中值可以是普通值或 Observable。
+ * @returns {HTMLElement} - 返回元素本身，支持链式调用。
+ * @throws {Error} 如果参数无效或设置属性失败。
  */
-export declare function setProps(
-element: HTMLElement,
-props: Record<string, any | Observable<any>>
-): HTMLElement;
-
-export declare function small(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function setProps(element: HTMLElement, props: Object): HTMLElement;
 
-export declare function small(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function small(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
-export declare function span(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLSpanElement>;
-
-export declare function span(...childNodes: any[]): HyperscriptExtensions<HTMLSpanElement>;
+export declare function span(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLSpanElement>;
 
 /**
  * 将对象属性按类型分为两部分：可观察对象（Observable）与普通值（非 Observable）。
- * 
- * @param obj - 要分割的对象，其属性值可能是 Observable 或普通值。
- * @returns 一个数组，第一个对象包含所有 Observable 属性，第二个对象包含所有非 Observable 属性。
- * @throws 如果参数不是一个非空对象会抛出错误。
+ *
+ * @param {Record<string,any>} obj - 要分割的对象，其属性值可能是 Observable 或普通值。
+ * @returns {[Record<string, Observable<any>>, Record<string, any>]} - 返回一个数组，第一个对象包含所有 Observable 属性，第二个对象包含所有非 Observable 属性。
+ * @throws {Error} 如果参数不是一个非空对象。
  */
-export declare function splitObjectByObservable(
-obj: Record<string, any>
-): [Record<string, Observable<any>>, Record<string, any>];
-
-export declare function strong(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function splitObjectByObservable(obj: Record<string, any>): [Record<string, Observable<any>>, Record<string, any>];
 
-export declare function strong(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function strong(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
-export declare function sub(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function sub(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function sub(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
+/**
+ * @template T
+ * @typedef { import('rxjs').Observer<T> } Observer
+ */
 /**
  * 为指定的 DOM 元素订阅事件流，并将订阅与元素绑定，便于管理。
- * 
- * @param elem - 要订阅事件的 DOM 元素。
- * @returns 一个函数，接受事件名称和观察者（函数或观察者对象），用于订阅事件，返回元素本身。
- * @throws 如果参数无效会抛出错误。
+ *
+ * @param {HTMLElement} elem - 要订阅事件的 DOM 元素。
+ * @returns {(e:string, o:((value: Event) => void) | Partial<Observer<Event>>) => HTMLElement} - 返回一个函数，该函数接受事件名称和观察者，用于订阅事件。
+ * @throws {Error} 如果参数无效。
+ *
  */
-export declare function subscribeEvent(
-elem: HTMLElement
-): (
-event: string,
-observer: ((value: Event) => void) | Partial<Observer<Event>>
-) => HTMLElement;
+export declare function subscribeEvent(elem: HTMLElement): (e: string, o: ((value: Event) => void) | Partial<Observer<Event>>) => HTMLElement;
 
 /**
- * 订阅一个 Observable，将其发出的值动态设置为指定 DOM 元素的属性值。
- * 
- * @param element - 要设置属性的 DOM 元素。
- * @param key - 属性名称，支持普通属性、嵌套属性（如 "style.color"）或以 "." 开头的类名（如 ".active"）。
- * @param value$ - 一个 RxJS Observable ，用于发出属性值。
- * @returns 返回元素本身，支持链式调用。
- * @throws 如果参数无效或订阅失败会抛出错误。
+ *
+ * 订阅一个 BehaviorSubject，将其发出的值动态设置为指定 DOM 元素的属性值。
+ *
+ * @template T
+ * @param {HTMLElement} element - 要设置属性的 DOM 元素。
+ * @param {string} key - 属性名称，支持普通属性、嵌套属性（如 "style.color"）或以 "." 开头的类名（如 ".active"）。
+ * @param {Observable<T>} value$ - 一个 RxJS Observable ，用于发出属性值。
+ * @returns {HTMLElement} - 返回元素本身，支持链式调用。
+ * @throws {Error} 如果参数无效或订阅失败。
  */
-export declare function subscribeProp(
-element: HTMLElement,
-key: string,
-value$: Observable<any>
-): HTMLElement;
-
-export declare function summary(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function summary(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function subscribeProp<T>(element: HTMLElement, key: string, value$: Observable<T>): HTMLElement;
 
-export declare function sup(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function summary(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
-export declare function sup(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function sup(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
 /**
  * 创建静态选项卡组件。
- * 
- * @param props - 选项卡组件的属性，必须包含 tabIndex（BehaviorSubject<number>），可选 rootProps。
- * @param tabs - 导航按钮的内容数组，可以是字符串或 HTML 元素。
- * @param panels - 内容面板的内容数组，可以是字符串或 HTML 元素。
- * @returns 返回一个包含导航栏和内容面板的选项卡组件。
+ *
+ * `tabControl` 函数生成一个静态选项卡组件，其中选项卡的数量和顺序是固定的。
+ * 每个选项卡由一个导航按钮和一个对应的内容面板组成。
+ *
+ * @param {{ tabIndex: BehaviorSubject<number>, [key: string]: any}} props - 选项卡组件的属性。
+ * @param {Array<string|HTMLElement>} tabs - 导航按钮的内容数组，可以是字符串或 HTML 元素。
+ * @param {Array<string|HTMLElement>} panels - 内容面板的内容数组，可以是字符串或 HTML 元素。
+ * @returns {HTMLElement} - 返回一个包含导航栏和内容面板的选项卡组件。
  */
-export declare function tabControl(
-props: {
-    tabIndex: BehaviorSubject<number>,
-    [key: string]: any
-},
-tabs: Array<string | HTMLElement>,
-panels: Array<string | HTMLElement>
-): HTMLElement;
-
-export declare function table(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLTableElement>;
+export declare function tabControl(props: {
+    tabIndex: BehaviorSubject<number>;
+    [key: string]: any;
+}, tabs: Array<string | HTMLElement>, panels: Array<string | HTMLElement>): HTMLElement;
 
-export declare function table(...childNodes: any[]): HyperscriptExtensions<HTMLTableElement>;
+export declare function table(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLTableElement>;
 
 /**
  * 选项卡的导航按钮。
- * 
- * @param source - 按钮的内容，可以是字符串或 HTML 元素。
- * @returns 返回一个带有 `nav-item` 样式类的 <li> 元素，内部包含一个按钮。
+ *
+ * `tabNavItem` 函数生成一个选项卡的导航按钮，通常用于选项卡的导航栏中。
+ *
+ * @param {...(string|HTMLElement)} source - 按钮的内容，可以是字符串或 HTML 元素。
+ * @returns {HTMLElement} - 返回一个带有 `nav-item` 样式类的 `<li>` 元素，内部包含一个按钮。
+ *
  */
-export declare function tabNavItem(
-...source: (string | HTMLElement)[]
-): HTMLElement;
+export declare function tabNavItem(...source: (string | HTMLElement)[]): HTMLElement;
 
 /**
  * 选项卡的内容面板。
- * 
- * @param source - 面板的内容，可以是字符串或 HTML 元素。
- * @returns 返回一个带有 `tab-pane` 样式类的 <div> 元素。
+ *
+ * `tabPanel` 函数生成一个选项卡的内容区域，用于显示与选项卡对应的内容。
+ *
+ * @param {...(string|HTMLElement)} source - 面板的内容，可以是字符串或 HTML 元素。
+ * @returns {HTMLElement} - 返回一个带有 `tab-pane` 样式类的 `<div>` 元素。
+ *
  */
-export declare function tabPanel(
-...source: (string | HTMLElement)[]
-): HTMLElement;
+export declare function tabPanel(...source: (string | HTMLElement)[]): HTMLElement;
 
 /**
  * 选项卡组件的基础框架。
- * 
- * @param props - 传递给根容器 <div> 的属性（如 id、className 等）。
- * @returns 返回一个包含导航栏和内容面板的 <div> 元素。
+ *
+ * `tabRoot` 函数生成一个包含导航栏和内容面板的容器结构，
+ * 用于构建选项卡组件的基础部分。
+ *
+ * @param {Object} props - 传递给根容器 `<div>` 的属性（如 `id`、`className` 等）。
+ * @returns {HTMLElement} - 返回一个包含导航栏和内容面板的 `<div>` 元素。
+ *
  */
-export declare function tabRoot(props: { [key: string]: any }): HTMLElement;
-
-export declare function tbody(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLTableSectionElement>;
+export declare function tabRoot(props: Object): HTMLElement;
 
-export declare function tbody(...childNodes: any[]): HyperscriptExtensions<HTMLTableSectionElement>;
+export declare function tbody(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLTableSectionElement>;
 
-export declare function td(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLTableCellElement>;
-
-export declare function td(...childNodes: any[]): HyperscriptExtensions<HTMLTableCellElement>;
+export declare function td(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLTableCellElement>;
 
 /**
  * 创建一个支持 RxJS 数据绑定的 <textarea> 元素。
- * 
- * @param props - 配置对象，包含 <textarea> 元素的属性，必须包含 value（BehaviorSubject<string>）。
- * @returns 创建的 <textarea> 元素。
- * @throws 如果 props 不是对象，或者 value 不是 BehaviorSubject 会抛出错误。
- */
-export declare function textarea(
-props: {
-    value: BehaviorSubject<string>,
-    [key: string]: any
-}
-): HyperscriptExtensions<HTMLTextAreaElement>;
+ *
+ * @param {{value:BehaviorSubject<string>, [key:string]:any}} props - 配置对象，包含 <textarea> 元素的属性。
+ * @returns {HyperscriptTextAreaElement} - 创建的 <textarea> 元素。
+ * @throws {Error} 如果 `props` 不是对象，或者 `value` 不是 BehaviorSubject。
+ */
+export declare function textarea(props: {
+    value: BehaviorSubject<string>;
+    [key: string]: any;
+}): HyperscriptTextAreaElement;
 
 /**
  * 创建一个支持 RxJS 数据绑定的 <input type="text"> 元素。
- * 
- * @param props - 配置对象，包含 <input> 元素的属性，必须包含 value（BehaviorSubject<string>）。
- * @returns 创建的 <input type="text"> 元素。
- * @throws 如果 props 不是对象，或者 value 不是 BehaviorSubject 会抛出错误。
+ *
+ * @param {{value: BehaviorSubject<string>, [key: string]: any}} props - 配置对象，包含 <input> 元素的属性。
+ * @returns {HyperscriptInputElement} - 创建的 <input type="text"> 元素。
+ * @throws {Error} 如果 `props` 不是对象，或者 `value` 不是 BehaviorSubject。
  */
 export declare function textbox(props: {
-    value: BehaviorSubject<string>,
-    [key: string]: any
-}): HyperscriptExtensions<HTMLInputElement>;
+    value: BehaviorSubject<string>;
+    [key: string]: any;
+}): HyperscriptInputElement_2;
 
 /**
- * 创建一个文本节点，支持静态文本和基于 Observable 的动态文本。
- * 
- * @param text - Observable<any> | any。
- * @returns 文本节点，若为动态文本节点则带有 unsubscribe 方法。
+ * @typedef {Text & {subscription?: Subscription, unsubscribe?: ()=>void}} ObservableTextNode
  */
-export declare function textNode(
-text: any
-): Text & { subscription?: Subscription, unsubscribe?: () => void };
-
-export declare function tfoot(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLTableSectionElement>;
-
-export declare function tfoot(...childNodes: any[]): HyperscriptExtensions<HTMLTableSectionElement>;
-
-export declare function th(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLTableCellElement>;
-
-export declare function th(...childNodes: any[]): HyperscriptExtensions<HTMLTableCellElement>;
+/**
+ * 创建一个文本节点。
+ * 支持静态文本和动态更新的文本（通过 RxJS Observable）。
+ *
+ * - 如果传入的是字符串，则创建一个静态文本节点。
+ * - 如果传入的是 RxJS Observable，则创建一个动态文本节点，并根据 Observable 的值实时更新文本内容。
+ * - 动态文本节点支持通过 `unsubscribe` 方法取消订阅。
+ *
+ * @param {any} text Observable<any> | any。
+ * @returns {ObservableTextNode}
+ *
+ */
+export declare function textNode(text: any): ObservableTextNode;
 
-export declare function thead(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLTableSectionElement>;
+export declare function tfoot(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLTableSectionElement>;
 
-export declare function thead(...childNodes: any[]): HyperscriptExtensions<HTMLTableSectionElement>;
+export declare function th(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLTableCellElement>;
 
-export declare function time(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLTimeElement>;
+export declare function thead(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLTableSectionElement>;
 
-export declare function time(...childNodes: any[]): HyperscriptExtensions<HTMLTimeElement>;
+export declare function time(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLTimeElement>;
 
 /**
  * 将扁平化的键值对数组转换为嵌套的 JavaScript 对象或数组。
  *
- * @param flatEntries - 扁平化的键值对数组。每个元素为 [keyPath, value]，keyPath 是 (string | number)[]。
- * @returns 嵌套的对象或数组。
+ * @param {[ (string | number)[], any ][]} flatEntries - 扁平化的键值对数组。
+ * 每个键值对的格式为 `[keyPath, value]`，其中 `keyPath` 是一个表示嵌套路径的数组。假设输入的键值对数组已经按照键路径（keyPath）排好顺序。
+ * @returns {Record<string|number, any>} - 返回嵌套的 JavaScript 对象或数组。
+ *
  */
-export declare function tojs(
-flatEntries: [ (string | number)[], any ][]
-): Record<string|number, any>;
-
-export declare function tr(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLTableRowElement>;
-
-export declare function tr(...childNodes: any[]): HyperscriptExtensions<HTMLTableRowElement>;
+export declare function tojs(flatEntries: [(string | number)[], any][]): Record<string | number, any>;
 
-export declare function track(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLTrackElement>;
+export declare function tr(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLTableRowElement>;
 
-export declare function track(...childNodes: any[]): HyperscriptExtensions<HTMLTrackElement>;
+export declare function track(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLTrackElement>;
 
-export declare function tt(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function tt(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
-export declare function tt(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-/**
- * JavaScript 基本数据类型名称数组
- * typeof 返回的所有类型字符串
- */
 export declare const types: string[];
 
-export declare function u(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function u(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function ul(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLUListElement>;
+export declare function u(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
-export declare function ul(...childNodes: any[]): HyperscriptExtensions<HTMLUListElement>;
+export declare function ul(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLUListElement>;
 
 /**
  * 通过不断调用 fn 生成值，直到 fn 返回 falsy。
+ *
  * @public
- * @param fn - 生成函数，接收当前 seed，返回 [value, nextSeed] 或 falsy。
- * @param seed - 初始种子值。
- * @returns 由 fn 生成的所有 value 组成的数组。
+ * @template T, S
+ * @param {(seed: S) => [T, S] | false | null | undefined} fn - 生成函数，接收当前 seed，返回 [value, nextSeed] 或 falsy。
+ * @param {S} seed - 初始种子值。
+ * @returns {Array<T>} 由 fn 生成的所有 value 组成的数组。
+ * @this *
  */
-export declare function unfold<T, S>(
-fn: (seed: S) => [T, S] | false | null | undefined,
-seed: S
-): T[];
+export declare function unfold<T, S>(this: any, fn: (seed: S) => [T, S] | false | null | undefined, seed: S): Array<T>;
 
 /**
- * 将任意值序列化为“无引号 JSON”格式的字符串。
- * 
- * @param value - 需要序列化的任意值。
- * @returns 无引号 JSON 格式的字符串。
+ * 将任意 JS 值序列化为“无引号 JSON”字符串（仅对键名和部分字符串值去引号）。
+ *
+ * @public
+ * @param {*} value - 要序列化的值
+ * @returns {string} 序列化后的字符串
  */
 export declare function unquotedJsonStringify(value: any): string;
 
 /**
- * unwraps an array of arguments simply. If the array contains a single element that is itself an array,
- * it unwraps and returns that element. Otherwise, it returns the original array.
- * 
- * @param args - The array of arguments to process.
- * @returns The unwrapped array if the input is a single array, otherwise the original array.
+ * 简易unwrap参数数组。如果子节点是单个数组，则解构为子节点，否则返回原数组。
+ *
+ * @template T
+ * @param {(T|T[])[]} args - 子节点数组。
+ * @returns {T[]} - 解构后的子节点数组。
  */
-export declare function unwrapArgs<T>(
-args: (T|T[])[]
-): T[];
+export declare function unwrapArgs<T>(args: (T | T[])[]): T[];
 
-export declare function video(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLVideoElement>;
+export declare function video(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLVideoElement>;
 
-export declare function video(...childNodes: any[]): HyperscriptExtensions<HTMLVideoElement>;
-
-export declare function wbr(props: { [_: string]: any }, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
-
-export declare function wbr(...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+export declare function wbr(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
 
 /**
- * Combines two arrays into an array of tuples.
- * 
- * - If the arrays have different lengths, the longer array will be truncated to match the length of the shorter array.
- * 
- * @param a - The first array.
- * @param b - The second array.
- * @returns An array of tuples, where each tuple contains one element from `a` and one from `b`.
- * @throws Will throw an error if either `a` or `b` is not an array.
+ * 合并两个数组为一个元组数组。
+ *
+ * 如果数组长度不同，将以较长的数组为基准，短数组对应位置为 undefined。
+ *
+ * @public
+ * @template T, U
+ * @param {T[]} a - 第一个数组
+ * @param {U[]} b - 第二个数组
+ * @returns {Array<[T, U]>} - 合并后的元组数组
+ * @throws {Error} 如果 a 或 b 不是数组
  */
-export declare function zipArray<T, U>(a: T[], b: U[]): [T, U][];
+export declare function zipArray<T, U>(a: T[], b: U[]): Array<[T, U]>;
 
 export { }