hyperscript-rxjs 1.3.15 → 1.3.17

package/dist/hyperscript-rxjs.d.ts

@@ -0,0 +1,1438 @@
+import { BehaviorSubject } from 'rxjs';
+import { HyperscriptExtensions as HyperscriptExtensions_2 } from './HyperscriptExtensions.d.ts';
+import { Observable } 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 abbr(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+
+export declare function address(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+
+/**
+ * @template T
+ * @param {Array<T>} array - 要处理的原数组
+ * @param {number} n - 要取出的元素个数
+ * @returns {[Array<T>, Array<T>]} - [已取出的元素数组, 剩余元素数组]
+ */
+export declare function advance<T>(array: Array<T>, n: number): [Array<T>, Array<T>];
+
+export declare function area(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLAreaElement>;
+
+/**
+ * insert a element at position in place.
+ * @param {any} array
+ * @param {any} item
+ * @param {any} index
+ */
+export declare function arrayInsert(array: any, item: any, index?: any): void;
+
+/**
+ * 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 aside(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+
+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 b(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+
+export declare function bdi(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+
+export declare function bdo(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+
+/**
+ * 绑定选项卡的激活状态到 `tabIndex`。
+ *
+ * `bindTabIndex` 函数将选项卡的导航按钮和内容面板与 `tabIndex` 绑定，
+ * 实现动态切换选项卡的功能。
+ *
+ * @param {HTMLElement} tabRoot - 选项卡的根容器，包含导航栏和内容面板。
+ * @param {BehaviorSubject<number>} tabIndex$ - 表示当前激活选项卡索引的 BehaviorSubject。
+ *
+ */
+export declare function bindTabIndex(tabRoot: HTMLElement, tabIndex$: BehaviorSubject<number>): void;
+
+/**
+ * 一个包含所有 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 br(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLBRElement>;
+
+export declare function button(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLButtonElement>;
+
+export declare function caption(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+
+/**
+ * @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;
+}): HyperscriptInputElement;
+
+/**
+ * @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 code(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+
+export declare function col(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLTableColElement>;
+
+export declare function colgroup(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLTableColElement>;
+
+/**
+ * 显示或隐藏包含的元素。
+ *
+ * `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[];
+
+/**
+ * 比较两个日期对象的大小。
+ *
+ * @public
+ * @param {Date} a - 第一个日期
+ * @param {Date} b - 第二个日期
+ * @returns {number} 如果 a > b 返回正数，a < b 返回负数，相等返回 0
+ */
+export declare function compareDate(a: Date, b: Date): number;
+
+/**
+ * 比较两个 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([keypath1]: [(number | string)[], any], [keypath2]: [(number | string)[], any]): number;
+
+/**
+ *
+ * Compares two values and returns a number indicating their relative order.
+ * @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;
+
+/**
+ * 比较两个 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;
+
+/**
+ * 可以比较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 {T[]} array - 要排序的数组
+     * @returns {T[]} 排序后的数组
+     */
+    sort(array: T[]): T[];
+    /**
+     * 移除数组中的重复值。
+     * @param {T[]} array - 要处理的数组
+     * @returns {T[]} 去重后的新数组
+     */
+    distinct(array: T[]): T[];
+    /**
+     * 将已排序的数组转为集合（去重）。
+     * @param {T[]} array - 已排序的数组
+     * @returns {T[]} 唯一元素数组
+     */
+    sortedArrayToSet(array: T[]): T[];
+    /**
+     * 根据 getKey 生成的 key 对数组元素分组。
+     * @template U
+     * @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 {[T,V][]} array - 已排序的数组
+     * @returns {[T, V[]][]} 分组结果
+     */
+    groupSortedEntries<V>(array: [T, V][]): [T, V[]][];
+    /**
+     * 计算两个数组的差集。数组元素是升序排列
+     * @param {T[]} array1 - 第一个数组
+     * @param {T[]} array2 - 第二个数组
+     * @returns {T[]} array1 中有而 array2 中没有的元素
+     */
+    differenceSet(array1: T[], array2: T[]): T[];
+    /**
+     * 计算两个数组的交集。
+     * @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 {T[]} array1 - 第一个数组
+     * @param {T[]} array2 - 第二个数组
+     * @returns {boolean} 如果集合相等返回 true，否则返回 false
+     */
+    isEqualset(array1: T[], array2: T[]): boolean;
+    /**
+     * 判断第一个数组是否为第二个数组的子集。
+     * @param {T[]} array1 - 第一个数组
+     * @param {T[]} array2 - 第二个数组
+     * @returns {boolean} 如果 array1 是 array2 的子集返回 true，否则返回 false
+     */
+    isSubset(array1: T[], array2: T[]): boolean;
+    /**
+     * 判断第一个数组是否为第二个数组的超集。
+     * @param {T[]} array1 - 第一个数组
+     * @param {T[]} array2 - 第二个数组
+     * @returns {boolean} 如果 array1 是 array2 的超集返回 true，否则返回 false
+     */
+    isSuperset(array1: T[], array2: T[]): boolean;
+}
+
+export declare function compose(...fns: ((arg: any) => any)[]): (arg: any) => any;
+
+export declare function cond(branches: Array<Function | [Function, Function]>): (...args: any[]) => any;
+
+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 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][]);
+    _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;
+    /**
+     * @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 {[(string | number)[], T][]} entries
+     * @returns
+     */
+    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]>;
+}
+
+/**
+ * 默认比较函数，适用于可比较的基本类型。
+ *
+ * @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;
+
+export declare const defaultComparer: Comparer<any>;
+
+export declare function del(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLModElement>;
+
+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 dialog(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLDialogElement>;
+
+export declare function div(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLDivElement>;
+
+export declare function dl(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLDListElement>;
+
+export declare function dt(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+
+export declare function em(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+
+export declare const entryComparer: Comparer<[(string | number)[], any]>;
+
+/**
+ * 从扁平化的数据集构建嵌套的 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 figcaption(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+
+export declare function figure(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+
+/**
+ * 查找数组中最后一个满足条件的元素索引。
+ *
+ * @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 flat(data: any, isLeaf?: (value: any, key: string | number, keyPath: (string | number)[]) => boolean): [(string | number)[], any][];
+
+/**
+ * 动态切换两个元素或元素数组的显示状态。
+ *
+ * `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[];
+
+/**
+ * 通用折叠（递归归约）函数。
+ *
+ * @public
+ * @param {(this:any, acc: any, seed: any) => [*, *]|[any]|[]|null|undefined} fn - 处理函数，返回 [新acc, 新seed] 或 [新acc]
+ * @param {*} acc - 初始累加值
+ * @param {*} seed - 初始种子
+ * @returns {*} 折叠后的结果
+ * @this *
+ */
+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 form(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLFormElement>;
+
+/**
+ * 用途：插入一组元素，不必使用循环语句，fragment 用后即弃。
+ *
+ * @param {...Node|Node[]} childNodes - 要插入的子节点，可以是单个节点、多个节点或节点数组。
+ * @returns {DocumentFragment} - 返回包含所有子节点的 DocumentFragment。
+ * @throws {Error} 如果传入的子节点不是有效的 DOM 节点。
+ */
+export declare function fragment(...childNodes: (Node | Node[])[]): DocumentFragment;
+
+/**
+ * 获取 HTML 元素的默认 CSS `display` 值。
+ *
+ * 根据元素的标签名称 (`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 {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;
+
+/**
+ * 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 h2(props?: {
+    [_: string]: any;
+}, ...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 h5(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLHeadingElement>;
+
+export declare function h6(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLHeadingElement>;
+
+export declare function header(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+
+export declare function hgroup(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+
+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 {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[]): HyperscriptElement;
+
+export declare type HyperscriptElement = HyperscriptExtensions_2<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_3<T>;
+
+    subscribeEvent(
+    event: string,
+    observer: ((value: Event) => void) | Partial<Observer_2<Event>>
+    ): HyperscriptExtensions_3<T>;
+
+    unsubscribe(): void;
+
+    subscription?: Subscription;
+
+};
+
+export declare type HyperscriptInputElement = HyperscriptExtensions_2<HTMLInputElement>;
+
+declare type HyperscriptInputElement_2 = HyperscriptExtensions_3<HTMLInputElement>;
+
+export declare type HyperscriptSelectElement = HyperscriptExtensions_2<HTMLSelectElement>;
+
+declare type HyperscriptSelectElement_2 = HyperscriptExtensions_3<HTMLSelectElement>;
+
+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 中的一类元素，它们不会独占一行，通常用于包裹文本或其他内联元素。
+ * 该集合中的标签名称均为大写，便于快速判断某个元素是否为内联元素。
+ *
+ * 常见的内联元素包括：
+ * - 文本样式：`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 ins(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLModElement>;
+
+/**
+ * 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 isEmptyObject(obj: unknown): obj is Record<never, never>;
+
+/**
+ * 检查一个值是否是普通对象（Plain Object）
+ * @param {unknown} value - 要检查的值
+ * @returns {value is object} - 返回是否是普通对象的类型谓词
+ */
+export declare function isPlainObject(value: unknown): value is object;
+
+/**
+ * 判断输入的字符串数组是否为从0开始的连续数字区间（如 ['0','1','2',...])。
+ *
+ * @public
+ * @param {string[]} keys - 要检查的字符串数组
+ * @returns {boolean} - 如果是从0开始的连续数字区间返回 true，否则返回 false
+ */
+export declare function isRange(keys: string[]): boolean;
+
+/**
+ * 检查对象是否为 RxJS 类型。
+ *
+ * `isRxType` 函数用于判断给定的对象是否为 RxJS 的 `Observable` 或 `Subscription` 类型。
+ *
+ * @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 const keyComparer: Comparer<string | number>;
+
+export declare const keyPathComparer: Comparer<(string | number)[]>;
+
+export declare function label(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLLabelElement>;
+
+export declare function legend(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLLegendElement>;
+
+export declare function li(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLLIElement>;
+
+export declare function main(props?: {
+    [_: string]: any;
+}, ...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 menuitem(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+
+export declare function meter(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLMeterElement>;
+
+/**
+ * @typedef {import("./HyperscriptExtensions.d.ts").HyperscriptExtensions<HTMLSelectElement>} HyperscriptSelectElement
+ */
+/**
+ * 创建一个支持多选功能的 <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(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+
+/**
+ *
+ * @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>>;
+
+/**
+ *
+ * @param {Record<string|number, any>} model
+ * @returns {Observable<[(string | number)[], any]>}
+ */
+export declare function nestedMerge(model: Record<string | number, any>): Observable<[(string | number)[], any]>;
+
+/**
+ * 规范化子节点，将非节点转换为文本节点。
+ *
+ * @param {any[]} childNodes - 子节点数组。
+ * @returns {Node[]} - 返回规范化后的节点数组。
+ */
+export declare function normalizeChildNodes(childNodes: any[]): Node[];
+
+/**
+ * 创建一个支持双向绑定的数字输入框。
+ *
+ * `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;
+}): HyperscriptInputElement_2;
+
+/**
+ * ObservableArray 是一个可观察的数组，支持 insertBefore、removeChild、replaceChild 操作，
+ * 并通过 RxJS Subject 通知变化，适用于响应式 DOM 操作场景。
+ *
+ * @template T
+ * @extends Array<T>
+ */
+export declare class ObservableArray<T> extends Array<T> {
+    /**
+     * @constructor 创建一个 ObservableArray 实例。禁止传参。
+     * @param {()=>T} newItem
+     * @throws {Error} 如果传入参数则抛出异常。
+     */
+    constructor(newItem: () => T);
+    newitem: () => T;
+    /**
+     * 变化通知的 Subject。
+     * @type {Subject<any[]>}
+     */
+    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 {T} item 要插入的元素
+     * @param {number} [index=this.length] 插入位置，默认为数组末尾
+     */
+    insertBefore(item: T, index?: number): void;
+    /**
+     * 删除指定位置的元素，并通知变化。
+     * @param {number} [index=this.length-1] 删除位置，默认为数组末尾
+     */
+    removeChild(index?: number): void;
+    /**
+     * 替换指定位置的元素，并通知变化。
+     * @param {T} item 新元素
+     * @param {number} index 替换位置
+     */
+    replaceChild(item: T, index: number): void;
+    /**
+     * 附加一个默认子元素
+     */
+    appendChild(): void;
+}
+
+export declare type ObservableTextNode = Text & {
+    subscription?: Subscription;
+    unsubscribe?: () => void;
+};
+
+export declare type Observer<T> = Observer_2<T>;
+
+export declare function ol(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLOListElement>;
+
+export declare function optgroup(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLOptGroupElement>;
+
+export declare function option(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLOptionElement>;
+
+export declare function output(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLOutputElement>;
+
+export declare function p(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLParagraphElement>;
+
+/**
+ * 解析 hyperscript 风格的参数，返回 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[];
+};
+
+/**
+ * 解析嵌套的 DOM 属性路径，并返回目标对象和属性名。
+ *
+ * @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];
+
+/**
+ *
+ * 拾取对象中的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 pipe(initialValue: any, ...fns: ((arg: any) => any)[]): any;
+
+/**
+ * 为指定的 DOM 元素订阅事件流，并通过 pipe 对事件流进行处理。
+ *
+ * @param {HTMLElement} elem - 要订阅事件的 DOM 元素。
+ * @returns {(e:string,s:(event$: Observable<Event>) => Subscription)=>HTMLElement} - 返回一个函数，该函数接受事件名称和处理函数，用于订阅和处理事件。
+ * @throws {Error} 如果参数无效。
+ */
+export declare function pipeEvent(elem: HTMLElement): (e: string, s: (event$: Observable<Event>) => Subscription) => HTMLElement;
+
+/**
+ * 获取对象的嵌套属性
+ * @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 progress(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLProgressElement>;
+
+export declare function q(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLQuoteElement>;
+
+/**
+ * 将对象序列化为 URL 查询字符串（支持嵌套对象和多类型字段）。
+ *
+ * @public
+ * @param {Object} data - 要序列化的对象
+ * @returns {string} 查询字符串（如 "?a=1&b=2"），无有效字段时返回空字符串
+ */
+export declare function queryStringify(data: Object): string;
+
+/**
+ * 单选按钮
+ * @public
+ * @param {{checked: BehaviorSubject<boolean>; [key: string]: any}} props
+ * @returns {HyperscriptInputElement}
+ */
+export declare function radio(props: {
+    checked: BehaviorSubject<boolean>;
+    [key: string]: any;
+}): HyperscriptInputElement_2;
+
+/**
+ * 创建一个从 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>;
+
+/**
+ * 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>): void;
+
+export declare function rp(props?: {
+    [_: string]: any;
+}, ...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 ruby(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+
+export declare function s(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+
+export declare function samp(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+
+export declare function section(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+
+/**
+ * 创建一个支持 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 {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;
+
+/**
+ * 为 DOM 元素设置属性，包括静态属性和动态属性（Observable）。
+ *
+ * @param {HTMLElement} element - 要设置属性的 DOM 元素。
+ * @param {Object} props - 包含属性键值对的对象，其中值可以是普通值或 Observable。
+ * @returns {HTMLElement} - 返回元素本身，支持链式调用。
+ * @throws {Error} 如果参数无效或设置属性失败。
+ */
+export declare function setProps(element: HTMLElement, props: Object): HTMLElement;
+
+export declare function small(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+
+export declare function span(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLSpanElement>;
+
+/**
+ * 将对象属性按类型分为两部分：可观察对象（Observable）与普通值（非 Observable）。
+ *
+ * @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 sub(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+
+/**
+ * @template T
+ * @typedef { import('rxjs').Observer<T> } Observer
+ */
+/**
+ * 为指定的 DOM 元素订阅事件流，并将订阅与元素绑定，便于管理。
+ *
+ * @param {HTMLElement} elem - 要订阅事件的 DOM 元素。
+ * @returns {(e:string, o:((value: Event) => void) | Partial<Observer<Event>>) => HTMLElement} - 返回一个函数，该函数接受事件名称和观察者，用于订阅事件。
+ * @throws {Error} 如果参数无效。
+ *
+ */
+export declare function subscribeEvent(elem: HTMLElement): (e: string, o: ((value: Event) => void) | Partial<Observer<Event>>) => HTMLElement;
+
+/**
+ *
+ * 订阅一个 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<T>(element: HTMLElement, key: string, value$: Observable<T>): HTMLElement;
+
+export declare function summary(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+
+export declare function sup(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+
+/**
+ * 创建静态选项卡组件。
+ *
+ * `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>;
+
+/**
+ * 选项卡的导航按钮。
+ *
+ * `tabNavItem` 函数生成一个选项卡的导航按钮，通常用于选项卡的导航栏中。
+ *
+ * @param {...(string|HTMLElement)} source - 按钮的内容，可以是字符串或 HTML 元素。
+ * @returns {HTMLElement} - 返回一个带有 `nav-item` 样式类的 `<li>` 元素，内部包含一个按钮。
+ *
+ */
+export declare function tabNavItem(...source: (string | HTMLElement)[]): HTMLElement;
+
+/**
+ * 选项卡的内容面板。
+ *
+ * `tabPanel` 函数生成一个选项卡的内容区域，用于显示与选项卡对应的内容。
+ *
+ * @param {...(string|HTMLElement)} source - 面板的内容，可以是字符串或 HTML 元素。
+ * @returns {HTMLElement} - 返回一个带有 `tab-pane` 样式类的 `<div>` 元素。
+ *
+ */
+export declare function tabPanel(...source: (string | HTMLElement)[]): HTMLElement;
+
+/**
+ * 选项卡组件的基础框架。
+ *
+ * `tabRoot` 函数生成一个包含导航栏和内容面板的容器结构，
+ * 用于构建选项卡组件的基础部分。
+ *
+ * @param {Object} props - 传递给根容器 `<div>` 的属性（如 `id`、`className` 等）。
+ * @returns {HTMLElement} - 返回一个包含导航栏和内容面板的 `<div>` 元素。
+ *
+ */
+export declare function tabRoot(props: Object): HTMLElement;
+
+export declare function tbody(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLTableSectionElement>;
+
+export declare function td(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLTableCellElement>;
+
+/**
+ * 创建一个支持 RxJS 数据绑定的 <textarea> 元素。
+ *
+ * @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 {{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;
+}): HyperscriptInputElement_2;
+
+/**
+ * @typedef {Text & {subscription?: Subscription, unsubscribe?: ()=>void}} ObservableTextNode
+ */
+/**
+ * 创建一个文本节点。
+ * 支持静态文本和动态更新的文本（通过 RxJS Observable）。
+ *
+ * - 如果传入的是字符串，则创建一个静态文本节点。
+ * - 如果传入的是 RxJS Observable，则创建一个动态文本节点，并根据 Observable 的值实时更新文本内容。
+ * - 动态文本节点支持通过 `unsubscribe` 方法取消订阅。
+ *
+ * @param {any} text Observable<any> | any。
+ * @returns {ObservableTextNode}
+ *
+ */
+export declare function textNode(text: any): ObservableTextNode;
+
+export declare function tfoot(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLTableSectionElement>;
+
+export declare function th(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLTableCellElement>;
+
+export declare function thead(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLTableSectionElement>;
+
+export declare function time(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLTimeElement>;
+
+/**
+ * 将扁平化的键值对数组转换为嵌套的 JavaScript 对象或数组。
+ *
+ * @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 track(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLTrackElement>;
+
+export declare function tt(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+
+export declare const types: string[];
+
+export declare function u(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+
+export declare function ul(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLUListElement>;
+
+/**
+ * 通过不断调用 fn 生成值，直到 fn 返回 falsy。
+ *
+ * @public
+ * @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>(this: any, fn: (seed: S) => [T, S] | false | null | undefined, seed: S): Array<T>;
+
+/**
+ * 将任意 JS 值序列化为“无引号 JSON”字符串（仅对键名和部分字符串值去引号）。
+ *
+ * @public
+ * @param {*} value - 要序列化的值
+ * @returns {string} 序列化后的字符串
+ */
+export declare function unquotedJsonStringify(value: any): string;
+
+/**
+ * 简易unwrap参数数组。如果子节点是单个数组，则解构为子节点，否则返回原数组。
+ *
+ * @template T
+ * @param {(T|T[])[]} args - 子节点数组。
+ * @returns {T[]} - 解构后的子节点数组。
+ */
+export declare function unwrapArgs<T>(args: (T | T[])[]): T[];
+
+export declare function video(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLVideoElement>;
+
+export declare function wbr(props?: {
+    [_: string]: any;
+}, ...childNodes: any[]): HyperscriptExtensions<HTMLElement>;
+
+/**
+ * 合并两个数组为一个元组数组。
+ *
+ * 如果数组长度不同，将以较长的数组为基准，短数组对应位置为 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[]): Array<[T, U]>;
+
+export { }