hyperscript-rxjs 1.3.14 → 1.3.16

package/dist/hyperscript-rxjs.cjs

@@ -0,0 +1,4114 @@
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	// The require scope
+/******/ 	var __webpack_require__ = {};
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  Comparer: () => (/* reexport */ Comparer),
+  Deep: () => (/* reexport */ Deep),
+  ObservableArray: () => (/* reexport */ ObservableArray),
+  a: () => (/* reexport */ a),
+  abbr: () => (/* reexport */ abbr),
+  address: () => (/* reexport */ address),
+  advance: () => (/* reexport */ advance),
+  area: () => (/* reexport */ tags_area),
+  arrayInsert: () => (/* reexport */ arrayInsert),
+  arrayRemove: () => (/* reexport */ arrayRemove),
+  article: () => (/* reexport */ article),
+  aside: () => (/* reexport */ aside),
+  attachSubscriptionToNode: () => (/* reexport */ attachSubscriptionToNode),
+  audio: () => (/* reexport */ audio),
+  b: () => (/* reexport */ b),
+  bdi: () => (/* reexport */ bdi),
+  bdo: () => (/* reexport */ bdo),
+  bindTabIndex: () => (/* reexport */ bindTabIndex),
+  blockLevelFamily: () => (/* reexport */ blockLevelFamily),
+  blockquote: () => (/* reexport */ blockquote),
+  br: () => (/* reexport */ br),
+  button: () => (/* reexport */ tags_button),
+  caption: () => (/* reexport */ caption),
+  checkbox: () => (/* reexport */ checkbox_checkbox),
+  choice: () => (/* reexport */ choice),
+  cite: () => (/* reexport */ cite),
+  code: () => (/* reexport */ code),
+  col: () => (/* reexport */ col),
+  colgroup: () => (/* reexport */ colgroup),
+  collapse: () => (/* reexport */ collapse),
+  compareDate: () => (/* reexport */ compareDate),
+  compareEntries: () => (/* reexport */ compareEntries),
+  compareKey: () => (/* reexport */ compareKey),
+  compareKeyPath: () => (/* reexport */ compareKeyPath),
+  compareNumber: () => (/* reexport */ compareNumber),
+  compose: () => (/* reexport */ compose),
+  cond: () => (/* reexport */ cond),
+  data: () => (/* reexport */ data),
+  datalist: () => (/* reexport */ datalist),
+  dd: () => (/* reexport */ dd),
+  defaultCompare: () => (/* reexport */ defaultCompare),
+  defaultComparer: () => (/* reexport */ defaultComparer),
+  del: () => (/* reexport */ del),
+  details: () => (/* reexport */ details),
+  dfn: () => (/* reexport */ dfn),
+  dialog: () => (/* reexport */ dialog),
+  div: () => (/* reexport */ div),
+  dl: () => (/* reexport */ dl),
+  dt: () => (/* reexport */ dt),
+  em: () => (/* reexport */ em),
+  entryComparer: () => (/* reexport */ entryComparer),
+  erectObject: () => (/* reexport */ erectObject),
+  fieldset: () => (/* reexport */ fieldset),
+  figcaption: () => (/* reexport */ figcaption),
+  figure: () => (/* reexport */ figure),
+  findLastIndex: () => (/* reexport */ findLastIndex),
+  flat: () => (/* reexport */ flat),
+  flip: () => (/* reexport */ flip),
+  fold: () => (/* reexport */ fold),
+  footer: () => (/* reexport */ footer),
+  form: () => (/* reexport */ tags_form),
+  fragment: () => (/* reexport */ fragment),
+  getDisplay: () => (/* reexport */ getDisplay),
+  getNestedProperty: () => (/* reexport */ getNestedProperty),
+  groupByFirstLevelKey: () => (/* reexport */ groupByFirstLevelKey),
+  h1: () => (/* reexport */ h1),
+  h2: () => (/* reexport */ h2),
+  h3: () => (/* reexport */ h3),
+  h4: () => (/* reexport */ h4),
+  h5: () => (/* reexport */ h5),
+  h6: () => (/* reexport */ h6),
+  header: () => (/* reexport */ header),
+  hgroup: () => (/* reexport */ hgroup),
+  hr: () => (/* reexport */ hr),
+  hyperscript: () => (/* reexport */ hyperscript),
+  i: () => (/* reexport */ i),
+  img: () => (/* reexport */ img),
+  inlineFamily: () => (/* reexport */ inlineFamily),
+  input: () => (/* reexport */ input),
+  ins: () => (/* reexport */ ins),
+  intersectObject: () => (/* reexport */ intersectObject),
+  isEmptyObject: () => (/* reexport */ isEmptyObject),
+  isPlainObject: () => (/* reexport */ isPlainObject),
+  isRange: () => (/* reexport */ isRange),
+  isRxType: () => (/* reexport */ isRxType),
+  kbd: () => (/* reexport */ kbd),
+  keyComparer: () => (/* reexport */ keyComparer),
+  keyPathComparer: () => (/* reexport */ keyPathComparer),
+  label: () => (/* reexport */ label),
+  legend: () => (/* reexport */ legend),
+  li: () => (/* reexport */ li),
+  main: () => (/* reexport */ main),
+  mark: () => (/* reexport */ mark),
+  menu: () => (/* reexport */ menu),
+  menuitem: () => (/* reexport */ menuitem),
+  meter: () => (/* reexport */ meter),
+  multiselect: () => (/* reexport */ multiselect),
+  nav: () => (/* reexport */ nav),
+  nestedCombineLatest: () => (/* reexport */ nestedCombineLatest),
+  nestedMerge: () => (/* reexport */ nestedMerge),
+  normalizeChildNodes: () => (/* reexport */ normalizeChildNodes),
+  numberbox: () => (/* reexport */ numberbox),
+  ol: () => (/* reexport */ ol),
+  optgroup: () => (/* reexport */ optgroup),
+  option: () => (/* reexport */ tags_option),
+  output: () => (/* reexport */ output),
+  p: () => (/* reexport */ p),
+  parseHyperscriptArgs: () => (/* reexport */ parseHyperscriptArgs),
+  parsePropName: () => (/* reexport */ parsePropName),
+  pickBehaviorSubject: () => (/* reexport */ pickBehaviorSubject),
+  pipe: () => (/* reexport */ pipe),
+  pipeEvent: () => (/* reexport */ pipeEvent),
+  pluckProperty: () => (/* reexport */ pluckProperty),
+  pre: () => (/* reexport */ pre),
+  progress: () => (/* reexport */ progress),
+  q: () => (/* reexport */ q),
+  queryStringify: () => (/* reexport */ queryStringify),
+  radio: () => (/* reexport */ radio_radio),
+  rangeArray: () => (/* reexport */ rangeArray),
+  rb: () => (/* reexport */ rb),
+  restore: () => (/* reexport */ restore),
+  rp: () => (/* reexport */ rp),
+  rt: () => (/* reexport */ rt),
+  rtc: () => (/* reexport */ rtc),
+  ruby: () => (/* reexport */ ruby),
+  s: () => (/* reexport */ s),
+  samp: () => (/* reexport */ samp),
+  section: () => (/* reexport */ section),
+  select: () => (/* reexport */ select_select),
+  setProp: () => (/* reexport */ setProp),
+  setProps: () => (/* reexport */ setProps),
+  small: () => (/* reexport */ small),
+  span: () => (/* reexport */ span),
+  splitObjectByObservable: () => (/* reexport */ splitObjectByObservable),
+  strong: () => (/* reexport */ strong),
+  sub: () => (/* reexport */ sub),
+  subscribeEvent: () => (/* reexport */ subscribeEvent),
+  subscribeProp: () => (/* reexport */ subscribeProp),
+  summary: () => (/* reexport */ summary),
+  sup: () => (/* reexport */ sup),
+  tabControl: () => (/* reexport */ tabControl),
+  tabNavItem: () => (/* reexport */ tabNavItem),
+  tabPanel: () => (/* reexport */ tabPanel),
+  tabRoot: () => (/* reexport */ tabRoot),
+  table: () => (/* reexport */ table),
+  tbody: () => (/* reexport */ tbody),
+  td: () => (/* reexport */ td),
+  textNode: () => (/* reexport */ textNode),
+  textarea: () => (/* reexport */ textarea_textarea),
+  textbox: () => (/* reexport */ textbox),
+  tfoot: () => (/* reexport */ tfoot),
+  th: () => (/* reexport */ th),
+  thead: () => (/* reexport */ thead),
+  time: () => (/* reexport */ time),
+  tojs: () => (/* reexport */ tojs),
+  tr: () => (/* reexport */ tr),
+  track: () => (/* reexport */ track),
+  tt: () => (/* reexport */ tt),
+  types: () => (/* reexport */ types),
+  u: () => (/* reexport */ u),
+  ul: () => (/* reexport */ ul),
+  unfold: () => (/* reexport */ unfold),
+  unquotedJsonStringify: () => (/* reexport */ unquotedJsonStringify),
+  unwrapArgs: () => (/* reexport */ unwrapArgs),
+  video: () => (/* reexport */ video),
+  wbr: () => (/* reexport */ wbr),
+  zipArray: () => (/* reexport */ zipArray)
+});
+
+;// ./src/array/advance.js
+/**
+ * @template T
+ * @param {Array<T>} array - 要处理的原数组
+ * @param {number} n - 要取出的元素个数
+ * @returns {[Array<T>, Array<T>]} - [已取出的元素数组, 剩余元素数组]
+ */
+function advance(array, n) {
+  let taken = [];
+  for (let i = 0; i < n; i++) {
+    taken[n - 1 - i] = array[i];
+  }
+  return [taken, array.slice(n)];
+}
+;// ./src/array/arrayInsert.js
+/**
+ * insert a element at position in place.
+ * @param {any} array
+ * @param {any} item
+ * @param {any} index
+ */
+function arrayInsert(array, item, index = array.length) {
+  const len = array.length;
+  for (let i = len; i > index; i--) {
+    array[i] = array[i - 1];
+  }
+  array[index] = item;
+}
+;// ./src/array/arrayRemove.js
+/**
+ * remove a element in place
+ * 
+ * @template T
+ * @param {T[]} array
+ * @param {number} index
+ */
+function arrayRemove(array, index = array.length - 1) {
+  const len = array.length;
+  for (let i = index; i < len - 1; i++) {
+    array[i] = array[i + 1];
+  }
+  Reflect.deleteProperty(array, len - 1);
+  array.length = len - 1;
+}
+;// ./src/array/findLastIndex.js
+/**
+ * 查找数组中最后一个满足条件的元素索引。
+ *
+ * @public
+ * @template T
+ * @param {T[]} array - 要查找的数组
+ * @param {(value: T, index: number) => boolean} callbackFn - 判断函数，返回 true 表示找到
+ * @param {number} [lastIndex=array.length-1] - 可选，查找的起始索引（从后往前）
+ * @returns {number} - 最后一个满足条件的元素索引，未找到返回 -1
+ */
+function findLastIndex(array, callbackFn, lastIndex = array.length - 1) {
+  lastIndex = Math.min(lastIndex, array.length - 1);
+  while (lastIndex >= 0) {
+    if (callbackFn(array[lastIndex], lastIndex)) {
+      return lastIndex;
+    }
+    lastIndex--;
+  }
+  return -1;
+}
+;// ./src/array/isRange.js
+/**
+ * 判断输入的字符串数组是否为从0开始的连续数字区间（如 ['0','1','2',...])。
+ *
+ * @public
+ * @param {string[]} keys - 要检查的字符串数组
+ * @returns {boolean} - 如果是从0开始的连续数字区间返回 true，否则返回 false
+ */
+function isRange(keys) {
+  if (keys.every(key => /^\d+$/.test(key))) {
+    let nums = keys.map(key => parseInt(key));
+    return nums.every((v, i) => v === i);
+  }
+  return false;
+}
+;// ./src/array/rangeArray.js
+/**
+ * 创建一个从 0 到 length-1 的数字数组。
+ *
+ * @public
+ * @param {number} length - 要创建的数组长度
+ * @returns {number[]} - 从 0 到 length-1 的数字数组
+ */
+function rangeArray(length) {
+  return Array.from({
+    length
+  }).map((v, i) => i);
+}
+;// ./src/array/unwrapArgs.js
+/**
+ * 简易unwrap参数数组。如果子节点是单个数组，则解构为子节点，否则返回原数组。
+ *
+ * @template T
+ * @param {(T|T[])[]} args - 子节点数组。
+ * @returns {T[]} - 解构后的子节点数组。
+ */
+function unwrapArgs(args) {
+  return /** @type{T[]} */args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+}
+;// ./src/array/zipArray.js
+/**
+ * 合并两个数组为一个元组数组。
+ *
+ * 如果数组长度不同，将以较长的数组为基准，短数组对应位置为 undefined。
+ *
+ * @public
+ * @template T, U
+ * @param {T[]} a - 第一个数组
+ * @param {U[]} b - 第二个数组
+ * @returns {Array<[T, U]>} - 合并后的元组数组
+ * @throws {Error} 如果 a 或 b 不是数组
+ */
+function zipArray(a, b) {
+  if (!Array.isArray(a) || !Array.isArray(b)) {
+    throw new Error("arrayZip(a,b):both a and b should be array");
+  }
+  if (a.length >= b.length) {
+    return a.map((v, i) => [v, b[i]]);
+  } else {
+    return b.map((v, i) => [a[i], v]);
+  }
+}
+;// ./src/array/0.js
+
+
+
+
+
+
+
+
+;// ./src/comparers/distinctArray.js
+/**
+ * 数组去重，并保持元素的相对顺序。
+ * @template T 
+ * @param {T[]} array
+ * @param {(a:T,b:T)=>boolean} equals
+ * @returns {T[]}
+ */
+function distinctArray(array, equals) {
+  /**
+   * 递归处理去重
+   * @param {T[]} resultArray - 已去重的结果数组
+   * @param {T[]} rest - 剩余待处理的数组
+   * @returns {T[]} - 去重后的数组
+   */
+  function loop(resultArray, rest) {
+    if (rest.length === 0) {
+      return resultArray;
+    } else {
+      let [head, ...tail] = rest;
+      if (resultArray.findIndex(e => equals(head, e)) < 0) {
+        return loop([...resultArray, head], tail);
+      } else {
+        return loop(resultArray, tail);
+      }
+    }
+  }
+  return loop([], array);
+}
+;// ./src/comparers/groupSortedEntries.js
+/**
+ * Groups an array of sorted key-value entries into an array of groups, 
+ * where each group contains entries with the same key.
+ *
+ * @template K, V
+ * @param {[K, V][]} sortedEntries - An array of key-value pairs, 
+ * where the keys are already sorted in ascending order.
+ * @param {(a:K,b:K)=>number} compare - A comparison function that takes two keys 
+ * and returns a number: 0 if the keys are equal, a negative number if the first key 
+ * is less than the second, and a positive number otherwise.
+ * @returns {[K, V[]][]} An array of groups, where each group is a tuple 
+ * containing a key and an array of values associated with that key.
+ */
+function groupSortedEntries(sortedEntries, compare) {
+  if (sortedEntries.length === 0) {
+    return [];
+  }
+  const [head, ...tail] = sortedEntries;
+  /** @type {[K, V[]]} */
+  const firstGroup = [head[0], [head[1]]];
+  return tail.reduce((groups, [k, v]) => {
+    let [k0, group] = groups[groups.length - 1];
+    if (compare(k0, k) === 0) {
+      group.push(v);
+    } else {
+      groups.push([k, [v]]);
+    }
+    return groups;
+  }, [firstGroup]);
+}
+;// ./src/comparers/groupArrayBy.js
+
+
+/**
+ * 按指定的 key 函数对数组元素分组。
+ *
+ * 先将数组元素映射为 [key, value] 对，按 key 排序后，再分组。
+ *
+ * @public
+ * @template T, K
+ * @param {T[]} array - 要分组的数组
+ * @param {(item: T) => K} getKey - 生成分组 key 的函数
+ * @param {(a: K, b: K) => number} compare - key 的比较函数
+ * @returns {[K, T[]][]} 分组后的结果，每组为 [key, 元素数组]
+ */
+function groupArrayBy(array, getKey, compare) {
+  if (array.length === 0) {
+    return [];
+  }
+  let sortedEntries = array.map(
+  /**
+   * @returns {[K, T]}
+   */
+  e => [getKey(e), e]).sort(([ka], [kb]) => compare(ka, kb));
+  return groupSortedEntries(sortedEntries, compare);
+}
+;// ./src/comparers/differenceSet.js
+/**
+ * return set1 - set2
+ * @template T 
+ * @param {T[]} set1
+ * @param {T[]} set2
+ * @param {(a: T, b: T) => number} compare
+ * @returns {T[]}
+ */
+function differenceSet(set1, set2, compare) {
+  /**
+   * @param {T[]} acc
+   * @param {T[]} a
+   * @param {T[]} b
+   * @returns {T[]}
+   */
+  function loop(acc, a, b) {
+    if (a.length === 0) {
+      return acc;
+    } else if (b.length === 0) {
+      return [...acc, ...a];
+    } else {
+      let n = compare(a[0], b[0]);
+      if (n === 0) {
+        return loop(acc, a.slice(1), b.slice(1));
+      } else if (n < 0) {
+        return loop([...acc, a[0]], a.slice(1), b);
+      } else {
+        // if (n > 0)
+        return loop(acc, a, b.slice(1));
+      }
+    }
+  }
+  return loop([], set1, set2);
+}
+;// ./src/comparers/findIndexInSet.js
+/**
+ * 同Array.findIndex，返回元素在集合中的索引位置
+ * 
+ * @template T
+ * @param {T[]} set Array.sort(compare)后的Array
+ * @param {T} e 是要查找的元素
+ * @param {(a:T,b:T)=>number} compare 元素的比较函数
+ */
+function findIndexInSet(set, e, compare) {
+  /** @param {number} i  */
+  function loop(i) {
+    if (i === set.length) {
+      return -1;
+    } else {
+      const n = compare(set[i], e);
+      if (n === 0) {
+        return i;
+      } else if (n < 0) {
+        return loop(i + 1);
+      } else {
+        return -1;
+      }
+    }
+  }
+  return loop(0);
+}
+;// ./src/comparers/intersectSet.js
+/**
+ * 计算两个有序数组的交集。
+ * @template T
+ * @param {T[]} set1 - 第一个已排序的数组
+ * @param {T[]} set2 - 第二个已排序的数组
+ * @param {(a: T, b: T) => number} compare - 比较函数
+ * @returns {T[]} 两数组的交集
+ */
+function intersectSet(set1, set2, compare) {
+  /**
+   * 递归计算交集
+   * @param {T[]} acc - 当前交集结果
+   * @param {T[]} a - 剩余的 set1
+   * @param {T[]} b - 剩余的 set2
+   * @returns {T[]} 交集
+   */
+  function loop(acc, a, b) {
+    if (a.length === 0 || b.length === 0) {
+      return acc;
+    } else {
+      //每次去掉最大的元素
+      switch (Math.sign(compare(a[0], b[0]))) {
+        case -1:
+          return loop(acc, a.slice(1), b);
+        case 0:
+          return loop([...acc, a[0]], a.slice(1), b.slice(1));
+        case 1:
+        default:
+          return loop(acc, a, b.slice(1));
+      }
+    }
+  }
+  return loop([], set1, set2);
+}
+;// ./src/comparers/isEqualset.js
+/**
+ * 判断两个集合是否相等（成员完全相同，顺序无关）。
+ * @template T
+ * @param {T[]} set1 - 第一个集合
+ * @param {T[]} set2 - 第二个集合
+ * @param {(a: T, b: T) => number} compare - 比较函数
+ * @returns {boolean} 如果集合相等返回 true，否则返回 false
+ */
+function isEqualset(set1, set2, compare) {
+  /**
+   * @param {T[]} a
+   * @param {T[]} b
+   * @returns {boolean}
+   */
+  function loop(a, b) {
+    if (a.length === 0 && b.length === 0) {
+      return true;
+    }
+    if (a.length > 0 && b.length > 0) {
+      let [a0, ...aa] = a;
+      let [b0, ...bb] = b;
+      if (compare(a0, b0) === 0) {
+        return loop(aa, bb);
+      } else {
+        return false;
+      }
+    }
+    return false;
+  }
+  return loop(set1, set2);
+}
+;// ./src/comparers/isSubset.js
+/**
+ * 判断 set1 是否为 set2 的子集（假定已排序）。
+ * @template T
+ * @param {T[]} set1 - 可能为子集的数组
+ * @param {T[]} set2 - 可能为超集的数组
+ * @param {(a: T, b: T) => number} compare - 比较函数
+ * @returns {boolean} 如果 set1 是 set2 的子集返回 true，否则返回 false
+ */
+function isSubset(set1, set2, compare) {
+  /**
+   * @param {T[]} a
+   * @param {T[]} b
+   * @returns {boolean}
+   */
+  function loop(a, b) {
+    if (a.length === 0) {
+      return true;
+    } else if (b.length === 0) {
+      return false;
+    } else {
+      switch (Math.sign(compare(a[0], b[0]))) {
+        case -1:
+          return false;
+        case 0:
+          return loop(a.slice(1), b.slice(1));
+        case 1:
+        default:
+          return loop(a, b.slice(1));
+      }
+    }
+  }
+  return loop(set1, set2);
+}
+;// ./src/comparers/isSuperset.js
+
+
+/**
+ * 判断 a 是否为 b 的超集（假定已排序）。
+ * @template T
+ * @param {T[]} a - 可能为超集的数组
+ * @param {T[]} b - 可能为子集的数组
+ * @param {(x: T, y: T) => number} compare - 比较函数
+ * @returns {boolean} 如果 a 是 b 的超集返回 true，否则返回 false
+ */
+function isSuperset(a, b, compare) {
+  return isSubset(b, a, compare);
+}
+;// ./src/comparers/unionSet.js
+/**
+ * 计算两个有序数组的并集（去重）。
+ * @template T
+ * @param {T[]} set1 - 第一个已排序的数组
+ * @param {T[]} set2 - 第二个已排序的数组
+ * @param {(a: T, b: T) => number} compare - 比较函数
+ * @returns {T[]} 并集后的新数组
+ */
+function unionSet(set1, set2, compare) {
+  /**
+   * @param {T[]} acc - 当前结果
+   * @param {T[]} a - 剩余的 set1
+   * @param {T[]} b - 剩余的 set2
+   * @returns {T[]} 并集
+   */
+  function loop(acc, a, b) {
+    if (a.length === 0) {
+      return [...acc, ...b];
+    } else if (b.length === 0) {
+      return [...acc, ...a];
+    } else {
+      switch (Math.sign(compare(a[0], b[0]))) {
+        case -1:
+          return loop([...acc, a[0]], a.slice(1), b);
+        case 0:
+          return loop([...acc, a[0]], a.slice(1), b.slice(1));
+        case 1:
+        default:
+          return loop([...acc, b[0]], a, b.slice(1));
+      }
+    }
+  }
+  return loop([], set1, set2);
+}
+;// ./src/comparers/sortedArrayToSet.js
+/**
+ * 数组去重，排序好后的数组去重。
+ * @template T
+ * @param {T[]} sortedArray - 已排序的数组
+ * @param {(a: T, b: T) => number} compare - 比较函数
+ * @returns {T[]} 去重后的新数组
+ */
+function sortedArrayToSet(sortedArray, compare) {
+  /**
+   * @param {T[]} acc - 当前结果
+   * @param {T[]} sarray - 剩余待处理的数组
+   * @returns {T[]} 去重后的新数组
+   */
+  function loop(acc, sarray) {
+    if (sarray.length === 0) {
+      return acc;
+    } else {
+      switch (Math.sign(compare(acc[acc.length - 1], sarray[0]))) {
+        case -1:
+          return loop([...acc, sarray[0]], sarray.slice(1));
+        case 0:
+          return loop(acc, sarray.slice(1));
+        case 1:
+        default:
+          throw new Error('sort ascent');
+      }
+    }
+  }
+  if (sortedArray.length === 0) {
+    return [];
+  } else {
+    return loop([sortedArray[0]], sortedArray.slice(1));
+  }
+}
+;// ./src/comparers/Comparer.js
+
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * 用于比较和操作数组及集合的工具类。
+ *
+ * @public
+ * @template T
+ */
+class Comparer {
+  /**
+   * @param {(a: T, b: T) => number} compare - 比较函数
+   */
+  constructor(compare) {
+    this.compare = compare;
+  }
+
+  /**
+   * 使用实例的比较函数对数组进行排序。
+   * @param {T[]} array - 要排序的数组
+   * @returns {T[]} 排序后的数组
+   */
+  sort(array) {
+    return array.sort(this.compare);
+  }
+
+  /**
+   * 移除数组中的重复值。
+   * @param {T[]} array - 要处理的数组
+   * @returns {T[]} 去重后的新数组
+   */
+  distinct(array) {
+    return distinctArray(array, (a, b) => this.compare(a, b) === 0);
+  }
+
+  /**
+   * 将已排序的数组转为集合（去重）。
+   * @param {T[]} array - 已排序的数组
+   * @returns {T[]} 唯一元素数组
+   */
+  sortedArrayToSet(array) {
+    return sortedArrayToSet(array, this.compare);
+  }
+
+  /**
+   * 根据 getKey 生成的 key 对数组元素分组。
+   * @template U
+   * @param {U[]} array - 要分组的数组
+   * @param {(item:U) => T} getKey - 生成分组 key 的函数
+   * @returns {[T, U[]][]} 分组后的对象或数组
+   */
+  groupBy(array, getKey) {
+    return groupArrayBy(array, getKey, this.compare);
+  }
+
+  /**
+   * 对已排序的数组按 key 分组。
+   * @template V
+   * @param {[T,V][]} array - 已排序的数组
+   * @returns {[T, V[]][]} 分组结果
+   */
+  groupSortedEntries(array) {
+    return groupSortedEntries(array, this.compare);
+  }
+
+  /**
+   * 计算两个数组的差集。数组元素是升序排列
+   * @param {T[]} array1 - 第一个数组
+   * @param {T[]} array2 - 第二个数组
+   * @returns {T[]} array1 中有而 array2 中没有的元素
+   */
+  differenceSet(array1, array2) {
+    return differenceSet(array1, array2, this.compare);
+  }
+
+  /**
+   * 计算两个数组的交集。
+   * @param {T[]} array1 - 第一个数组
+   * @param {T[]} array2 - 第二个数组
+   * @returns {T[]} 同时存在于 array1 和 array2 的元素
+   */
+  intersectSet(array1, array2) {
+    return intersectSet(array1, array2, this.compare);
+  }
+
+  /**
+   * 计算两个数组的并集（去重）。
+   * @param {T[]} array1 - 第一个数组
+   * @param {T[]} array2 - 第二个数组
+   * @returns {T[]} 两个数组的唯一元素合集
+   */
+  unionSet(array1, array2) {
+    return unionSet(array1, array2, this.compare);
+  }
+
+  /**
+   * 在集合（数组）中查找元素的索引。
+   * @param {T[]} set - 要查找的数组
+   * @param {T} element - 要查找的元素
+   * @returns {number} 元素在集合中的索引，未找到返回 -1
+   */
+  findIndexInSet(set, element) {
+    return findIndexInSet(set, element, this.compare);
+  }
+
+  /**
+   * 判断两个数组作为集合是否相等。
+   * @param {T[]} array1 - 第一个数组
+   * @param {T[]} array2 - 第二个数组
+   * @returns {boolean} 如果集合相等返回 true，否则返回 false
+   */
+  isEqualset(array1, array2) {
+    return isEqualset(array1, array2, this.compare);
+  }
+
+  /**
+   * 判断第一个数组是否为第二个数组的子集。
+   * @param {T[]} array1 - 第一个数组
+   * @param {T[]} array2 - 第二个数组
+   * @returns {boolean} 如果 array1 是 array2 的子集返回 true，否则返回 false
+   */
+  isSubset(array1, array2) {
+    return isSubset(array1, array2, this.compare);
+  }
+
+  /**
+   * 判断第一个数组是否为第二个数组的超集。
+   * @param {T[]} array1 - 第一个数组
+   * @param {T[]} array2 - 第二个数组
+   * @returns {boolean} 如果 array1 是 array2 的超集返回 true，否则返回 false
+   */
+  isSuperset(array1, array2) {
+    return isSuperset(array1, array2, this.compare);
+  }
+}
+;// ./src/comparison/defaultCompare.js
+/**
+ * 默认比较函数，适用于可比较的基本类型。
+ *
+ * @public
+ * @template T
+ * @param {T} a - 第一个值
+ * @param {T} b - 第二个值
+ * @returns {number} 如果 a > b 返回 1，a < b 返回 -1，相等返回 0
+ */
+function defaultCompare(a, b) {
+  return a > b ? 1 : a < b ? -1 : 0;
+}
+;// ./src/comparison/compareKey.js
+
+
+/**
+ * 
+ * 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.
+ * 
+ */
+function compareKey(a, b) {
+  let type1 = typeof a;
+  let type2 = typeof b;
+  if (type1 === type2) {
+    return defaultCompare(a, b);
+  }
+
+  //string > number
+  if (type1 === 'string') {
+    return 1;
+  }
+  return -1;
+}
+;// ./src/comparison/compareKeyPath.js
+
+
+/**
+ * 比较两个 key path（键路径数组）。
+ *
+ * @public
+ * @param {(number|string)[]} a - 第一个 key path
+ * @param {(number|string)[]} b - 第二个 key path
+ * @returns {number} 若 a < b 返回负数，相等返回 0，大于返回正数
+ */
+function compareKeyPath(a, b) {
+  //两个空数组相等
+  if (a.length === 0 && b.length === 0) {
+    return 0;
+  }
+
+  //空数组小于非空数组。
+  if (a.length === 0) {
+    return -1;
+  }
+
+  //非空数组大于空数组。
+  if (b.length === 0) {
+    return 1;
+  }
+
+  //两个数组每次从0位出一个元素，进行比较。
+  let [a0, ...aa] = a;
+  let [b0, ...bb] = b;
+
+  //两个元素相等，递归比较剩余数组。
+  return compareKey(a0, b0) || compareKeyPath(aa, bb);
+}
+;// ./src/comparison/compareEntries.js
+
+
+/**
+ * 比较两个 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，大于返回正数
+ */
+function compareEntries([keypath1], [keypath2]) {
+  return compareKeyPath(keypath1, keypath2);
+}
+;// ./src/comparers/comparers.js
+// import {  } from "../comparison/defaultCompare.js"
+// import {  } from "../comparison/compareKey.js"
+// import {  } from "../comparison/compareKeyPath.js"
+// import { } from "../comparison/compareEntries.js"
+
+
+
+const defaultComparer = new Comparer(defaultCompare);
+const keyComparer = new Comparer(compareKey);
+const keyPathComparer = new Comparer(compareKeyPath);
+const entryComparer = new Comparer(compareEntries);
+;// ./src/comparers/0.js
+
+
+// export * from "./differenceSet.js"
+// export * from "./distinctArray.js"
+// export * from "./findIndexInSet.js"
+// export * from "./groupArrayBy.js"
+// export * from "./groupSortedEntries.js"
+// export * from "./intersectSet.js"
+// export * from "./isEqualset.js"
+// export * from "./isSubset.js"
+// export * from "./isSuperset.js"
+// export * from "./sortedArrayToSet.js"
+// export * from "./unionSet.js"
+;// ./src/comparison/compareDate.js
+/**
+ * 比较两个日期对象的大小。
+ *
+ * @public
+ * @param {Date} a - 第一个日期
+ * @param {Date} b - 第二个日期
+ * @returns {number} 如果 a > b 返回正数，a < b 返回负数，相等返回 0
+ */
+function compareDate(a, b) {
+  return a.valueOf() - b.valueOf();
+}
+;// ./src/comparison/compareNumber.js
+
+
+/**
+ * 可以比较NaN,Infinity,number,bigint
+ * @param {number|bigint} a
+ * @param {number|bigint} b
+ */
+function compareNumber(a, b) {
+  if (Number.isNaN(a) && Number.isNaN(b)) {
+    return 0;
+  }
+
+  //NaN最大
+  if (Number.isNaN(a)) {
+    return 1;
+  }
+  if (Number.isNaN(b)) {
+    return -1;
+  }
+  return defaultCompare(a, b);
+}
+;// ./src/comparison/types.js
+/// 这个字符串数组列举了JavaScript 中所有基本数据类型（primitive types）的名称。typeof 返回值域
+const types = ["undefined",
+// 未定义类型，表示未赋值的变量
+"object",
+// 对象类型（包括 null 和所有对象/数组/日期等）
+"boolean",
+// 布尔类型（true/false）
+"number",
+// 数字类型（包括整数和浮点数）
+"bigint",
+// 大整数类型（ES2020 新增，表示任意精度的整数）
+"string",
+// 字符串类型
+"symbol",
+// Symbol 类型（ES2015 新增，表示唯一标识符）
+"function" // 函数类型（虽然 typeof 返回 'function'，但函数本质是 object 的子类型）
+];
+;// ./src/comparison/0.js
+
+
+
+
+
+
+
+;// external "rxjs"
+const external_rxjs_namespaceObject = require("rxjs");
+;// ./src/object/pluckProperty.js
+/**
+ * 获取对象的嵌套属性
+ * @param {Record<string | number, any>} obj - 源对象/数组
+ * @param {(string|number)[]} keyPath - 属性访问路径数组
+ * @returns {any} 路径对应的属性值
+ * @throws {TypeError} 当路径不存在时抛出错误
+ */
+function pluckProperty(obj, keyPath) {
+  // 类型检查
+  if (typeof obj !== 'object' || obj === null) {
+    throw new TypeError('First argument must be an object');
+  }
+  if (!Array.isArray(keyPath)) {
+    throw new TypeError('keyPath must be an array');
+  }
+  return keyPath.reduce((prev, curr) => {
+    if (prev == null || !(curr in prev)) {
+      throw new TypeError(`Property '${curr}' not found in path`);
+    }
+    return prev[curr];
+  }, obj);
+}
+;// ./src/structures/groupByFirstLevelKey.js
+
+
+/**
+ * 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]
+ * 
+ */
+function groupByFirstLevelKey(flatEntries) {
+  if (flatEntries.length === 0) {
+    return [];
+  }
+  let sortedKvPairs = flatEntries.map(
+  /**
+   * @returns {[ string | number, [ (string | number)[], any ] ]}
+   */
+  ([[key, ...keyPath], value]) => [key, [keyPath, value]]);
+  return keyComparer.groupSortedEntries(sortedKvPairs);
+}
+;// ./src/structures/tojs.js
+
+
+
+/**
+ * 将扁平化的键值对数组转换为嵌套的 JavaScript 对象或数组。
+ *
+ * @param {[ (string | number)[], any ][]} flatEntries - 扁平化的键值对数组。
+ * 每个键值对的格式为 `[keyPath, value]`，其中 `keyPath` 是一个表示嵌套路径的数组。假设输入的键值对数组已经按照键路径（keyPath）排好顺序。
+ * @returns {Record<string|number, any>} - 返回嵌套的 JavaScript 对象或数组。
+ *
+ */
+function tojs(flatEntries) {
+  if (!Array.isArray(flatEntries)) {
+    throw new TypeError('Expected an array of flat entries');
+  }
+  if (flatEntries.length === 0) {
+    return {};
+  }
+  if (flatEntries.length === 1 && flatEntries[0][0].length === 0) {
+    return flatEntries[0][1];
+  }
+
+  // 按第一层键分组，并递归处理嵌套结构
+  let entries = groupByFirstLevelKey(flatEntries).map(([k, group]) => {
+    // 如果组中只有一个键值对，且键路径为空，直接取值
+    let v = group.length === 1 && group[0][0].length === 0 ? group[0][1] : tojs(group); // 否则递归处理
+    return [k, v];
+  });
+
+  // 获取第一层的键
+  let keys = entries.map(([k]) => k);
+
+  // 将键值对数组转换为对象
+  let obj = Object.fromEntries(entries);
+
+  // 如果第一层键是连续的数字序列，则转换为数组
+  if (isRange(keys)) {
+    return Array.from({
+      ...obj,
+      length: keys.length
+    });
+  } else {
+    return obj;
+  }
+}
+;// ./src/structures/flat.js
+/**
+ * 扁平化对象或数组，输入参数与JSON.stringify相同。
+ * @param {any} data
+ * @param {(value: any,key: string|number, keyPath: (string|number)[]) => boolean} [isLeaf] 当函数返回真时，属性作为叶节点。
+ * @returns {[(string|number)[],any][]}
+ */
+const flat = (data, isLeaf = () => false) => {
+  /**
+   * 
+   * @param {[(string | number)[], any][]} acc 
+   * @param {(string | number)[]} keyPath 
+   * @param {string | number} key 
+   * @param {*} value
+   * @returns {[(string | number)[], any][]}
+   */
+  function loop(acc, keyPath, key, value) {
+    keyPath = [...keyPath, key];
+    if (isLeaf(value, key, keyPath)) {
+      // 首先拦截叶节点
+      return [...acc, [keyPath, value]];
+    } else if (value && typeof value === 'object') {
+      // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects
+      // 内置对象为叶节点
+      if (value instanceof Function || value instanceof Boolean || value instanceof Symbol || value instanceof Error || value instanceof Number || value instanceof BigInt || value instanceof Date || value instanceof String || value instanceof RegExp || value instanceof Map || value instanceof Set || value instanceof WeakMap || value instanceof WeakSet) {
+        return [...acc, [keyPath, value]];
+      }
+      // 空數組為叶節點
+      if (Array.isArray(value) && value.length === 0) {
+        return [...acc, [keyPath, value]];
+      }
+
+      // 空对象为叶节点
+      if (Object.keys(value).length === 0) {
+        return [...acc, [keyPath, value]];
+      }
+
+      // date,regex
+      let entries = Array.isArray(value) ? value.map((v, i) => [i, v]) : Object.entries(value);
+      if (entries.length > 0) {
+        // 附加当前对象包含的所有词条到词条累加器后面
+        return entries.map(([k, v]) => loop([], keyPath, k, v)).reduce((a, b) => [...a, ...b], acc);
+      } else {
+        return [...acc, [keyPath, value]];
+      }
+    } else {
+      return [...acc, [keyPath, value]];
+    }
+  }
+  return loop([], [], '', data).map(
+  // 删除辅助的第一层路径: ['', ...paths] -> paths
+  ([[_, ...keyPath], value]) => [keyPath, value]);
+};
+;// ./src/deep/intersectEntries.js
+
+
+/**
+ * 返回一个新entries，每个entry的key都在keys中。
+ * @template T
+ * @param {[(string|number)[],T][]} entries
+ * @param {(string|number)[][]} keys
+ */
+function intersectEntries(entries, keys) {
+  /**
+   * 
+   * @param {[(string|number)[],T][]} acc 
+   * @param {[(string|number)[],T][]} entries 
+   * @param {(string|number)[][]} keys 
+   * @returns {[(string|number)[],T][]}
+   */
+  const loop = (acc, entries, keys) => {
+    // 由intersect修改而来
+    if (entries.length === 0 || keys.length === 0) {
+      return acc;
+    } else {
+      switch (Math.sign(compareKeyPath(entries[0][0], keys[0]))) {
+        case 0:
+          let yy = [...acc, entries[0]];
+          return loop(yy, entries.slice(1), keys.slice(1));
+        case -1:
+          return loop(acc, entries.slice(1), keys);
+        case 1:
+        default:
+          return loop(acc, entries, keys.slice(1));
+      }
+    }
+  };
+  return loop([], entries, keys);
+}
+;// ./src/deep/Deep.js
+
+
+
+
+
+
+
+
+/**
+ * 深度（嵌套）数据结构类，用于处理按键路径排序的键值对集合。
+ * 提供了多种操作方法，包括集合操作、序列操作和数据转换。
+ * 
+ * @template T
+ * 
+ */
+class Deep {
+  /**
+   * 构造函数。
+   *
+   * @param {[(string|number)[], T][]} entries - 按键路径排序的键值对数组。键值对已经按keypath排序。
+   */
+  constructor(entries) {
+    this._entries = entries;
+    this._keys = this._entries.map(([k]) => k);
+  }
+
+  ///基本數據屬性
+
+  get entries() {
+    return this._entries;
+  }
+  get keys() {
+    return this._keys;
+  }
+  getValues() {
+    return this.entries.map(([k, v]) => v);
+  }
+
+  ///构造正常数据对象
+  /**
+   * 将深度数据结构转换为普通对象。
+   * 
+   * @returns {Record<string|number, any>} 转换后的普通对象。
+   */
+  toObject() {
+    return tojs(this.entries);
+  }
+
+  ///單個讀取
+
+  /**
+   * 
+   * @param {(string|number)[]} searchKeyPath 
+   * @returns 
+   */
+  findIndex(searchKeyPath) {
+    return keyPathComparer.findIndexInSet(this.keys, searchKeyPath);
+  }
+
+  ///集合操作
+
+  /**
+   * 
+   * @param {(string|number)[][]} keys 
+   * @returns 
+   */
+  structuralEqual(keys) {
+    return keyPathComparer.isEqualset(this.keys, keys);
+  }
+
+  /**
+   * 
+   * @param {(string|number)[][]} keys 
+   * @returns 
+   */
+  structuralSubset(keys) {
+    return keyPathComparer.isSubset(this.keys, keys);
+  }
+
+  /**
+   * 
+   * @param {(string|number)[][]} keys 
+   * @returns 
+   */
+  structuralSuperset(keys) {
+    return keyPathComparer.isSuperset(this.keys, keys);
+  }
+
+  /**
+   * @param {(string|number)[][]} keys
+   * @this {Deep<T>}
+   * @returns {Deep<T>}
+   */
+  intersect(keys) {
+    let entries = intersectEntries(this.entries, keys);
+    return new Deep(entries);
+  }
+
+  /**
+   * 
+   * @param {(string|number)[][]} keys
+   * @this {Deep<T>}
+   * @returns {Deep<T>}
+   */
+  difference(keys) {
+    let newkeys = keyPathComparer.differenceSet(this.keys, keys);
+    return this.intersect(newkeys);
+  }
+
+  /**
+   * 后来者赢(参数赢)
+   * @param {[(string | number)[], T][]} entries 
+   * @returns 
+   */
+  union(entries) {
+    let entries2 = entryComparer.sort([...this.entries, ...entries]);
+    return new Deep(entries2);
+  }
+
+  /// 序列操作符
+
+  /**
+   * 
+   * @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(callbackfn, thisArg) {
+    let values = this.entries.map(callbackfn, thisArg);
+    return this.replaceValue(values);
+  }
+
+  /**
+   * 
+   * @param {(value: [(string | number)[], T], index: number, array: [(string | number)[], T][]) => boolean} predicate 
+   * @param {Deep<T>} [thisArg]
+   * @returns 
+   */
+  filter(predicate, thisArg) {
+    let entries = this.entries.filter(predicate, thisArg);
+    return new Deep(entries);
+  }
+
+  /**
+   * 
+   * @param { (value: [(string | number)[], T], index: number, array: [(string | number)[], T][]) => void} callbackfn 
+   * @param {Deep<T>} [thisArg]
+   * @returns 
+   */
+  forEach(callbackfn, thisArg) {
+    this.entries.forEach(callbackfn, thisArg);
+  }
+
+  /// 值操作
+
+  /**
+   * 修改部分个别数值
+   * @param {Record<string|number,any>} obj 
+   * @this {Deep<T>}
+   * @returns 
+   */
+  freshValue(obj) {
+    let entries = this.keys.map(
+    /**
+     * @returns {[(string | number)[],any]}
+     */
+    k => [k, pluckProperty(obj, k)]);
+    return new Deep(entries);
+  }
+
+  /**
+   * 按列替换数值
+   * @template U
+   * @param {U[]} values
+   * @this {Deep<T>}
+   * @returns {Deep<U>}
+   */
+  replaceValue(values) {
+    let entries = zipArray(this.keys, values);
+    return new Deep(entries);
+  }
+
+  /**
+   * 按列替换数值，保留原有数值
+   * @template U
+   * @param {U[]} values
+   * @this {Deep<T>}
+   * @returns {Deep<[T,U]>}
+   */
+  zipValue(values) {
+    return this.replaceValue(zipArray(this.getValues(), values));
+  }
+
+  /// rxjs操作符
+
+  /**
+   * 返回Observable of 总体的当前值
+   * @template U
+   * @this {Deep<Observable<U>>}
+   * @returns {Observable<Deep<U>>}
+   */
+  combineLatest() {
+    let values = this.getValues();
+    return (0,external_rxjs_namespaceObject.combineLatest)(values).pipe((0,external_rxjs_namespaceObject.map)(values => this.replaceValue(values)));
+  }
+
+  /**
+   * 返回发射消息的那一个成员的路径以及新值。
+   * @template U
+   * @this {Deep<Observable<U>>}
+   * @returns {Observable<[(string|number)[], U]>}
+   */
+  merge() {
+    return (0,external_rxjs_namespaceObject.from)(this.entries).pipe((0,external_rxjs_namespaceObject.mergeMap)(([keyPath, value$]) => value$.pipe((0,external_rxjs_namespaceObject.map)(
+    /**
+     * @returns {[(string|number)[], U]}
+     */
+    value => [keyPath, value]))));
+  }
+
+  /// 静态构造方法
+
+  /**
+   * 
+   * @param {{[_:string|number]:any}} obj 
+   * @param {(value: any, key: string | number, keyPath: (string | number)[]) => boolean} [filter]
+   * @returns 
+   */
+  static fromObject(obj, filter = () => false) {
+    let arr = flat(obj, filter);
+    let entries = entryComparer.sort(arr);
+    return new Deep(entries);
+  }
+
+  /**
+   * @template T
+   * @param {{[_:string|number]:any}} obj 
+   * @returns {Deep<BehaviorSubject<T>>}
+   */
+  static fromBehaviorSubject(obj) {
+    return Deep.fromObject(obj, v => (0,external_rxjs_namespaceObject.isObservable)(v) || v instanceof external_rxjs_namespaceObject.Subscription).filter(([k, v]) => v instanceof external_rxjs_namespaceObject.BehaviorSubject);
+  }
+
+  /**
+   * @template T
+   * @param {{[_:string|number]:any}} obj 
+   * @returns 
+   */
+  static fromObservable(obj) {
+    return Deep.fromObject(obj, v => (0,external_rxjs_namespaceObject.isObservable)(v) || v instanceof external_rxjs_namespaceObject.Subscription).filter(([k, v]) => (0,external_rxjs_namespaceObject.isObservable)(v));
+  }
+}
+;// ./src/deep/0.js
+
+;// ./src/deep-rxjs/isRxType.js
+
+
+/**
+ * 检查对象是否为 RxJS 类型。
+ *
+ * `isRxType` 函数用于判断给定的对象是否为 RxJS 的 `Observable` 或 `Subscription` 类型。
+ *
+ * @param {any} obj - 要检查的对象。
+ * @returns {boolean} - 如果对象是 `Observable` 或 `Subscription`，返回 `true`；否则返回 `false`。
+ *
+ */
+function isRxType(obj) {
+  return typeof obj === 'object' && obj && ((0,external_rxjs_namespaceObject.isObservable)(obj) || obj instanceof external_rxjs_namespaceObject.Subscription);
+}
+;// ./src/deep-rxjs/ObservableArray.js
+
+
+
+
+/**
+ * ObservableArray 是一个可观察的数组，支持 insertBefore、removeChild、replaceChild 操作，
+ * 并通过 RxJS Subject 通知变化，适用于响应式 DOM 操作场景。
+ * 
+ * @template T
+ * @extends Array<T>
+ */
+class ObservableArray extends Array {
+  /**
+   * @constructor 创建一个 ObservableArray 实例。禁止传参。
+   * @param {()=>T} newItem
+   * @throws {Error} 如果传入参数则抛出异常。
+   */
+  constructor(newItem) {
+    super();
+    this.newitem = newItem;
+
+    /**
+     * 变化通知的 Subject。
+     * @type {Subject<any[]>}
+     */
+    this.action$ = new external_rxjs_namespaceObject.Subject();
+
+    /**
+     * 插入元素事件流，发出 [item, index]。
+     * @type {import('rxjs').Observable<[T, number]>}
+     */
+    this.insertBefore$ = this.action$.pipe((0,external_rxjs_namespaceObject.filter)(([action]) => action === 'insertBefore'), (0,external_rxjs_namespaceObject.map)(([_, item, index]) => [item, index]));
+
+    /**
+     * 删除元素事件流，发出 index。
+     * @type {import('rxjs').Observable<number>}
+     */
+    this.removeChild$ = this.action$.pipe((0,external_rxjs_namespaceObject.filter)(([action]) => action === 'removeChild'), (0,external_rxjs_namespaceObject.map)(([_, index]) => index));
+
+    /**
+     * 替换元素事件流，发出 [item, index]。
+     * @type {import('rxjs').Observable<[T, number]>}
+     */
+    this.replaceChild$ = this.action$.pipe((0,external_rxjs_namespaceObject.filter)(([action]) => action === 'replaceChild'), (0,external_rxjs_namespaceObject.map)(([_, item, index]) => [item, index]));
+  }
+
+  /**
+   * 在指定位置插入元素，并通知变化。
+   * @param {T} item 要插入的元素
+   * @param {number} [index=this.length] 插入位置，默认为数组末尾
+   */
+  insertBefore(item, index = this.length) {
+    arrayInsert(this, item, index);
+    this.action$.next(['insertBefore', item, index]);
+  }
+
+  /**
+   * 删除指定位置的元素，并通知变化。
+   * @param {number} [index=this.length-1] 删除位置，默认为数组末尾
+   */
+  removeChild(index = this.length - 1) {
+    arrayRemove(this, index);
+    this.action$.next(['removeChild', index]);
+  }
+
+  /**
+   * 替换指定位置的元素，并通知变化。
+   * @param {T} item 新元素
+   * @param {number} index 替换位置
+   */
+  replaceChild(item, index) {
+    this[index] = item;
+    this.action$.next(['replaceChild', item, index]);
+  }
+  /**
+   * 附加一个默认子元素
+   */
+  appendChild() {
+    this.insertBefore(this.newitem(), this.length);
+  }
+}
+;// ./src/deep-rxjs/0.js
+
+
+;// ./src/hyperscript-rxjs/displays/blockLevelFamily.js
+/**
+ * 一个包含所有 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
+ */
+const blockLevelFamily = new Set(['ADDRESS', 'ARTICLE', 'ASIDE', 'BLOCKQUOTE', 'DD', 'DETAILS', 'DIALOG', 'DIV', 'DL', 'DT', 'FIELDSET', 'FIGCAPTION', 'FIGURE', 'FOOTER', 'FORM', 'H1', 'H2', 'H3', 'H4', 'H5', 'H6', 'HEADER', 'HGROUP', 'HR', 'LI', 'MAIN', 'NAV', 'OL', 'P', 'PRE', 'SECTION', 'TABLE', 'UL']);
+;// ./src/hyperscript-rxjs/displays/inlineFamily.js
+/**
+ * 一个包含所有 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
+ */
+const inlineFamily = new Set(['A', 'ABBR', 'ACRONYM', 'AUDIO', 'B', 'BDI', 'BDO', 'BIG', 'BR', 'BUTTON', 'CANVAS', 'CITE', 'CODE', 'DATA', 'DATALIST', 'DEL', 'DFN', 'EM', 'EMBED', 'I', 'IFRAME', 'IMG', 'INPUT', 'INS', 'KBD', 'LABEL', 'MAP', 'MARK', 'METER', 'NOSCRIPT', 'OBJECT', 'OUTPUT', 'PICTURE', 'PROGRESS', 'Q', 'RUBY', 'S', 'SAMP', 'SCRIPT', 'SELECT', 'SLOT', 'SMALL', 'SPAN', 'STRONG', 'SUB', 'SUP', 'SVG', 'TEMPLATE', 'TEXTAREA', 'TIME', 'TT', 'U', 'VAR', 'VIDEO', 'WBR']);
+
+// developer.mozilla.org/en-US/docs/Web/HTML/Inline_elements
+;// ./src/hyperscript-rxjs/displays/getDisplay.js
+
+
+
+/**
+ * 获取 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'`
+ * 
+ */
+function getDisplay(elem) {
+  if (elem.tagName === 'TBODY') {
+    return 'table-row-group';
+  } else if (elem.tagName === 'THEAD') {
+    return 'table-header-group';
+  } else if (elem.tagName === 'TFOOT') {
+    return 'table-footer-group';
+  } else if (elem.tagName === 'TR') {
+    return 'table-row';
+  } else if (elem.tagName === 'TD' || elem.tagName === 'TH') {
+    return 'table-cell';
+  } else if (elem.tagName === 'COLGROUP') {
+    return 'table-column-group';
+  } else if (elem.tagName === 'COL') {
+    return 'table-column';
+  } else if (elem.tagName === 'CAPTION') {
+    return 'table-caption';
+  } else if (blockLevelFamily.has(elem.tagName)) {
+    return 'block';
+  } else if (inlineFamily.has(elem.tagName)) {
+    return 'inline';
+  } else {
+    return 'unset';
+  }
+}
+;// ./src/hyperscript-rxjs/displays/0.js
+
+
+
+;// ./src/nodes/attachSubscriptionToNode.js
+
+
+/**
+ * Attaches an RxJS subscription to a DOM node.
+ * @param {Node & { subscription?: Subscription }} elem - DOM node to attach the subscription to.
+ * @param {Subscription} subscription - RxJS subscription to attach.
+ * @throws {Error} If parameters are invalid.
+ */
+const attachSubscriptionToNode = (elem, subscription) => {
+  if (!(elem instanceof Node)) {
+    throw new Error('Valid DOM node required');
+  }
+  if (!(subscription instanceof external_rxjs_namespaceObject.Subscription)) {
+    throw new Error('Valid RxJS subscription required');
+  }
+
+  //新建或附加订阅
+  if (!elem.subscription) {
+    elem.subscription = subscription;
+  } else {
+    elem.subscription.add(subscription);
+  }
+};
+;// ./src/nodes/pipeEvent.js
+
+
+
+
+/**
+ * 为指定的 DOM 元素订阅事件流，并通过 pipe 对事件流进行处理。
+ *
+ * @param {HTMLElement} elem - 要订阅事件的 DOM 元素。
+ * @returns {(e:string,s:(event$: Observable<Event>) => Subscription)=>HTMLElement} - 返回一个函数，该函数接受事件名称和处理函数，用于订阅和处理事件。
+ * @throws {Error} 如果参数无效。
+ */
+function pipeEvent(elem) {
+  // 参数检查，确保 elem 是一个有效的 DOM 元素
+  if (!(elem instanceof HTMLElement)) {
+    throw new Error('参数 "elem" 必须是一个有效的 DOM 元素。');
+  }
+  return (
+    /**
+     * 
+     * @param {string} event 
+     * @param {(event$: Observable<Event>) => Subscription} subscriber 
+     * @returns 
+     */
+    function (event, subscriber) {
+      // 参数检查，确保 event 是字符串，subscriber 是函数
+      if (typeof event !== 'string') {
+        throw new Error('参数 "event" 必须是一个字符串。');
+      }
+      if (typeof subscriber !== 'function') {
+        throw new Error('参数 "subscriber" 必须是一个函数。');
+      }
+      let event$ = (0,external_rxjs_namespaceObject.fromEvent)(elem, event); // 创建事件流 Observable
+
+      try {
+        let subscription = subscriber(event$); // 订阅事件流并处理           
+        attachSubscriptionToNode(elem, subscription); // 将订阅附加到 DOM 元素，便于管理
+      } catch (error) {
+        console.error(`处理事件 "${event}" 时发生错误:`, error);
+        throw error;
+      }
+
+      // 返回元素本身，支持链式调用
+      return elem;
+    }
+  );
+}
+;// ./src/nodes/subscribeEvent.js
+
+
+
+/**
+ * @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} 如果参数无效。
+ * 
+ */
+function subscribeEvent(elem) {
+  // 参数检查，确保 elem 是一个有效的 DOM 元素
+  if (!(elem instanceof HTMLElement)) {
+    throw new Error('参数 "elem" 必须是一个有效的 DOM 元素。');
+  }
+  return (
+    /**
+     * @param {string} event 
+     * @param {((value: Event) => void) | Partial<Observer<Event>>} observer
+     * @returns 
+     */
+    (event, observer) => {
+      // 参数检查，确保 event 是字符串，observer 是函数或观察者对象
+      if (typeof event !== 'string') {
+        throw new Error('参数 "event" 必须是一个字符串。');
+      }
+      if (typeof observer !== 'function' && typeof observer !== 'object' || observer === null) {
+        throw new Error('参数 "observer" 必须是一个函数或观察者对象。');
+      }
+
+      // 创建事件流 Observable
+      let event$ = (0,external_rxjs_namespaceObject.fromEvent)(elem, event);
+
+      // 订阅事件流
+      let subscription;
+      try {
+        subscription = event$.subscribe(observer);
+      } catch (error) {
+        console.error(`订阅事件 "${event}" 时发生错误:`, error);
+        throw error;
+      }
+
+      // 将订阅附加到 DOM 元素，便于管理
+      attachSubscriptionToNode(elem, subscription);
+
+      // 返回元素本身，支持链式调用
+      return elem;
+    }
+  );
+}
+;// ./src/nodes/parseHyperscriptArgs.js
+/**
+ * 解析 hyperscript 风格的参数，返回 props 和 childNodes。
+ * 
+ * @param {any[]} args - hyperscript 风格的参数数组。
+ * @returns {{ props: Record<string, any>, childNodes: any[] }} 包含 props（对象）和 childNodes（数组）的对象。
+ * @throws 如果参数不是数组会抛出错误。
+ */
+
+function parseHyperscriptArgs(args) {
+  // 参数验证，确保 args 是一个数组
+  if (!Array.isArray(args)) {
+    throw new Error('参数 "args" 必须是一个数组。');
+  }
+  if (args.length === 0) {
+    return {
+      props: {},
+      childNodes: []
+    };
+  } else {
+    let [first, ...rest] = args;
+
+    // 
+    if (isProps(first)) {
+      return {
+        props: first ? first : {},
+        childNodes: rest
+      };
+    } else {
+      // 如果第一个参数不是对象，则所有参数作为子节点
+      return {
+        props: {},
+        childNodes: args
+      };
+    }
+  }
+}
+
+/**
+ * 如果第一个参数是 undefined、null 或普通对象（非数组），则返回 true。
+ * 否则返回 false。
+ * @param {unknown} value - 要检查的值
+ * @returns {boolean}
+ * 
+ */
+function isProps(value) {
+  //// 基本检查: 空作为props的占位符（不建议，作为兼容）
+  if (value === undefined || value === null) {
+    return true;
+  }
+
+  // 基本检查：非对象直接返回false
+  if (typeof value !== 'object') {
+    return false;
+  }
+
+  // 检查原型链
+  const proto = Object.getPrototypeOf(value);
+
+  // 1. 原型为null（如Object.create(null)创建的对象）
+  // 2. 原型等于Object.prototype（普通对象）
+  return proto === null || proto === Object.prototype;
+}
+;// ./src/nodes/normalizeChildNodes.js
+
+
+/**
+ * 规范化子节点，将非节点转换为文本节点。
+ *
+ * @param {any[]} childNodes - 子节点数组。
+ * @returns {Node[]} - 返回规范化后的节点数组。
+ */
+function normalizeChildNodes(childNodes) {
+  const normalizedNodes = unwrapArgs(childNodes); // 解构子节点数组
+
+  return normalizedNodes.map(child => child instanceof Node ? child : document.createTextNode(String(child)) // 将非节点转换为文本节点
+  );
+}
+;// ./src/object/splitObjectByObservable.js
+
+
+/**
+ * 将对象属性按类型分为两部分：可观察对象（Observable）与普通值（非 Observable）。
+ *
+ * @param {Record<string,any>} obj - 要分割的对象，其属性值可能是 Observable 或普通值。
+ * @returns {[Record<string, Observable<any>>, Record<string, any>]} - 返回一个数组，第一个对象包含所有 Observable 属性，第二个对象包含所有非 Observable 属性。
+ * @throws {Error} 如果参数不是一个非空对象。
+ */
+function splitObjectByObservable(obj) {
+  // 参数检查，确保输入是一个非空对象
+  if (typeof obj !== 'object' || Array.isArray(obj) || obj === null) {
+    throw new Error('参数 "obj" 必须是一个非空对象。');
+  }
+
+  /**
+   * @type {Record<string, Observable<any>>}
+   */
+  let observables = {}; // 存储 Observable 属性
+
+  /**
+   * @type {Record<string, any>}
+   */
+  let scalars = {}; // 存储非 Observable 属性
+
+  // 遍历对象的所有属性
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      let value = obj[key];
+
+      // 根据值的类型分类
+      if ((0,external_rxjs_namespaceObject.isObservable)(value)) {
+        observables[key] = value; // 如果是 Observable，存入 observables
+      } else {
+        scalars[key] = value; // 否则存入 scalars
+      }
+    }
+  }
+  //可观察对象（Observable）与普通值（非 Observable）
+  return [observables, scalars];
+}
+;// ./src/props/getNestedProperty.js
+/**
+ * 根据属性路径数组读取对象的嵌套属性值。
+ * @param {Record<string | number, any>} obj - 要读取属性的对象。
+ * @param {(string | number)[]} keyPath - 属性路径数组，例如 ['a', 'b'] 表示 obj.a.b。
+ * @returns {any} - 返回目标属性的值，如果路径为空数组，则返回对象本身。
+ * @throws {Error} 如果路径中的某一级属性不存在或输入无效。
+ */
+function getNestedProperty(obj, keyPath) {
+  if (!Array.isArray(keyPath)) {
+    throw new Error('The "pathArray" parameter must be an array.');
+  }
+  if (!obj || typeof obj !== 'object') {
+    throw new Error('The "obj" parameter must be a non-null object.');
+  }
+  return keyPath.reduce((currentObj, key) => {
+    if (currentObj === null || currentObj === undefined) {
+      throw new Error(`Cannot read property "${key}" of null or undefined.`);
+    }
+    if (typeof key === 'string' && typeof currentObj === 'object' && key in currentObj) {
+      return /** @type {Record<string, any>} */currentObj[key];
+    } else if (typeof key === 'number' && Array.isArray(currentObj) && key >= 0 && key < currentObj.length) {
+      return currentObj[key];
+    } else {
+      throw new Error(`Property "${key}" does not exist on the object.`);
+    }
+  }, obj);
+}
+;// ./src/props/parsePropName.js
+
+
+/**
+ * 解析嵌套的 DOM 属性路径，并返回目标对象和属性名。
+ *
+ * @param {string} props - 属性路径，是 DOM API 的属性，不需要引号包裹，支持嵌套属性（如 "style.color"）。
+ * @param {Record<string, any>} obj - 起始对象，通常是一个 DOM 元素。
+ * @returns {[Record<string, any>, string]} - 返回一个数组，表示叶节点，其中第一个元素是目标对象，第二个元素是属性名。（如 [obj.style, "color"]）。
+ * @throws {Error} 如果路径中的某一级属性不存在或输入无效。
+ */
+function parsePropName(props, obj) {
+  if (typeof props !== 'string') {
+    throw new Error('The "prop" parameter must be a string.');
+  }
+
+  /**
+   * @param {any} target
+   * @param {string} prop
+   * @returns {[any, string]}
+   */
+  function getTargetAndProp(target, prop) {
+    if (!target || typeof target !== 'object') {
+      throw new Error('The "obj" parameter must be a non-null object.');
+    }
+    if (!(prop in target)) {
+      throw new Error(`Property "${prop}" does not exist on the target object.`);
+    }
+    return [target, prop];
+  }
+  if (props.includes('.')) {
+    const pathArray = props.split('.');
+    const prop = pathArray.pop();
+    if (!prop) {
+      throw new Error('The "prop" parameter must be a non-empty string.');
+    }
+    const target = getNestedProperty(obj, pathArray);
+    return getTargetAndProp(target, prop);
+  } else {
+    return getTargetAndProp(obj, props);
+  }
+}
+;// ./src/props/setProp.js
+
+
+/**
+ * 
+ * 设置一个元素对象的任意嵌套路径属性的值，如果是CSS类名，值为真则添加类名，值为假则移除类名。如果是普通属性或嵌套属性则设置改属性值。
+ *
+ * @param {HTMLElement} root - 要设置属性的 DOM 元素。
+ * @param {string} key - 属性名称，支持普通属性、嵌套属性（如 "style.color"）或以 "." 开头的类名（如 ".active"）。
+ * @param {*} value - 要设置的属性值。如果是布尔值，用于控制类名的添加或移除。
+ * @returns {HTMLElement} - 返回元素本身，支持链式调用。
+ * @throws {Error} 如果参数无效或设置失败。
+ * 
+ */
+function setProp(root, key, value) {
+  if (!(root instanceof HTMLElement)) {
+    throw new Error('The "element" parameter must be a valid DOM element.');
+  }
+  if (typeof key !== 'string') {
+    throw new Error('The "key" parameter must be a string.');
+  }
+
+  // CSS 类名操作
+  if (key.charAt(0) === '.') {
+    const className = key.substring(1);
+    if (className.length === 0) {
+      throw new Error('The class name cannot be empty.');
+    }
+    if (value) {
+      root.classList.add(className); // 添加类名
+    } else {
+      root.classList.remove(className); // 移除类名
+    }
+  } else {
+    // 普通属性或嵌套属性设置
+    const [target, prop] = parsePropName(key, root); // 解析属性路径
+    target[prop] = value; // 设置属性值
+  }
+  return root; // 返回元素本身，支持链式调用
+}
+;// ./src/props/subscribeProp.js
+
+
+
+
+
+/**
+ * 
+ * 订阅一个 BehaviorSubject，将其发出的值动态设置为指定 DOM 元素的属性值。
+ * 
+ * @template T
+ * @param {HTMLElement} element - 要设置属性的 DOM 元素。
+ * @param {string} key - 属性名称，支持普通属性、嵌套属性（如 "style.color"）或以 "." 开头的类名（如 ".active"）。
+ * @param {Observable<T>} value$ - 一个 RxJS Observable ，用于发出属性值。
+ * @returns {HTMLElement} - 返回元素本身，支持链式调用。
+ * @throws {Error} 如果参数无效或订阅失败。
+ */
+function subscribeProp(element, key, value$) {
+  // 参数检查，确保输入有效
+  if (!(element instanceof HTMLElement)) {
+    throw new Error('参数 "element" 必须是一个有效的 DOM 元素。');
+  }
+  if (typeof key !== 'string') {
+    throw new Error('参数 "key" 必须是一个字符串。');
+  }
+  if (!(0,external_rxjs_namespaceObject.isObservable)(value$)) {
+    throw new Error('参数 "value$" 必须是一个有效的 Observable。');
+  }
+
+  // 创建订阅，将 BehaviorSubject 的值动态设置为元素的属性
+  const subscription = value$.pipe((0,external_rxjs_namespaceObject.startWith)(0)).subscribe({
+    next: value => {
+      setProp(element, key, value);
+    },
+    error: e => {
+      setProp(element, key, e.message);
+    }
+  });
+
+  // 将订阅附加到 DOM 节点，便于统一管理
+  attachSubscriptionToNode(element, subscription);
+
+  // 返回元素本身，支持链式调用
+  return element;
+}
+;// ./src/props/setProps.js
+
+
+
+
+/**
+ * 为 DOM 元素设置属性，包括静态属性和动态属性（Observable）。
+ *
+ * @param {HTMLElement} element - 要设置属性的 DOM 元素。
+ * @param {Object} props - 包含属性键值对的对象，其中值可以是普通值或 Observable。
+ * @returns {HTMLElement} - 返回元素本身，支持链式调用。
+ * @throws {Error} 如果参数无效或设置属性失败。
+ */
+function setProps(element, props) {
+  // 参数检查
+  if (!(element instanceof HTMLElement)) {
+    throw new Error('参数 "element" 必须是一个有效的 DOM 元素。');
+  }
+  if (typeof props !== 'object' || props === null) {
+    throw new Error('参数 "props" 必须是一个非空对象。');
+  }
+
+  // 将属性分为 Observable 和普通值
+  const [observables, scalars] = splitObjectByObservable(props);
+
+  // 设置普通属性
+  Object.entries(scalars).forEach(([key, value]) => {
+    try {
+      setProp(element, key, value);
+    } catch (error) {
+      console.error(`设置属性 "${key}" 时发生错误:`, error);
+    }
+  });
+
+  // 注意顺序，订阅动态属性要在设置静态属性之后
+  Object.entries(observables).forEach(([key, value$]) => {
+    try {
+      subscribeProp(element, key, value$);
+    } catch (error) {
+      console.error(`订阅属性 "${key}" 时发生错误:`, error);
+    }
+  });
+
+  // 返回元素本身，支持链式调用
+  return element;
+}
+;// ./src/hyperscript-rxjs/hyperscript.js
+
+
+
+
+
+
+
+/**
+ * @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
+ */
+function hyperscript(elemName, ...args) {
+  // 参数验证，确保 elemName 是一个有效的字符串
+  if (typeof elemName !== 'string' || !tagNames.has(elemName)) {
+    throw new Error(`参数 elemName 不是一个有效的 HTML 元素标签名。`);
+  }
+
+  // 创建 HTML 元素
+
+  let element = document.createElement(elemName);
+
+  // 解析传入的参数
+  const {
+    props,
+    childNodes
+  } = parseHyperscriptArgs(args);
+
+  // 设置元素属性
+  setProps(element, props);
+
+  // 添加子节点
+  normalizeChildNodes(childNodes).forEach(child => {
+    element.appendChild(child); // 将子节点附加到元素
+  });
+  Object.assign(element, {
+    /**
+     * 
+     * @param {string} event 
+     * @param {(event$: Observable<Event>) => Subscription} subscriber 
+     */
+    pipeEvent(event, subscriber) {
+      return pipeEvent(element)(event, subscriber);
+    },
+    /**
+     * 
+     * @param {string} event 
+     * @param {((value: Event) => void) | import('rxjs').Observer<Event>} observer 
+     */
+    subscribeEvent(event, observer) {
+      return subscribeEvent(element)(event, observer);
+    },
+    unsubscribe() {
+      if ('subscription' in element && element.subscription instanceof external_rxjs_namespaceObject.Subscription) {
+        element.subscription.unsubscribe(); // 取消订阅
+        delete element.subscription; // 删除属性
+      }
+    }
+  });
+  return /** @type {HyperscriptElement} */element; // 返回创建的元素
+}
+const tagNames = new Set(["a", "abbr", "address", "area", "article", "aside", "audio", "b", "bdi", "bdo", "blockquote", "br", "button", "caption", "cite", "code", "col", "colgroup", "data", "datalist", "dd", "del", "details", "dfn", "dialog", "div", "dl", "dt", "em", "fieldset", "figcaption", "figure", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6", "header", "hgroup", "hr", "i", "img", "input", "ins", "kbd", "label", "legend", "li", "main", "mark", "menu", "menuitem", "meter", "nav", "ol", "optgroup", "option", "output", "p", "pre", "progress", "q", "rb", "rp", "rt", "rtc", "ruby", "s", "samp", "section", "select", "small", "span", "strong", "sub", "summary", "sup", "table", "tbody", "td", "textarea", "tfoot", "th", "thead", "time", "tr", "track", "tt", "u", "ul", "video", "wbr"]);
+;// ./src/hyperscript-rxjs/tags.js
+
+
+/**
+ * @template {HTMLElement} T
+ * @typedef {import("./HyperscriptExtensions.d.ts").HyperscriptExtensions<T>} HyperscriptExtensions
+ */
+
+/**
+ * 创建 <a> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLAnchorElement>}
+ */
+const a = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLAnchorElement>} */hyperscript('a', props, ...childNodes));
+
+/**
+ * 创建 <abbr> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const abbr = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('abbr', props, ...childNodes));
+
+/**
+ * 创建 <address> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const address = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('address', props, ...childNodes));
+
+/**
+ * 创建 <area> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLAreaElement>}
+ */
+const tags_area = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLAreaElement>} */hyperscript('area', props, ...childNodes));
+
+/**
+ * 创建 <article> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const article = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('article', props, ...childNodes));
+
+/**
+ * 创建 <aside> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const aside = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('aside', props, ...childNodes));
+
+/**
+ * 创建 <audio> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLAudioElement>}
+ */
+const audio = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLAudioElement>} */hyperscript('audio', props, ...childNodes));
+
+/**
+ * 创建 <b> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const b = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('b', props, ...childNodes));
+
+/**
+ * 创建 <bdi> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const bdi = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('bdi', props, ...childNodes));
+
+/**
+ * 创建 <bdo> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const bdo = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('bdo', props, ...childNodes));
+
+/**
+ * 创建 <blockquote> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLQuoteElement>}
+ */
+const blockquote = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLQuoteElement>} */hyperscript('blockquote', props, ...childNodes));
+
+/**
+ * 创建 <br> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLBRElement>}
+ */
+const br = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLBRElement>} */hyperscript('br', props, ...childNodes));
+
+/**
+ * 创建 <button> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLButtonElement>}
+ */
+const tags_button = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLButtonElement>} */hyperscript('button', props, ...childNodes));
+
+/**
+ * 创建 <caption> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const caption = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('caption', props, ...childNodes));
+
+/**
+ * 创建 <cite> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const cite = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('cite', props, ...childNodes));
+
+/**
+ * 创建 <code> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const code = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('code', props, ...childNodes));
+
+/**
+ * 创建 <col> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLTableColElement>}
+ */
+const col = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLTableColElement>} */hyperscript('col', props, ...childNodes));
+
+/**
+ * 创建 <colgroup> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLTableColElement>}
+ */
+const colgroup = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLTableColElement>} */hyperscript('colgroup', props, ...childNodes));
+
+/**
+ * 创建 <data> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLDataElement>}
+ */
+const data = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLDataElement>} */hyperscript('data', props, ...childNodes));
+
+/**
+ * 创建 <datalist> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLDataListElement>}
+ */
+const datalist = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLDataListElement>} */hyperscript('datalist', props, ...childNodes));
+
+/**
+ * 创建 <dd> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const dd = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('dd', props, ...childNodes));
+
+/**
+ * 创建 <del> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLModElement>}
+ */
+const del = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLModElement>} */hyperscript('del', props, ...childNodes));
+
+/**
+ * 创建 <details> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLDetailsElement>}
+ */
+const details = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLDetailsElement>} */hyperscript('details', props, ...childNodes));
+
+/**
+ * 创建 <dfn> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const dfn = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('dfn', props, ...childNodes));
+
+/**
+ * 创建 <dialog> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLDialogElement>}
+ */
+const dialog = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLDialogElement>} */hyperscript('dialog', props, ...childNodes));
+
+/**
+ * 创建 <div> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLDivElement>}
+ */
+const div = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLDivElement>} */hyperscript('div', props, ...childNodes));
+
+/**
+ * 创建 <dl> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLDListElement>}
+ */
+const dl = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLDListElement>} */hyperscript('dl', props, ...childNodes));
+
+/**
+ * 创建 <dt> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const dt = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('dt', props, ...childNodes));
+
+/**
+ * 创建 <em> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const em = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('em', props, ...childNodes));
+
+/**
+ * 创建 <fieldset> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLFieldSetElement>}
+ */
+const fieldset = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLFieldSetElement>} */hyperscript('fieldset', props, ...childNodes));
+
+/**
+ * 创建 <figcaption> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const figcaption = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('figcaption', props, ...childNodes));
+
+/**
+ * 创建 <figure> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const figure = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('figure', props, ...childNodes));
+
+/**
+ * 创建 <footer> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const footer = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('footer', props, ...childNodes));
+
+/**
+ * 创建 <form> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLFormElement>}
+ */
+const tags_form = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLFormElement>} */hyperscript('form', props, ...childNodes));
+
+/**
+ * 创建 <h1> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLHeadingElement>}
+ */
+const h1 = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLHeadingElement>} */hyperscript('h1', props, ...childNodes));
+
+/**
+ * 创建 <h2> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLHeadingElement>}
+ */
+const h2 = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLHeadingElement>} */hyperscript('h2', props, ...childNodes));
+
+/**
+ * 创建 <h3> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLHeadingElement>}
+ */
+const h3 = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLHeadingElement>} */hyperscript('h3', props, ...childNodes));
+
+/**
+ * 创建 <h4> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLHeadingElement>}
+ */
+const h4 = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLHeadingElement>} */hyperscript('h4', props, ...childNodes));
+
+/**
+ * 创建 <h5> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLHeadingElement>}
+ */
+const h5 = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLHeadingElement>} */hyperscript('h5', props, ...childNodes));
+
+/**
+ * 创建 <h6> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLHeadingElement>}
+ */
+const h6 = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLHeadingElement>} */hyperscript('h6', props, ...childNodes));
+
+/**
+ * 创建 <header> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const header = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('header', props, ...childNodes));
+
+/**
+ * 创建 <hgroup> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const hgroup = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('hgroup', props, ...childNodes));
+
+/**
+ * 创建 <hr> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLHRElement>}
+ */
+const hr = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLHRElement>} */hyperscript('hr', props, ...childNodes));
+
+/**
+ * 创建 <i> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const i = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('i', props, ...childNodes));
+
+/**
+ * 创建 <img> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLImageElement>}
+ */
+const img = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLImageElement>} */hyperscript('img', props, ...childNodes));
+
+/**
+ * 创建 <input> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLInputElement>}
+ */
+const input = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLInputElement>} */hyperscript('input', props, ...childNodes));
+
+/**
+ * 创建 <ins> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLModElement>}
+ */
+const ins = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLModElement>} */hyperscript('ins', props, ...childNodes));
+
+/**
+ * 创建 <kbd> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const kbd = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('kbd', props, ...childNodes));
+
+/**
+ * 创建 <label> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLLabelElement>}
+ */
+const label = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLLabelElement>} */hyperscript('label', props, ...childNodes));
+
+/**
+ * 创建 <legend> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLLegendElement>}
+ */
+const legend = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLLegendElement>} */hyperscript('legend', props, ...childNodes));
+
+/**
+ * 创建 <li> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLLIElement>}
+ */
+const li = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLLIElement>} */hyperscript('li', props, ...childNodes));
+
+/**
+ * 创建 <main> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const main = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('main', props, ...childNodes));
+
+/**
+ * 创建 <mark> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const mark = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('mark', props, ...childNodes));
+
+/**
+ * 创建 <menu> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLMenuElement>}
+ */
+const menu = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLMenuElement>} */hyperscript('menu', props, ...childNodes));
+
+/**
+ * 创建 <menuitem> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const menuitem = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('menuitem', props, ...childNodes));
+
+/**
+ * 创建 <meter> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLMeterElement>}
+ */
+const meter = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLMeterElement>} */hyperscript('meter', props, ...childNodes));
+
+/**
+ * 创建 <nav> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const nav = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('nav', props, ...childNodes));
+
+/**
+ * 创建 <ol> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLOListElement>}
+ */
+const ol = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLOListElement>} */hyperscript('ol', props, ...childNodes));
+
+/**
+ * 创建 <optgroup> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLOptGroupElement>}
+ */
+const optgroup = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLOptGroupElement>} */hyperscript('optgroup', props, ...childNodes));
+
+/**
+ * 创建 <option> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLOptionElement>}
+ */
+const tags_option = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLOptionElement>} */hyperscript('option', props, ...childNodes));
+
+/**
+ * 创建 <output> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLOutputElement>}
+ */
+const output = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLOutputElement>} */hyperscript('output', props, ...childNodes));
+
+/**
+ * 创建 <p> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLParagraphElement>}
+ */
+const p = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLParagraphElement>} */hyperscript('p', props, ...childNodes));
+
+/**
+ * 创建 <pre> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLPreElement>}
+ */
+const pre = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLPreElement>} */hyperscript('pre', props, ...childNodes));
+
+/**
+ * 创建 <progress> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLProgressElement>}
+ */
+const progress = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLProgressElement>} */hyperscript('progress', props, ...childNodes));
+
+/**
+ * 创建 <q> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLQuoteElement>}
+ */
+const q = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLQuoteElement>} */hyperscript('q', props, ...childNodes));
+
+/**
+ * 创建 <rb> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const rb = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('rb', props, ...childNodes));
+
+/**
+ * 创建 <rp> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const rp = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('rp', props, ...childNodes));
+
+/**
+ * 创建 <rt> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const rt = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('rt', props, ...childNodes));
+
+/**
+ * 创建 <rtc> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const rtc = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('rtc', props, ...childNodes));
+
+/**
+ * 创建 <ruby> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const ruby = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('ruby', props, ...childNodes));
+
+/**
+ * 创建 <s> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const s = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('s', props, ...childNodes));
+
+/**
+ * 创建 <samp> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const samp = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('samp', props, ...childNodes));
+
+/**
+ * 创建 <section> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const section = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('section', props, ...childNodes));
+
+/**
+ * 创建 <small> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const small = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('small', props, ...childNodes));
+
+/**
+ * 创建 <span> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLSpanElement>}
+ */
+const span = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLSpanElement>} */hyperscript('span', props, ...childNodes));
+
+/**
+ * 创建 <strong> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const strong = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('strong', props, ...childNodes));
+
+/**
+ * 创建 <sub> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const sub = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('sub', props, ...childNodes));
+
+/**
+ * 创建 <summary> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const summary = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('summary', props, ...childNodes));
+
+/**
+ * 创建 <sup> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const sup = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('sup', props, ...childNodes));
+
+/**
+ * 创建 <table> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLTableElement>}
+ */
+const table = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLTableElement>} */hyperscript('table', props, ...childNodes));
+
+/**
+ * 创建 <tbody> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLTableSectionElement>}
+ */
+const tbody = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLTableSectionElement>} */hyperscript('tbody', props, ...childNodes));
+
+/**
+ * 创建 <td> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLTableCellElement>}
+ */
+const td = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLTableCellElement>} */hyperscript('td', props, ...childNodes));
+
+/**
+ * 创建 <tfoot> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLTableSectionElement>}
+ */
+const tfoot = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLTableSectionElement>} */hyperscript('tfoot', props, ...childNodes));
+
+/**
+ * 创建 <th> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLTableCellElement>}
+ */
+const th = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLTableCellElement>} */hyperscript('th', props, ...childNodes));
+
+/**
+ * 创建 <thead> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLTableSectionElement>}
+ */
+const thead = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLTableSectionElement>} */hyperscript('thead', props, ...childNodes));
+
+/**
+ * 创建 <time> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLTimeElement>}
+ */
+const time = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLTimeElement>} */hyperscript('time', props, ...childNodes));
+
+/**
+ * 创建 <tr> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLTableRowElement>}
+ */
+const tr = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLTableRowElement>} */hyperscript('tr', props, ...childNodes));
+
+/**
+ * 创建 <track> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLTrackElement>}
+ */
+const track = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLTrackElement>} */hyperscript('track', props, ...childNodes));
+
+/**
+ * 创建 <tt> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const tt = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('tt', props, ...childNodes));
+
+/**
+ * 创建 <u> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const u = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('u', props, ...childNodes));
+
+/**
+ * 创建 <ul> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLUListElement>}
+ */
+const ul = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLUListElement>} */hyperscript('ul', props, ...childNodes));
+
+/**
+ * 创建 <video> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLVideoElement>}
+ */
+const video = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLVideoElement>} */hyperscript('video', props, ...childNodes));
+
+/**
+ * 创建 <wbr> 元素
+ * @param {{ [_: string]: any }} [props] - 元素属性
+ * @param {...any} childNodes - 子节点
+ * @returns {HyperscriptExtensions<HTMLElement>}
+ */
+const wbr = (props, ...childNodes) => (/** @type {HyperscriptExtensions<HTMLElement>} */hyperscript('wbr', props, ...childNodes));
+;// ./src/hyperscript-rxjs/tabControls/tabRoot.js
+
+
+/**
+ * 选项卡组件的基础框架。
+ *
+ * `tabRoot` 函数生成一个包含导航栏和内容面板的容器结构，
+ * 用于构建选项卡组件的基础部分。
+ *
+ * @param {Object} props - 传递给根容器 `<div>` 的属性（如 `id`、`className` 等）。
+ * @returns {HTMLElement} - 返回一个包含导航栏和内容面板的 `<div>` 元素。
+ *
+ */
+function tabRoot(props) {
+  // <div>
+  //     <ul class="nav nav-tabs"></ul>
+  //     <div class="tab-content"></div>
+  // </div>
+  return div(props, ul({
+    className: 'nav nav-tabs'
+  }), div({
+    className: 'tab-content'
+  }));
+}
+;// ./src/hyperscript-rxjs/tabControls/tabNavItem.js
+
+
+/**
+ * 选项卡的导航按钮。
+ *
+ * `tabNavItem` 函数生成一个选项卡的导航按钮，通常用于选项卡的导航栏中。
+ *
+ * @param {...(string|HTMLElement)} source - 按钮的内容，可以是字符串或 HTML 元素。
+ * @returns {HTMLElement} - 返回一个带有 `nav-item` 样式类的 `<li>` 元素，内部包含一个按钮。
+ *
+ */
+function tabNavItem(...source) {
+  // <li class="nav-item">
+  //     <button type="button" class="btn btn-link nav-link">
+  //        source
+  //     </button>
+  // </li>
+  return li({
+    className: 'nav-item'
+  }, tags_button({
+    type: 'button',
+    className: 'btn btn-link nav-link'
+  }, ...source));
+}
+;// ./src/hyperscript-rxjs/tabControls/tabPanel.js
+
+
+/**
+ * 选项卡的内容面板。
+ *
+ * `tabPanel` 函数生成一个选项卡的内容区域，用于显示与选项卡对应的内容。
+ *
+ * @param {...(string|HTMLElement)} source - 面板的内容，可以是字符串或 HTML 元素。
+ * @returns {HTMLElement} - 返回一个带有 `tab-pane` 样式类的 `<div>` 元素。
+ *
+ */
+function tabPanel(...source) {
+  // <div class="tab-pane">
+  //     source
+  // </div>
+  return div({
+    className: 'tab-pane'
+  }, ...source);
+}
+;// ./src/hyperscript-rxjs/tabControls/bindTabIndex.js
+
+
+
+/**
+ * 绑定选项卡的激活状态到 `tabIndex`。
+ *
+ * `bindTabIndex` 函数将选项卡的导航按钮和内容面板与 `tabIndex` 绑定，
+ * 实现动态切换选项卡的功能。
+ *
+ * @param {HTMLElement} tabRoot - 选项卡的根容器，包含导航栏和内容面板。
+ * @param {BehaviorSubject<number>} tabIndex$ - 表示当前激活选项卡索引的 BehaviorSubject。
+ *
+ */
+function bindTabIndex(tabRoot, tabIndex$) {
+  /**
+   * @typedef {import("../HyperscriptExtensions.d.ts").HyperscriptExtensions<HTMLElement>} HyperscriptElement
+   */
+
+  const navs = /** @type {HyperscriptElement} */tabRoot.firstChild; // 导航栏容器
+  const panels = /** @type {HyperscriptElement} */tabRoot.lastChild; // 内容面板容器
+
+  // 订阅 tabIndex，动态更新选项卡的激活状态
+  tabIndex$.subscribe(i => {
+    // 更新导航按钮的激活状态
+    Array.from(navs.childNodes).forEach((li, j) => {
+      const btn = /** @type {HTMLElement} */li.firstChild;
+      if (i === j) {
+        btn.classList.add('active');
+      } else {
+        btn.classList.remove('active');
+      }
+    });
+
+    // 更新内容面板的激活状态
+    Array.from(panels.childNodes).forEach((panel, j) => {
+      const classList = /** @type {HTMLElement} */panel.classList;
+      if (i === j) {
+        classList.add('active');
+      } else {
+        classList.remove('active');
+      }
+    });
+  });
+
+  // 监听导航按钮的点击事件，更新 tabIndex
+  navs.pipeEvent('click', click$ => click$.pipe((0,external_rxjs_namespaceObject.map)(e => Array.from(navs.childNodes).map(e => (/** @type {HTMLElement} */e.firstChild)).indexOf(/** @type {HTMLElement} */e.target)), (0,external_rxjs_namespaceObject.filter)(i => i > -1) // 过滤无效索引
+  ).subscribe(tabIndex$));
+}
+;// ./src/hyperscript-rxjs/tabControls/tabControl.js
+
+
+
+
+
+/**
+ * 创建静态选项卡组件。
+ *
+ * `tabControl` 函数生成一个静态选项卡组件，其中选项卡的数量和顺序是固定的。
+ * 每个选项卡由一个导航按钮和一个对应的内容面板组成。
+ *
+ * @param {{ tabIndex: BehaviorSubject<number>, [key: string]: any}} props - 选项卡组件的属性。
+ * @param {Array<string|HTMLElement>} tabs - 导航按钮的内容数组，可以是字符串或 HTML 元素。
+ * @param {Array<string|HTMLElement>} panels - 内容面板的内容数组，可以是字符串或 HTML 元素。
+ * @returns {HTMLElement} - 返回一个包含导航栏和内容面板的选项卡组件。
+ */
+function tabControl(props, tabs, panels) {
+  const {
+    tabIndex,
+    ...rootProps
+  } = props;
+
+  // 创建选项卡的根容器
+  const root = tabRoot(rootProps);
+  const tablist = /** @type {HTMLElement} */root.firstChild; // 导航栏容器
+  const tabcontent = /** @type {HTMLElement} */root.lastChild; // 内容面板容器
+
+  // 创建导航按钮并添加到导航栏
+  tabs.map(tab => tabNavItem(tab)).forEach(item => tablist.appendChild(item));
+
+  // 创建内容面板并添加到内容区域
+  panels.map(panel => tabPanel(panel)).forEach(panel => tabcontent.appendChild(panel));
+
+  // 绑定选项卡的激活状态
+  bindTabIndex(root, tabIndex);
+  return root;
+}
+;// ./src/hyperscript-rxjs/tabControls/0.js
+
+
+
+
+
+;// ./src/hyperscript-rxjs/checkbox.js
+
+
+
+
+/**
+ * @typedef {import("./HyperscriptExtensions.d.ts").HyperscriptExtensions<HTMLInputElement>} HyperscriptInputElement
+ */
+
+/**
+ * 创建一个支持 RxJS 的复选框组件。
+ *
+ * @param {{checked?:BehaviorSubject<boolean>, [key: string]: any}} props - 复选框的属性对象。
+ * @returns {HyperscriptInputElement} - 返回一个复选框元素。
+ */
+function checkbox_checkbox(props) {
+  if (typeof props !== 'object' || props === null) {
+    throw new Error('`checkbox` requires a `props` object.');
+  }
+
+  // 创建复选框元素，确保 type 为 'checkbox'
+  const elem = /** @type {HyperscriptInputElement}*/input({
+    ...props,
+    type: 'checkbox'
+  });
+
+  // 如果传入了 checked 属性
+  if (props.checked && props.checked instanceof external_rxjs_namespaceObject.BehaviorSubject) {
+    // 监听复选框的 input 事件，并将选中状态推送到 Observable/Subject
+    let subscriber =
+    /**
+     * 
+     * @param {Observable<Event>} input$ 
+     * @returns 
+     */
+    input$ => input$.pipe((0,external_rxjs_namespaceObject.map)(e => /** @type {HTMLInputElement} */e.target.checked) // 提取复选框的选中状态
+    ).subscribe(props.checked); // 推送选中状态到 Observable/Subject
+
+    elem.pipeEvent('input', subscriber); // 绑定事件处理器
+  } else {
+    throw new Error('`checkbox` requires a `checked` prop that is an instance of BehaviorSubject.');
+  }
+  return elem; // 返回复选框元素
+}
+;// ./src/hyperscript-rxjs/collapse.js
+
+
+
+
+/**
+ * 显示或隐藏包含的元素。
+ * 
+ * `collapse` 函数通过绑定 `hidden` 属性，实现一组 HTML 元素的动态显示或隐藏。
+ * 
+ * @param {Observable<boolean>} hidden$ - 一个可观察对象（如 BehaviorSubject），用于控制元素的 `hidden` 属性。
+ * @param {...HTMLElement|HTMLElement[]} elements - 一个或多个 HTML 元素，或者包含 HTML 元素的数组。
+ * @returns {HTMLElement[]} - 处理后的元素数组。
+ * 
+ * @throws {Error} 如果 `elements` 中包含非元素节点（如 TextNode）。
+ * 
+ */
+function collapse(hidden$, ...elements) {
+  // 支持子元素包含在数组中：collapse([a, b, c]) 或 collapse(a, b, c)
+  let elems = unwrapArgs(elements);
+  elems.forEach(elem => {
+    if (!(elem instanceof HTMLElement)) {
+      throw new Error('`collapse` only supports HTMLElement nodes.');
+    }
+
+    // 绑定 hidden 属性到可观察对象
+    subscribeProp(elem, 'hidden', hidden$);
+  });
+  return elems;
+}
+;// ./src/hyperscript-rxjs/choice.js
+
+
+
+
+/**
+ * @param {Observable<string>} chosen$ 
+ * @param {Record<string, HTMLElement | HTMLElement[]>} possibilities 
+ * @returns {HTMLElement[]}
+ */
+function choice(chosen$, possibilities) {
+  // 遍历 possibilities，将每个可能性绑定到 collapse
+  const elems = Object.entries(possibilities).map(([key, possibility]) => {
+    const hidden$ = chosen$.pipe((0,external_rxjs_namespaceObject.map)(selectedKey => selectedKey !== key) // 如果当前选中的键不是当前可能性，则隐藏
+    );
+    return collapse(hidden$, possibility); // 绑定 hidden 属性
+  }).reduce((acc, cur) => [...acc, ...cur], []); // 扁平化数组
+
+  return elems;
+}
+;// ./src/hyperscript-rxjs/flip.js
+
+
+
+
+/**
+ * 动态切换两个元素或元素数组的显示状态。
+ *
+ * `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[]} - 包含所有元素的数组。
+ *
+ */
+function flip(yinHidden$, yin, yang) {
+  // 创建一个 Observable，用于控制 yangElement 的隐藏状态
+  const yangHidden$ = yinHidden$.pipe((0,external_rxjs_namespaceObject.map)(isHidden => !isHidden));
+
+  // 阴阳交叉
+  return [...collapse(yangHidden$, yin), ...collapse(yinHidden$, yang)];
+}
+;// ./src/hyperscript-rxjs/fragment.js
+
+
+/**
+ * 用途：插入一组元素，不必使用循环语句，fragment 用后即弃。
+ *
+ * @param {...Node|Node[]} childNodes - 要插入的子节点，可以是单个节点、多个节点或节点数组。
+ * @returns {DocumentFragment} - 返回包含所有子节点的 DocumentFragment。
+ * @throws {Error} 如果传入的子节点不是有效的 DOM 节点。
+ */
+function fragment(...childNodes) {
+  // 创建一个 DocumentFragment
+  const frag = new DocumentFragment();
+
+  // 验证并附加子节点
+  normalizeChildNodes(childNodes).forEach(child => {
+    frag.appendChild(child); // 将子节点附加到元素
+  });
+
+  // 返回 DocumentFragment
+  return frag;
+}
+;// ./src/hyperscript-rxjs/multiselect.js
+
+
+/**
+ * @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` 属性。
+ * 
+ */
+function multiselect(props, ...options) {
+  if (typeof props !== 'object' || props === null) {
+    throw new Error('`select` requires a `props` object.');
+  }
+  let {
+    oninput,
+    onchange,
+    ...rest
+  } = props;
+  let elem = hyperscript('select', {
+    ...rest,
+    multiple: true
+  }, ...options);
+  if (typeof oninput === 'function') {
+    elem.subscribeEvent('input', e => {
+      oninput(e);
+    });
+  }
+  if (typeof onchange === 'function') {
+    elem.subscribeEvent('change', e => {
+      onchange(e);
+    });
+  }
+  return /** @type {HyperscriptSelectElement} */elem;
+}
+;// ./src/hyperscript-rxjs/numberbox.js
+
+
+
+
+// import { fromEvent } from 'rxjs';
+// import { attachSubscriptionToNode } from '../../nodes/attachSubscriptionToNode';
+
+/**
+ * @internal
+ * @typedef {import("./HyperscriptInputElement.d.ts").HyperscriptInputElement} HyperscriptInputElement
+ */
+
+/**
+ * 创建一个支持双向绑定的数字输入框。
+ *
+ * `numberbox` 是一个自定义的输入框组件，支持通过 RxJS 的 `BehaviorSubject` 实现数字值的双向绑定。
+ * @public
+ * @param {{ number: BehaviorSubject<number>;  [key: string]: any;}} props - 配置对象，包含输入框的属性。
+ * @returns {HyperscriptInputElement} - 创建的数字输入框元素。
+ * @throws {Error} 如果 `props` 不是对象，或者 `number` 不是 `BehaviorSubject` 实例。
+ * 
+ */
+function numberbox(props) {
+  if (typeof props !== 'object' || props === null) {
+    throw new Error('`numberbox` requires a `props` object.');
+  }
+  let {
+    number,
+    ...rest
+  } = props;
+  let elem = /** @type {HyperscriptInputElement} */
+  input({
+    ...rest,
+    type: 'text'
+  });
+  if (number && number instanceof external_rxjs_namespaceObject.BehaviorSubject) {
+    let value = number.pipe((0,external_rxjs_namespaceObject.map)(n => String(n)));
+    subscribeProp(elem, 'value', value);
+    let subscriber =
+    /**
+     * 
+     * @param {Observable<Event>} blur$ 
+     * @returns 
+     */
+    blur$ => blur$.pipe((0,external_rxjs_namespaceObject.map)(e => Number(/** @type {HTMLInputElement} */
+    e.target.value))).subscribe(newValue => {
+      if (Number.isNaN(newValue)) {
+        elem.select();
+      } else if (number.value !== newValue) {
+        number.next(newValue);
+      }
+    });
+
+    // 展开pipeEvent是为了正确生成测试代码
+    // let event$ = fromEvent(elem, 'blur')// 创建事件流 Observable
+    // let subscription = blurSubscriber(event$); // 订阅事件流并处理           
+    // attachSubscriptionToNode(elem, subscription); // 将订阅附加到 DOM 元素，便于管理
+
+    elem.pipeEvent('blur', subscriber);
+  } else {
+    throw new Error('`numberbox` requires a `number` prop that is an instance of BehaviorSubject. ');
+  }
+
+  // 数字右对齐，用 style 可以获得最高优先级
+  elem.style.textAlign = 'right';
+  return elem;
+}
+;// ./src/hyperscript-rxjs/radio.js
+
+
+
+
+// import { fromEvent } from 'rxjs';
+// import { attachSubscriptionToNode } from '../../nodes/attachSubscriptionToNode';
+
+/**
+ * @internal
+ * @typedef {import("./HyperscriptInputElement.d.ts").HyperscriptInputElement} HyperscriptInputElement
+ */
+
+/**
+ * 单选按钮
+ * @public
+ * @param {{checked: BehaviorSubject<boolean>; [key: string]: any}} props 
+ * @returns {HyperscriptInputElement}
+ */
+function radio_radio(props) {
+  if (typeof props !== 'object' || props === null) {
+    throw new Error('`radio` requires a `props` object.');
+  }
+  const elem = /** @type {HyperscriptInputElement} */
+  input({
+    ...props,
+    type: 'radio'
+  });
+  if (props.checked && props.checked instanceof external_rxjs_namespaceObject.BehaviorSubject) {
+    const subscriber =
+    /**
+     * 
+     * @param {Observable<Event>} input$ 
+     * @returns 
+     */
+    input$ => input$.pipe((0,external_rxjs_namespaceObject.map)(e => /** @type {HTMLInputElement} */
+    e.target.checked)).subscribe(props.checked);
+    elem.pipeEvent('input', subscriber);
+
+    // 展开pipeEvent是为了正确生成测试代码
+    // let event$ = fromEvent(elem, 'input')// 创建事件流 Observable
+    // let subscription = subscriber(event$); // 订阅事件流并处理           
+    // attachSubscriptionToNode(elem, subscription); // 将订阅附加到 DOM 元素，便于管理
+  } else {
+    throw new Error('`radio` requires a `checked` prop that is an instance of BehaviorSubject. ');
+  }
+  return elem;
+}
+;// ./src/hyperscript-rxjs/select.js
+
+
+
+
+// import { fromEvent } from 'rxjs';
+// import { attachSubscriptionToNode } from '../nodes/attachSubscriptionToNode';
+
+/**
+ * @internal
+ * @typedef {import("./HyperscriptSelectElement.d.ts").HyperscriptSelectElement} HyperscriptSelectElement
+ */
+
+/**
+ * 创建一个支持 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。
+ */
+function select_select(props, ...options) {
+  if (typeof props !== 'object' || props === null) {
+    throw new Error('`select` requires a `props` object.');
+  }
+  let elem = /** @type {HyperscriptSelectElement} */
+  hyperscript('select', {
+    ...props,
+    multiple: false
+  }, ...options);
+
+  // todo: 显示判断属性是否传递了属性，('selectedIndex' in props)
+  let {
+    selectedIndex,
+    value
+  } = props;
+
+  // 确保至少有一个是 BehaviorSubject
+  if (elem.options.length > 0 && !(selectedIndex instanceof external_rxjs_namespaceObject.BehaviorSubject) && !(value instanceof external_rxjs_namespaceObject.BehaviorSubject)) {
+    throw new Error('`select` requires at least one of `selectedIndex` or `value` to be a BehaviorSubject.');
+  }
+  if (selectedIndex && selectedIndex instanceof external_rxjs_namespaceObject.BehaviorSubject) {
+    selectedIndex.subscribe(i => {
+      /** @type {HTMLOptionElement} */
+      elem[i].selected = true;
+    });
+    let subscriber =
+    /**
+     * @param {Observable<Event>} input$ 
+     */
+    input$ => input$.pipe((0,external_rxjs_namespaceObject.map)(e => /** @type {HTMLSelectElement} */
+    e.target.selectedIndex)).subscribe(selectedIndex);
+    elem.pipeEvent('input', subscriber);
+    // let event$ = fromEvent(elem, 'input');
+    // let subscription = subscriber(event$);
+    // attachSubscriptionToNode(elem, subscription);
+  }
+  if (value && value instanceof external_rxjs_namespaceObject.BehaviorSubject) {
+    value.subscribe(value => {
+      Array.from(elem.getElementsByTagName('option')).filter(opt => opt.value === value).forEach(opt => {
+        opt.selected = true;
+      });
+    });
+    let subscriber =
+    /**
+     * @param {Observable<Event>} input$ 
+     */
+
+    input$ => input$.pipe((0,external_rxjs_namespaceObject.map)(e => /** @type {HTMLSelectElement} */
+    e.target.value)).subscribe(value);
+    elem.pipeEvent('input', subscriber);
+    // let event$ = fromEvent(elem, 'input');
+    // let subscription = subscriber(event$);
+    // attachSubscriptionToNode(elem, subscription);
+  }
+  return elem;
+}
+;// ./src/hyperscript-rxjs/textarea.js
+
+
+
+
+/**
+ * @internal
+ * @typedef {import("./HyperscriptExtensions.d.ts").HyperscriptExtensions<HTMLTextAreaElement>} HyperscriptTextAreaElement
+ */
+
+/**
+ * 创建一个支持 RxJS 数据绑定的 <textarea> 元素。
+ * 
+ * @param {{value:BehaviorSubject<string>, [key:string]:any}} props - 配置对象，包含 <textarea> 元素的属性。
+ * @returns {HyperscriptTextAreaElement} - 创建的 <textarea> 元素。
+ * @throws {Error} 如果 `props` 不是对象，或者 `value` 不是 BehaviorSubject。
+ */
+function textarea_textarea(props) {
+  if (typeof props !== 'object' || props === null) {
+    throw new Error('`textarea` requires a `props` object.');
+  }
+  const {
+    value
+  } = props;
+  if (!(value instanceof external_rxjs_namespaceObject.BehaviorSubject)) {
+    throw new Error('`value` must be an instance of BehaviorSubject.');
+  }
+
+  // 创建 <textarea> 元素
+  const elem = /** @type {HyperscriptTextAreaElement} */hyperscript('textarea', props);
+
+  // 订阅输入事件并更新 BehaviorSubject
+  const subscriber =
+  /**
+   * 
+   * @param {Observable<Event>} input$ 
+   * @returns 
+   */
+  input$ => input$.pipe((0,external_rxjs_namespaceObject.map)(e => /** @type {HTMLTextAreaElement} */e.target.value)).subscribe(value);
+  elem.pipeEvent('input', subscriber);
+  return elem;
+}
+;// ./src/hyperscript-rxjs/textbox.js
+
+
+
+
+/**
+ * @internal
+ * @typedef {import("./HyperscriptInputElement.d.ts").HyperscriptInputElement} HyperscriptInputElement
+ */
+
+/**
+ * 创建一个支持 RxJS 数据绑定的 <input type="text"> 元素。
+ * 
+ * @param {{value: BehaviorSubject<string>, [key: string]: any}} props - 配置对象，包含 <input> 元素的属性。
+ * @returns {HyperscriptInputElement} - 创建的 <input type="text"> 元素。
+ * @throws {Error} 如果 `props` 不是对象，或者 `value` 不是 BehaviorSubject。
+ */
+function textbox(props) {
+  if (typeof props !== 'object' || props === null) {
+    throw new Error('`textbox` requires a `props` object.');
+  }
+  const {
+    value
+  } = props;
+  if (!(value instanceof external_rxjs_namespaceObject.BehaviorSubject)) {
+    throw new Error('`value` must be an instance of BehaviorSubject.');
+  }
+
+  // 创建 <input type="text"> 元素
+  const elem = /** @type {HyperscriptInputElement} */input({
+    ...props,
+    type: 'text'
+  });
+
+  // 订阅输入事件并更新 BehaviorSubject
+  const subscriber =
+  /**
+   * @param {Observable<Event>} input$ 
+   * @returns 
+   */
+  input$ => input$.pipe((0,external_rxjs_namespaceObject.map)(e => /** @type {HTMLInputElement} */e.target.value)).subscribe(value);
+  elem.pipeEvent('input', subscriber);
+  return elem;
+}
+;// ./src/hyperscript-rxjs/textNode.js
+
+
+
+/**
+ * @typedef {Text & {subscription?: Subscription, unsubscribe?: ()=>void}} ObservableTextNode
+ */
+
+/**
+ * 创建一个文本节点。
+ * 支持静态文本和动态更新的文本（通过 RxJS Observable）。
+ *
+ * - 如果传入的是字符串，则创建一个静态文本节点。
+ * - 如果传入的是 RxJS Observable，则创建一个动态文本节点，并根据 Observable 的值实时更新文本内容。
+ * - 动态文本节点支持通过 `unsubscribe` 方法取消订阅。
+ *
+ * @param {any} text Observable<any> | any。
+ * @returns {ObservableTextNode}
+ *
+ */
+function textNode(text) {
+  // 如果传入的是 Observable
+  if ((0,external_rxjs_namespaceObject.isObservable)(text)) {
+    const node = document.createTextNode("");
+
+    // 创建订阅并更新文本节点
+    const subscription = text.pipe((0,external_rxjs_namespaceObject.map)(d => String(d))).subscribe({
+      next(t) {
+        node.nodeValue = t;
+      },
+      error(err) {
+        node.nodeValue = `Error: ${err.message}`;
+      }
+    });
+    return Object.assign(node, {
+      subscription,
+      /**
+       * @this {ObservableTextNode}
+       */
+      unsubscribe() {
+        if (this.subscription) {
+          this.subscription.unsubscribe();
+          delete this.subscription; // 删除 subscription 成员
+          delete this.unsubscribe;
+        }
+      }
+    });
+  } else {
+    return document.createTextNode(String(text)); // 转换为字符串
+  }
+}
+;// ./src/hyperscript-rxjs/0.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+;// ./src/nodes/0.js
+
+
+
+
+
+;// ./src/object/intersectObject.js
+/**
+ * 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
+ */
+function intersectObject(obj, keys) {
+  // 类型检查
+  if (typeof obj !== 'object' || obj === null) {
+    throw new TypeError('First argument must be an object');
+  }
+  if (!Array.isArray(keys)) {
+    throw new TypeError('Second argument must be an array');
+  }
+  return Object.fromEntries(keys.filter(key => key in obj).map(key => [key, obj[key]]));
+}
+;// ./src/object/isPlainObject.js
+/**
+ * 检查一个值是否是普通对象（Plain Object）
+ * @param {unknown} value - 要检查的值
+ * @returns {value is object} - 返回是否是普通对象的类型谓词
+ */
+function isPlainObject(value) {
+  // 基本检查：非对象或为null的直接返回false
+  if (typeof value !== 'object' || value === null) {
+    return false;
+  }
+
+  // 检查原型链
+  const proto = Object.getPrototypeOf(value);
+
+  // 1. 原型为null（如Object.create(null)创建的对象）
+  // 2. 原型等于Object.prototype（普通对象）
+  return proto === null || proto === Object.prototype;
+}
+;// ./src/object/isEmptyObject.js
+
+
+/**
+ * 判断对象是否为空对象（非数组、非 null，且无自有属性）
+ * @param {unknown} obj - 要判断的对象
+ * @returns {obj is Record<never, never>} 类型谓词，确保类型收窄
+ */
+const isEmptyObject = obj => {
+  return isPlainObject(obj) && Object.keys(obj).length === 0;
+};
+;// ./src/object/nestedCombineLatest.js
+
+
+
+
+///对象格式的Observale，转化成扁平格式的数据后，整个数组外面Observable
+/**
+ * 
+ * @param {Record<string|number, any>} model 
+ * @returns {Observable<Record<string|number, any>>}
+ */
+function nestedCombineLatest(model) {
+  let deep = Deep.fromObservable(model);
+  return deep.combineLatest().pipe((0,external_rxjs_namespaceObject.map)(deep => deep.toObject()));
+}
+;// ./src/object/nestedMerge.js
+
+
+
+/**
+ * 
+ * @param {Record<string|number, any>} model 
+ * @returns {Observable<[(string | number)[], any]>}
+ */
+function nestedMerge(model) {
+  return Deep.fromObservable(model).merge();
+}
+;// ./src/object/pickBehaviorSubject.js
+
+
+
+
+
+/**
+ * 
+ * 拾取对象中的BehaviorSubject值，作爲葉子節點，忽略其他值。
+ * 
+ * @param {Record<string|number,any> & { pickeys?: string [] }} model - 输入的数据结构，可以是对象、数组或BehaviorSubject
+ * @returns {Record<string|number,any>} - 返回只包含BehaviorSubject当前值的结构
+ * @throws {Error} 当输入不包含任何BehaviorSubject或结构不符合预期时抛出错误
+ */
+function pickBehaviorSubject(model) {
+  let x = loop(model, '', null);
+  if (x.length === 1) {
+    return x[0][1];
+  } else {
+    throw new Error('pickBehaviorSubject');
+  }
+}
+
+/**
+ * 
+ * 递归遍历数据结构收集BehaviorSubject值
+ * 
+ * @param {any} value - 当前遍历的值
+ * @param {string|number} key - 当前键名
+ * @param {object|null} parent - 父级对象
+ * @returns {[string|number, any][]} - 返回收集到的键值对数组，每个元素是一个[key, value]元组
+ * @throws {Error} 当遇到不符合要求的数据结构时抛出错误
+ */
+function loop(value, key, parent) {
+  if ((0,external_rxjs_namespaceObject.isObservable)(value) && value instanceof external_rxjs_namespaceObject.BehaviorSubject) {
+    return [[key, value.value]]; //保存葉節點
+  } else if (value === null || typeof value !== 'object' || isRxType(value)) {
+    return [];
+  } else if (value instanceof ObservableArray) {
+    let v = [...value].map((e, i) => {
+      let pelem = loop(e, i, value);
+      if (pelem.length === 1) {
+        return pelem[0][1]; //表示元素是正常叶节点
+      } else {
+        throw new Error('dense Array'); //非正常叶节点，有洞
+      }
+    });
+    return [[key, v]];
+  } else if (value instanceof Array) {
+    if (value.length === 0) {
+      return []; //空不可变数组，将丢弃。
+    } else {
+      let v = value.map((e, i) => {
+        let pelem = loop(e, i, value);
+        if (pelem.length === 1) {
+          return pelem[0][1];
+        } else {
+          throw new Error('dense Array');
+        }
+      });
+      return [[key, v]];
+    }
+  } else if ('pickeys' in value) {
+    return loop(intersectObject(value, value.pickeys()), key, parent);
+  } else {
+    let entries = Object.entries(value);
+    if (entries.length === 0) {
+      return [];
+    } else {
+      let ee = entries.map(([k, v]) => loop(v, k, parent)).reduce((acc, val) => [...acc, ...val], []);
+      if (ee.length === 0) {
+        return [];
+      } else {
+        return [[key, Object.fromEntries(ee)]];
+      }
+    }
+  }
+}
+;// ./src/object/restore.js
+
+
+
+
+/**
+ * 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
+ */
+function restore(model, src) {
+  restore_loop(model, src);
+  // return model
+}
+
+/**
+ * Recursively updates model values from source
+ * @param {any & {appendChild?: (c:any) => void }} o - Current model node to update
+ * @param {any} src - Corresponding source value
+ */
+function restore_loop(o, src) {
+  if (o instanceof external_rxjs_namespaceObject.BehaviorSubject) {
+    // Input value
+    o.next(src);
+  } else if (o === null || typeof o !== 'object' || isRxType(o)) {
+    // noop
+  } else if (o instanceof ObservableArray) {
+    let len = o.length;
+    let diffcount = len - src.length;
+    if (diffcount > 0) {
+      // Truncate if longer
+      Array.from({
+        length: diffcount
+      }).map((e, i) => len - 1 - i).forEach(last => {
+        o.removeChild(last);
+      });
+    } else if (diffcount < 0) {
+      // Extend if shorter
+      Array.from({
+        length: -diffcount
+      }).map((e, i) => len + i).forEach(i => {
+        // Add an item to the end of an Array
+        o.appendChild();
+      });
+    }
+
+    // After alignment, update each element's value
+    for (let i of o.keys()) {
+      restore_loop(o[i], src[i]);
+    }
+  } else if (o instanceof Array) {
+    // Regular array, tuple
+    let indexes = o.length < src.length ? o : src;
+    // Ignore extra src elements, noop for missing elements
+    for (let i of indexes.keys()) {
+      // todo: Throw error when o[i] is not settable?
+      restore_loop(o[i], src[i]);
+    }
+  } else if (typeof o === 'object') {
+    // Recursively process object properties
+    Object.entries(o).filter(([k, v]) => k in src) // Intersection
+    .forEach(([k, v]) => {
+      restore_loop(v, src[k]);
+    });
+  }
+}
+;// ./src/object/0.js
+
+
+
+
+
+
+
+
+
+;// ./src/props/0.js
+
+
+
+
+
+;// ./src/ramda/compose.js
+/**
+ * 函数优先的管道组合工具（从右向左执行）
+ * @public
+ * @param {...((arg: any) => any)} fns - 要组合的函数列表
+ * @returns {(arg: any) => any} 组合后的函数（无参数时返回恒等函数 x => x）
+ * @throws {TypeError} 当参数包含非函数时抛出错误
+ */
+const compose = (...fns) => {
+  if (!fns || fns.length === 0) {
+    /** @param {*} x */
+    return x => x;
+  }
+  const firstNonFunctionIndex = fns.findIndex(fn => typeof fn !== 'function');
+  if (firstNonFunctionIndex !== -1) {
+    const invalidFn = fns[firstNonFunctionIndex];
+    const errorType = invalidFn === null ? 'null' : invalidFn === undefined ? 'undefined' : typeof invalidFn;
+    throw new TypeError(`所有参数必须是函数，但第 ${firstNonFunctionIndex} 个参数是: ${errorType}`);
+  }
+  if (fns.length === 1) {
+    return fns[0];
+  }
+
+  // 标注 args 类型
+  return fns.reduce((acc, fn) => /** @returns {*} */
+  (...args) => acc(fn(...args)));
+};
+;// ./src/ramda/cond.js
+/**
+ * 条件分支函数，依次判断分支并返回第一个匹配的结果。
+ *
+ * @public
+ * @param {Array<Function|[Function, Function]>} branches - 分支数组，每个分支可以是函数或 [谓词函数, 动作函数] 形式
+ * @returns {function(...*): *} 组合后的条件函数
+ */
+const cond = function cond(branches) {
+  /**
+   * @this any
+   */
+  return function () {
+    for (const branch of branches) {
+      if (typeof branch === 'function') {
+        let tryAction = branch.apply(this, arguments);
+        if (tryAction) {
+          return tryAction;
+        }
+      } else if (Array.isArray(branch)) {
+        let predicate = branch[0].apply(this, arguments);
+        if (predicate) {
+          let args = Array.from(arguments);
+          args[args.length] = predicate;
+          return branch[1].apply(this, args);
+        }
+      }
+    }
+  };
+};
+;// ./src/ramda/fold.js
+/**
+ * 通用折叠（递归归约）函数。
+ *
+ * @public
+ * @param {(this:any, acc: any, seed: any) => [*, *]|[any]|[]|null|undefined} fn - 处理函数，返回 [新acc, 新seed] 或 [新acc]
+ * @param {*} acc - 初始累加值
+ * @param {*} seed - 初始种子
+ * @returns {*} 折叠后的结果
+ * @this *
+ */
+function fold(fn, acc, seed) {
+  while (seed != null) {
+    let pair = fn.call(this, acc, seed);
+    if (pair == null || pair.length === 0) break;
+    acc = pair[0];
+    if (pair.length === 1) break;
+    seed = pair[1];
+  }
+  return acc;
+}
+;// ./src/ramda/pipe.js
+/**
+ * 数据优先的管道处理工具（从左向右执行）
+ * 适合一次性数据处理流程
+ * @public
+ * @param {any} initialValue - 初始值
+ * @param {...((arg: any) => any)} fns - 要应用的函数管道（从左向右执行）
+ * @throws {TypeError} 当参数包含非函数时抛出错误
+ */
+const pipe = (initialValue, ...fns) => {
+  // 无函数时直接返回初始值
+  if (fns.length === 0) return initialValue;
+
+  // 类型检查（遇到第一个错误就抛出）
+  const firstNonFunctionIndex = fns.findIndex(fn => typeof fn !== 'function');
+  if (firstNonFunctionIndex !== -1) {
+    const invalidFn = fns[firstNonFunctionIndex];
+    const errorType = invalidFn === null ? 'null' : invalidFn === undefined ? 'undefined' : typeof invalidFn;
+    throw new TypeError(`所有管道函数必须是函数，但第 ${firstNonFunctionIndex} 个参数是: ${errorType}`);
+  }
+  return fns.reduce((acc, fn) => fn(acc), initialValue);
+};
+;// ./src/ramda/unfold.js
+/**
+ * 通过不断调用 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 *
+ */
+function unfold(fn, seed) {
+  let result = [];
+  let resultSeedPair = fn.call(this, seed);
+  while (resultSeedPair && resultSeedPair.length) {
+    result[result.length] = resultSeedPair[0];
+    resultSeedPair = fn.call(this, resultSeedPair[1]);
+  }
+  return result;
+}
+;// ./src/ramda/0.js
+
+
+
+
+
+;// ./src/structures/erectObject.js
+
+
+
+/**
+ * 从扁平化的数据集构建嵌套的 JavaScript 对象。
+ *
+ * @param {[ (string | number)[], any ][]} entries - 扁平化的键值对数组。
+ * 每个键值对的格式为 `[keyPath, value]`，其中 `keyPath` 是一个表示嵌套路径的数组。
+ * @returns {object | any[]} - 返回嵌套的 JavaScript 对象或数组。
+ */
+function erectObject(entries) {
+  // 排序以便分组，排序后不需要再次排序
+  const flatEntries = entryComparer.sort(entries);
+  return tojs(flatEntries);
+}
+;// ./src/structures/0.js
+
+
+
+
+;// ./src/unquoted-json/stringifyKey.js
+/**
+ * 将键名字符串化，必要时加引号（如包含特殊字符或空字符串）。
+ *
+ * @public
+ * @param {string} x - 要处理的键名
+ * @returns {string} 处理后的键名
+ */
+const stringifyKey = x => {
+  if (x === "" || /(^\u0020)|[,:{}[\]"\u0000-\u001F\u007F]|(\u0020$)/.test(x)) return JSON.stringify(x);else return x;
+};
+;// ./src/unquoted-json/stringifyStringValue.js
+
+
+/**
+ * 将字符串值序列化为 JSON 字符串，必要时加引号（如布尔/null/数字字面量或特殊字符）。
+ *
+ * @public
+ * @param {string} x - 要处理的字符串值
+ * @returns {string} 处理后的字符串
+ */
+const stringifyStringValue = x => {
+  if (x === "true" || x === "false" || x === "null") return JSON.stringify(x);else if (/^[-+]?\d+(\.\d+)?([eE][-+]?\d+)?$/.test(x)) return JSON.stringify(x);else return stringifyKey(x);
+};
+;// ./src/unquoted-json/unquotedJsonStringify.js
+
+
+
+/**
+ * 将任意 JS 值序列化为“无引号 JSON”字符串（仅对键名和部分字符串值去引号）。
+ *
+ * @public
+ * @param {*} value - 要序列化的值
+ * @returns {string} 序列化后的字符串
+ */
+function unquotedJsonStringify(value) {
+  if (value === null) {
+    return 'null';
+  } else if (typeof value === 'string') {
+    return stringifyStringValue(value);
+  } else if (typeof value === 'number') {
+    return isFinite(value) ? value.toString() : 'null';
+  } else if (typeof value === 'boolean') {
+    return value ? 'true' : 'false';
+  } else if (typeof value === 'bigint') {
+    return value.toString();
+  } else if (Array.isArray(value)) {
+    let elems = value.map(e => unquotedJsonStringify(e)).join(',');
+    return '[' + elems + ']';
+  } else if (typeof value === 'object') {
+    let fields = Object.entries(value).map(([k, v]) => stringifyKey(k) + ':' + unquotedJsonStringify(v)).join(',');
+    return '{' + fields + '}';
+  } else if (typeof value === 'undefined') {
+    return 'null';
+  } else if (typeof value === 'function') {
+    return 'null';
+  } else if (typeof value === 'symbol') {
+    return 'null';
+  } else {
+    return 'null';
+  }
+}
+;// ./src/unquoted-json/queryStringify.js
+
+
+/**
+ * 将对象序列化为 URL 查询字符串（支持嵌套对象和多类型字段）。
+ *
+ * @public
+ * @param {Object} data - 要序列化的对象
+ * @returns {string} 查询字符串（如 "?a=1&b=2"），无有效字段时返回空字符串
+ */
+function queryStringify(data) {
+  if (!isPlainObject(data)) {
+    throw new Error("input should be a plain object.");
+  }
+  let pairs = Object.entries(data).filter(([k, v]) => supportedDataTypes.has(typeof v) && v !== '');
+  if (pairs.length === 0) {
+    return '';
+  }
+
+  // 如果字段是对象，包括数组，则序列化字段值，否则不变。
+  return pairs.map(([k, v]) => {
+    let vv = typeof v === 'object' ? unquotedJsonStringify(v) : String(v);
+    return queryStringify_escape(k) + '=' + queryStringify_escape(vv);
+  }).join('&');
+}
+const supportedDataTypes = new Set(['string', 'number', 'boolean', 'bigint',
+// 'function',
+// 'symbol',
+// 'undefined',
+'object']);
+
+/**
+ * 需要编码的ASCII字符及其百分比编码（键为字符本身，用\x或可打印形式）
+ * @type {Map<string, string>}
+ */
+const mp = new Map([['\x00', '%00'], ['\x01', '%01'], ['\x02', '%02'], ['\x03', '%03'], ['\x04', '%04'], ['\x05', '%05'], ['\x06', '%06'], ['\x07', '%07'], ['\x08', '%08'], ['\t', '%09'], ['\n', '%0A'], ['\x0B', '%0B'], ['\x0C', '%0C'], ['\r', '%0D'], ['\x0E', '%0E'], ['\x0F', '%0F'], ['\x10', '%10'], ['\x11', '%11'], ['\x12', '%12'], ['\x13', '%13'], ['\x14', '%14'], ['\x15', '%15'], ['\x16', '%16'], ['\x17', '%17'], ['\x18', '%18'], ['\x19', '%19'], ['\x1A', '%1A'], ['\x1B', '%1B'], ['\x1C', '%1C'], ['\x1D', '%1D'], ['\x1E', '%1E'], ['\x1F', '%1F'], ['\x20', '%20'], ['#', '%23'], ['%', '%25'],
+//浏览器能识别不是%dd格式的百分号为原义，这里冗余转义为了保险起见。
+['&', '%26'], ['+', '%2B'],
+// 原义+有时候会被解析为空格
+['=', '%3D'], ['\x7F', '%7F'] // DEL
+]);
+
+/**
+ * 这是最小的转义函数，其他一概保持原义。
+ * @param {string} str 
+ * @returns {string}
+ */
+const queryStringify_escape = str => str.replace(/[\x00-\x20#%&+=\x7F]/g, c => mp.get(c) || c);
+;// ./src/unquoted-json/0.js
+
+
+;// ./src/index.js
+
+
+
+
+
+
+
+
+
+
+
+
+module.exports = __webpack_exports__;
+/******/ })()
+;