From e1854aee8486f02bee9b8168868765334c2324ed Mon Sep 17 00:00:00 2001
From: Yury Chetyrko <ychetyrko@gmail.com>
Date: Sat, 16 Dec 2023 18:42:37 +0300
Subject: [PATCH] Get rid of El.controller

---
 source/html/El.ts                   |  51 ++--
 source/html/Elements.ts             |  26 +--
 source/html/HtmlDriver.ts           |  40 ++--
 source/html/HtmlElements.ts         | 346 ++++++++++++++--------------
 source/html/sensors/ResizeSensor.ts |   2 +-
 5 files changed, 233 insertions(+), 232 deletions(-)

diff --git a/source/html/El.ts b/source/html/El.ts
index 0ed4fad..7bb7786 100644
--- a/source/html/El.ts
+++ b/source/html/El.ts
@@ -10,26 +10,25 @@ import { equalElCoords, parseElCoords } from "./ElUtils.js"
 
 // ElDriver
 
-export class ElDriver<T extends Element, M = unknown, C = unknown> extends BaseDriver<El<T, M, C>> {
-  allocate(node: RxNode<El<T, M, C>>): El<T, M, C> {
-    return new ElImpl<T, M, C, void>(node)
+export class ElDriver<T extends Element, M = unknown> extends BaseDriver<El<T, M>> {
+  allocate(node: RxNode<El<T, M>>): El<T, M> {
+    return new ElImpl<T, M>(node)
   }
 }
 
 // BaseEl
 
-export interface BaseEl<T = any, M = any, C = any> {
+export interface BaseEl<T = any, M = any> {
   // System-managed properties
-  readonly node: RxNode<El<T, M, C>>
+  readonly node: RxNode<El<T, M>>
 
   // User-manageable properties
   model: M
-  controller: C
 }
 
 // El
 
-export interface El<T = any, M = any, C = any> extends BaseEl<T, M, C> {
+export interface El<T = any, M = any> extends BaseEl<T, M> {
   // System-managed properties
   native: T
 
@@ -98,9 +97,9 @@ export type ElArea = undefined | string | {
 
 // ElImpl
 
-export class ElImpl<T extends Element = any, M = any, C = any, R = any> implements El<T, M, C> {
+export class ElImpl<T extends Element = any, M = any> implements El<T, M> {
   // System-managed properties
-  readonly node: RxNode<El<T, M, C>>
+  readonly node: RxNode<El<T, M>>
   maxColumnCount: number
   maxRowCount: number
   cursorPosition?: CursorPosition
@@ -108,7 +107,6 @@ export class ElImpl<T extends Element = any, M = any, C = any, R = any> implemen
 
   // User-defined properties
   model: M
-  controller: C
   private _kind: ElKind
   private _area: ElArea
   private _coords: ElCoords
@@ -124,7 +122,7 @@ export class ElImpl<T extends Element = any, M = any, C = any, R = any> implemen
   private _overlayVisible: boolean | undefined
   private _hasStyles: boolean
 
-  constructor(node: RxNode<El<T, M, C>>) {
+  constructor(node: RxNode<El<T, M>>) {
     // System-managed properties
     this.node = node
     this.maxColumnCount = 0
@@ -133,7 +131,6 @@ export class ElImpl<T extends Element = any, M = any, C = any, R = any> implemen
     this.native = undefined as any as T // hack
     // User-defined properties
     this.model = undefined as any
-    this.controller = undefined as any as C // hack
     this._kind = ElKind.Part
     this._area = undefined
     this._coords = UndefinedElCoords
@@ -438,20 +435,20 @@ export class CursorCommand {
   rowShift?: number
 }
 
-export class CursorCommandDriver extends ElDriver<Element, unknown, void> {
+export class CursorCommandDriver extends ElDriver<Element, unknown> {
   constructor() {
     super("cursor", false, el => el.kind = ElKind.Cursor)
   }
 }
 
 export class Apply {
-  static kind<T extends Element>(element: El<T, any, any>, value: ElKind): void {
+  static kind<T extends Element>(element: El<T, any>, value: ElKind): void {
     const kind = Constants.layouts[value]
     kind && element.native.setAttribute(Constants.kindAttrName, kind)
     VerstakDriversByLayout[value](element as any)
   }
 
-  static coords<T extends Element>(element: El<T, any, any>, value: ElCoords | undefined): void {
+  static coords<T extends Element>(element: El<T, any>, value: ElCoords | undefined): void {
     if (element.native instanceof HTMLElement) {
       const s = element.native.style
       if (value) {
@@ -466,7 +463,7 @@ export class Apply {
     }
   }
 
-  static widthGrowth<T extends Element>(element: El<T, any, any>, value: number): void {
+  static widthGrowth<T extends Element>(element: El<T, any>, value: number): void {
     if (element.native instanceof HTMLElement) {
       const s = element.native.style
       if (value > 0) {
@@ -480,17 +477,17 @@ export class Apply {
     }
   }
 
-  static minWidth<T extends Element>(element: El<T, any, any>, value: string): void {
+  static minWidth<T extends Element>(element: El<T, any>, value: string): void {
     if (element.native instanceof HTMLElement)
       element.native.style.minWidth = `${value}`
   }
 
-  static applyMaxWidth<T extends Element>(element: El<T, any, any>, value: string): void {
+  static applyMaxWidth<T extends Element>(element: El<T, any>, value: string): void {
     if (element.native instanceof HTMLElement)
       element.native.style.maxWidth = `${value}`
   }
 
-  static heightGrowth<T extends Element>(element: El<T, any, any>, value: number): void {
+  static heightGrowth<T extends Element>(element: El<T, any>, value: number): void {
     const bNode = element.node
     const driver = bNode.driver
     if (driver.isPartitionSeparator) {
@@ -505,24 +502,24 @@ export class Apply {
     else {
       const hostDriver = bNode.host.driver
       if (hostDriver.isPartitionSeparator) {
-        const host = bNode.host.seat!.instance as RxNode<El<T, any, any>>
+        const host = bNode.host.seat!.instance as RxNode<El<T, any>>
         Apply.elementAlignment(element, Align.ToBounds)
         Apply.heightGrowth(host.element, value)
       }
     }
   }
 
-  static minHeight<T extends Element>(element: El<T, any, any>, value: string): void {
+  static minHeight<T extends Element>(element: El<T, any>, value: string): void {
     if (element.native instanceof HTMLElement)
       element.native.style.minHeight = `${value}`
   }
 
-  static maxHeight<T extends Element>(element: El<T, any, any>, value: string): void {
+  static maxHeight<T extends Element>(element: El<T, any>, value: string): void {
     if (element.native instanceof HTMLElement)
       element.native.style.maxHeight = `${value}`
   }
 
-  static contentAlignment<T extends Element>(element: El<T, any, any>, value: Align): void {
+  static contentAlignment<T extends Element>(element: El<T, any>, value: Align): void {
     if (element.native instanceof HTMLElement) {
       const s = element.native.style
       if ((value & Align.Default) === 0) { // if not auto mode
@@ -538,7 +535,7 @@ export class Apply {
     }
   }
 
-  static elementAlignment<T extends Element>(element: El<T, any, any>, value: Align): void {
+  static elementAlignment<T extends Element>(element: El<T, any>, value: Align): void {
     if (element.native instanceof HTMLElement) {
       const s = element.native.style
       if ((value & Align.Default) === 0) { // if not auto mode
@@ -555,7 +552,7 @@ export class Apply {
     }
   }
 
-  static contentWrapping<T extends Element>(element: El<T, any, any>, value: boolean): void {
+  static contentWrapping<T extends Element>(element: El<T, any>, value: boolean): void {
     if (element.native instanceof HTMLElement) {
       const s = element.native.style
       if (value) {
@@ -573,7 +570,7 @@ export class Apply {
     }
   }
 
-  static overlayVisible<T extends Element>(element: El<T, any, any>, value: boolean | undefined): void {
+  static overlayVisible<T extends Element>(element: El<T, any>, value: boolean | undefined): void {
     const e = element.native
     if (e instanceof HTMLElement) {
       const s = e.style
@@ -607,7 +604,7 @@ export class Apply {
     }
   }
 
-  static style<T extends Element>(element: El<T, any, any>, secondary: boolean, styleName: string, enabled?: boolean): void {
+  static style<T extends Element>(element: El<T, any>, secondary: boolean, styleName: string, enabled?: boolean): void {
     const native = element.native
     enabled ??= true
     if (secondary)
diff --git a/source/html/Elements.ts b/source/html/Elements.ts
index cc2792e..02bb5a1 100644
--- a/source/html/Elements.ts
+++ b/source/html/Elements.ts
@@ -30,17 +30,17 @@ import { HtmlElementDriver } from "./HtmlDriver.js"
 
 // Section
 
-export function Section<M = unknown, R = void>(
-  declaration?: RxNodeDecl<El<HTMLElement, M, R>>,
-  preset?: RxNodeDecl<El<HTMLElement, M, R>>): RxNode<El<HTMLElement, M, R>> {
+export function Section<M = unknown>(
+  declaration?: RxNodeDecl<El<HTMLElement, M>>,
+  preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> {
   return RxNode.acquire(Drivers.section, declaration, preset)
 }
 
 // Table
 
 export function Table<M = unknown, R = void>(
-  declaration?: RxNodeDecl<El<HTMLElement, M, R>>,
-  preset?: RxNodeDecl<El<HTMLElement, M, R>>): RxNode<El<HTMLElement, M, R>> {
+  declaration?: RxNodeDecl<El<HTMLElement, M>>,
+  preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> {
   return RxNode.acquire(Drivers.table, declaration, preset)
 }
 
@@ -66,7 +66,7 @@ export function cursor(areaParams: ElArea): void {
 // Note (either plain or html)
 
 export function Note(content: string,
-  declaration?: RxNodeDecl<El<HTMLElement, void, void>>): RxNode<El<HTMLElement, void, void>> {
+  declaration?: RxNodeDecl<El<HTMLElement, void>>): RxNode<El<HTMLElement, void>> {
   return RxNode.acquire(Drivers.note, declaration, {
     update(b) {
       b.native.innerText = content
@@ -75,7 +75,7 @@ export function Note(content: string,
 }
 
 export function HtmlNote(content: string,
-  declaration?: RxNodeDecl<El<HTMLElement, void, void>>): RxNode<El<HTMLElement, void, void>> {
+  declaration?: RxNodeDecl<El<HTMLElement, void>>): RxNode<El<HTMLElement, void>> {
   return RxNode.acquire(Drivers.note, declaration, {
     update(b) {
       b.native.innerHTML = content
@@ -86,16 +86,16 @@ export function HtmlNote(content: string,
 // Group
 
 export function Group<M = unknown, R = void>(
-  declaration?: RxNodeDecl<El<HTMLElement, M, R>>,
-  preset?: RxNodeDecl<El<HTMLElement, M, R>>): RxNode<El<HTMLElement, M, R>> {
+  declaration?: RxNodeDecl<El<HTMLElement, M>>,
+  preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> {
   return RxNode.acquire(Drivers.group, declaration, preset)
 }
 
 // PseudoElement
 
-export function PseudoElement<M = unknown, R = void>(
-  declaration?: RxNodeDecl<El<void, M, R>>,
-  preset?: RxNodeDecl<El<void, M, R>>): RxNode<El<void, M, R>> {
+export function PseudoElement<M = unknown>(
+  declaration?: RxNodeDecl<El<void, M>>,
+  preset?: RxNodeDecl<El<void, M>>): RxNode<El<void, M>> {
   return RxNode.acquire(Drivers.pseudo, declaration, preset)
 }
 
@@ -131,5 +131,5 @@ const Drivers = {
   cursor: new CursorCommandDriver(),
 
   // (no element)
-  pseudo: new ElDriver<HTMLElement>("pseudo", false, el => el.kind = ElKind.Group) as unknown as RxNodeDriver<El<void, any, any>>,
+  pseudo: new ElDriver<HTMLElement>("pseudo", false, el => el.kind = ElKind.Group) as unknown as RxNodeDriver<El<void, any>>,
 }
diff --git a/source/html/HtmlDriver.ts b/source/html/HtmlDriver.ts
index 6ed0775..17e1b87 100644
--- a/source/html/HtmlDriver.ts
+++ b/source/html/HtmlDriver.ts
@@ -10,19 +10,23 @@ import { Constants, El, ElDriver, ElImpl } from "./El.js"
 
 // WebDriver
 
-export abstract class WebDriver<T extends Element, M = unknown, C = unknown> extends ElDriver<T, M, C> {
+export class WebDriver<T extends Element, M = unknown> extends ElDriver<T, M> {
 
-  abstract acquireNativeElement(element: El<T, M, C>): T
+  setNativeElement(node: RxNode<El<T, M>>): void {
+    // it's up to descendant class to define logic
+  }
 
-  initialize(node: RxNode<El<T, M, C>>): void {
-    const element = node.element
-    const native = element.native = this.acquireNativeElement(element)
-    if (RxSystem.isLogging && !element.node.driver.isPartitionSeparator)
-      native.setAttribute(Constants.keyAttrName, element.node.key)
+  initialize(node: RxNode<El<T, M>>): void {
+    this.setNativeElement(node)
+    const e = node.element.native
+    if (RxSystem.isLogging && e !== undefined && !node.driver.isPartitionSeparator)
+      e.setAttribute(Constants.keyAttrName, node.key)
     super.initialize(node)
+    if (e == undefined && RxSystem.isLogging && !node.driver.isPartitionSeparator)
+      node.element.native.setAttribute(Constants.keyAttrName, node.key)
   }
 
-  finalize(node: RxNode<El<T, M, C>>, isLeader: boolean): boolean {
+  finalize(node: RxNode<El<T, M>>, isLeader: boolean): boolean {
     const element = node.element
     const native = element.native as T | undefined // hack
     if (native) {
@@ -35,7 +39,7 @@ export abstract class WebDriver<T extends Element, M = unknown, C = unknown> ext
     return false // children elements having native HTML elements are not treated as leaders
   }
 
-  mount(node: RxNode<El<T, M, C>>): void {
+  mount(node: RxNode<El<T, M>>): void {
     const element = node.element
     const native = element.native as T | undefined // hack
     if (native) {
@@ -66,7 +70,7 @@ export abstract class WebDriver<T extends Element, M = unknown, C = unknown> ext
     }
   }
 
-  update(node: RxNode<El<T, M, C>>): void | Promise<void> {
+  update(node: RxNode<El<T, M>>): void | Promise<void> {
     const element = node.element
     if (element instanceof ElImpl)
       element.prepareForUpdate()
@@ -111,24 +115,24 @@ export class StaticDriver<T extends HTMLElement> extends WebDriver<T> {
     this.native = native
   }
 
-  acquireNativeElement(): T {
-    return this.native
+  setNativeElement(node: RxNode<El<T>>): void {
+    node.element.native = this.native
   }
 }
 
 // HtmlElementDriver
 
-export class HtmlElementDriver<T extends HTMLElement, M = any, C = any> extends WebDriver<T, M, C> {
-  acquireNativeElement(element: El<T, M, C>): T {
-    return document.createElement(element.node.driver.name) as T
+export class HtmlElementDriver<T extends HTMLElement, M = any> extends WebDriver<T, M> {
+  setNativeElement(node: RxNode<El<T, M>>): void {
+    node.element.native = document.createElement(node.driver.name) as T
   }
 }
 
 // SvgElementDriver
 
-export class SvgElementDriver<T extends SVGElement, M = any, C = any> extends WebDriver<T, M, C> {
-  acquireNativeElement(element: El<T, M, C>): T {
-    return document.createElementNS("http://www.w3.org/2000/svg", element.node.driver.name) as T
+export class SvgElementDriver<T extends SVGElement, M = any> extends WebDriver<T, M> {
+  setNativeElement(node: RxNode<El<T, M>>): void {
+    node.element.native = document.createElementNS("http://www.w3.org/2000/svg", node.driver.name) as T
   }
 }
 
diff --git a/source/html/HtmlElements.ts b/source/html/HtmlElements.ts
index 341a0f9..ef73390 100644
--- a/source/html/HtmlElements.ts
+++ b/source/html/HtmlElements.ts
@@ -14,180 +14,180 @@ export function HtmlBody(declaration?: RxNodeDecl<El<HTMLElement>>, preset?: RxN
   return RxNode.acquire(driver, declaration, preset)
 }
 
-export function A<M = unknown>(declaration?: RxNodeDecl<El<HTMLAnchorElement, M, void>>, preset?: RxNodeDecl<El<HTMLAnchorElement, M, void>>): RxNode<El<HTMLAnchorElement, M, void>> { return RxNode.acquire(HtmlTags.a, declaration, preset) }
-export function Abbr<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.abbr, declaration, preset) }
-export function Address<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.address, declaration, preset) }
-export function Area<M = unknown>(declaration?: RxNodeDecl<El<HTMLAreaElement, M, void>>, preset?: RxNodeDecl<El<HTMLAreaElement, M, void>>): RxNode<El<HTMLAreaElement, M, void>> { return RxNode.acquire(HtmlTags.area, declaration, preset) }
-export function Article<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.article, declaration, preset) }
-export function Aside<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.aside, declaration, preset) }
-export function Audio<M = unknown>(declaration?: RxNodeDecl<El<HTMLAudioElement, M, void>>, preset?: RxNodeDecl<El<HTMLAudioElement, M, void>>): RxNode<El<HTMLAudioElement, M, void>> { return RxNode.acquire(HtmlTags.audio, declaration, preset) }
-export function B<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.b, declaration, preset) }
-export function Base<M = unknown>(declaration?: RxNodeDecl<El<HTMLBaseElement, M, void>>, preset?: RxNodeDecl<El<HTMLBaseElement, M, void>>): RxNode<El<HTMLBaseElement, M, void>> { return RxNode.acquire(HtmlTags.base, declaration, preset) }
-export function Bdi<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.bdi, declaration, preset) }
-export function Bdo<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.bdo, declaration, preset) }
-export function Big<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.big, declaration, preset) }
-export function BlockQuote<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.blockquote, declaration, preset) }
-export function Body<M = unknown>(declaration?: RxNodeDecl<El<HTMLBodyElement, M, void>>, preset?: RxNodeDecl<El<HTMLBodyElement, M, void>>): RxNode<El<HTMLBodyElement, M, void>> { return RxNode.acquire(HtmlTags.body, declaration, preset) }
-export function BR<M = unknown>(declaration?: RxNodeDecl<El<HTMLBRElement, M, void>>, preset?: RxNodeDecl<El<HTMLBRElement, M, void>>): RxNode<El<HTMLBRElement, M, void>> { return RxNode.acquire(HtmlTags.br, declaration, preset) }
-export function Button<M = unknown>(declaration?: RxNodeDecl<El<HTMLButtonElement, M, void>>, preset?: RxNodeDecl<El<HTMLButtonElement, M, void>>): RxNode<El<HTMLButtonElement, M, void>> { return RxNode.acquire(HtmlTags.button, declaration, preset) }
-export function Canvas<M = unknown>(declaration?: RxNodeDecl<El<HTMLCanvasElement, M, void>>, preset?: RxNodeDecl<El<HTMLCanvasElement, M, void>>): RxNode<El<HTMLCanvasElement, M, void>> { return RxNode.acquire(HtmlTags.canvas, declaration, preset) }
-export function Caption<M = unknown>(declaration?: RxNodeDecl<El<HTMLTableCaptionElement, M, void>>, preset?: RxNodeDecl<El<HTMLTableCaptionElement, M, void>>): RxNode<El<HTMLTableCaptionElement, M, void>> { return RxNode.acquire(HtmlTags.caption, declaration, preset) }
-export function Cite<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.cite, declaration, preset) }
-export function Code<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.code, declaration, preset) }
-export function Col<M = unknown>(declaration?: RxNodeDecl<El<HTMLTableColElement, M, void>>, preset?: RxNodeDecl<El<HTMLTableColElement, M, void>>): RxNode<El<HTMLTableColElement, M, void>> { return RxNode.acquire(HtmlTags.col, declaration, preset) }
-export function ColGroup<M = unknown>(declaration?: RxNodeDecl<El<HTMLTableColElement, M, void>>, preset?: RxNodeDecl<El<HTMLTableColElement, M, void>>): RxNode<El<HTMLTableColElement, M, void>> { return RxNode.acquire(HtmlTags.colgroup, declaration, preset) }
-export function Data<M = unknown>(declaration?: RxNodeDecl<El<HTMLDataElement, M, void>>, preset?: RxNodeDecl<El<HTMLDataElement, M, void>>): RxNode<El<HTMLDataElement, M, void>> { return RxNode.acquire(HtmlTags.data, declaration, preset) }
-export function DataList<M = unknown>(declaration?: RxNodeDecl<El<HTMLDataListElement, M, void>>, preset?: RxNodeDecl<El<HTMLDataListElement, M, void>>): RxNode<El<HTMLDataListElement, M, void>> { return RxNode.acquire(HtmlTags.datalist, declaration, preset) }
-export function DD<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.dd, declaration, preset) }
-export function Del<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.del, declaration, preset) }
-export function Details<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.details, declaration, preset) }
-export function Dfn<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.dfn, declaration, preset) }
-export function Div<M = unknown>(declaration?: RxNodeDecl<El<HTMLDivElement, M, void>>, preset?: RxNodeDecl<El<HTMLDivElement, M, void>>): RxNode<El<HTMLDivElement, M, void>> { return RxNode.acquire(HtmlTags.div, declaration, preset) }
-export function DL<M = unknown>(declaration?: RxNodeDecl<El<HTMLDListElement, M, void>>, preset?: RxNodeDecl<El<HTMLDListElement, M, void>>): RxNode<El<HTMLDListElement, M, void>> { return RxNode.acquire(HtmlTags.dl, declaration, preset) }
-export function DT<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.dt, declaration, preset) }
-export function EM<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.em, declaration, preset) }
-export function Embed<M = unknown>(declaration?: RxNodeDecl<El<HTMLEmbedElement, M, void>>, preset?: RxNodeDecl<El<HTMLEmbedElement, M, void>>): RxNode<El<HTMLEmbedElement, M, void>> { return RxNode.acquire(HtmlTags.embed, declaration, preset) }
-export function FieldSet<M = unknown>(declaration?: RxNodeDecl<El<HTMLFieldSetElement, M, void>>, preset?: RxNodeDecl<El<HTMLFieldSetElement, M, void>>): RxNode<El<HTMLFieldSetElement, M, void>> { return RxNode.acquire(HtmlTags.fieldset, declaration, preset) }
-export function FigCaption<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.figcaption, declaration, preset) }
-export function Figure<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.figure, declaration, preset) }
-export function Footer<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.footer, declaration, preset) }
-export function Form<M = unknown>(declaration?: RxNodeDecl<El<HTMLFormElement, M, void>>, preset?: RxNodeDecl<El<HTMLFormElement, M, void>>): RxNode<El<HTMLFormElement, M, void>> { return RxNode.acquire(HtmlTags.form, declaration, preset) }
-export function H1<M = unknown>(declaration?: RxNodeDecl<El<HTMLHeadingElement, M, void>>, preset?: RxNodeDecl<El<HTMLHeadingElement, M, void>>): RxNode<El<HTMLHeadingElement, M, void>> { return RxNode.acquire(HtmlTags.h1, declaration, preset) }
-export function H2<M = unknown>(declaration?: RxNodeDecl<El<HTMLHeadingElement, M, void>>, preset?: RxNodeDecl<El<HTMLHeadingElement, M, void>>): RxNode<El<HTMLHeadingElement, M, void>> { return RxNode.acquire(HtmlTags.h2, declaration, preset) }
-export function H3<M = unknown>(declaration?: RxNodeDecl<El<HTMLHeadingElement, M, void>>, preset?: RxNodeDecl<El<HTMLHeadingElement, M, void>>): RxNode<El<HTMLHeadingElement, M, void>> { return RxNode.acquire(HtmlTags.h3, declaration, preset) }
-export function H4<M = unknown>(declaration?: RxNodeDecl<El<HTMLHeadingElement, M, void>>, preset?: RxNodeDecl<El<HTMLHeadingElement, M, void>>): RxNode<El<HTMLHeadingElement, M, void>> { return RxNode.acquire(HtmlTags.h4, declaration, preset) }
-export function H5<M = unknown>(declaration?: RxNodeDecl<El<HTMLHeadingElement, M, void>>, preset?: RxNodeDecl<El<HTMLHeadingElement, M, void>>): RxNode<El<HTMLHeadingElement, M, void>> { return RxNode.acquire(HtmlTags.h5, declaration, preset) }
-export function H6<M = unknown>(declaration?: RxNodeDecl<El<HTMLHeadingElement, M, void>>, preset?: RxNodeDecl<El<HTMLHeadingElement, M, void>>): RxNode<El<HTMLHeadingElement, M, void>> { return RxNode.acquire(HtmlTags.h6, declaration, preset) }
-export function Head<M = unknown>(declaration?: RxNodeDecl<El<HTMLHeadElement, M, void>>, preset?: RxNodeDecl<El<HTMLHeadElement, M, void>>): RxNode<El<HTMLHeadElement, M, void>> { return RxNode.acquire(HtmlTags.head, declaration, preset) }
-export function Header<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.header, declaration, preset) }
-export function HGroup<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.hgroup, declaration, preset) }
-export function HR<M = unknown>(declaration?: RxNodeDecl<El<HTMLHRElement, M, void>>, preset?: RxNodeDecl<El<HTMLHRElement, M, void>>): RxNode<El<HTMLHRElement, M, void>> { return RxNode.acquire(HtmlTags.hr, declaration, preset) }
-export function Html<M = unknown>(declaration?: RxNodeDecl<El<HTMLHtmlElement, M, void>>, preset?: RxNodeDecl<El<HTMLHtmlElement, M, void>>): RxNode<El<HTMLHtmlElement, M, void>> { return RxNode.acquire(HtmlTags.html, declaration, preset) }
-export function I<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.i, declaration, preset) }
-export function IFrame<M = unknown>(declaration?: RxNodeDecl<El<HTMLIFrameElement, M, void>>, preset?: RxNodeDecl<El<HTMLIFrameElement, M, void>>): RxNode<El<HTMLIFrameElement, M, void>> { return RxNode.acquire(HtmlTags.iframe, declaration, preset) }
-export function Img<M = unknown>(declaration?: RxNodeDecl<El<HTMLImageElement, M, void>>, preset?: RxNodeDecl<El<HTMLImageElement, M, void>>): RxNode<El<HTMLImageElement, M, void>> { return RxNode.acquire(HtmlTags.img, declaration, preset) }
-export function Input<M = unknown>(declaration?: RxNodeDecl<El<HTMLInputElement, M, void>>, preset?: RxNodeDecl<El<HTMLInputElement, M, void>>): RxNode<El<HTMLInputElement, M, void>> { return RxNode.acquire(HtmlTags.input, declaration, preset) }
-export function Ins<M = unknown>(declaration?: RxNodeDecl<El<HTMLModElement, M, void>>, preset?: RxNodeDecl<El<HTMLModElement, M, void>>): RxNode<El<HTMLModElement, M, void>> { return RxNode.acquire(HtmlTags.ins, declaration, preset) }
-export function Kbd<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.kbd, declaration, preset) }
-export function KeyGen<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.keygen, declaration, preset) }
-export function Label<M = unknown>(declaration?: RxNodeDecl<El<HTMLLabelElement, M, void>>, preset?: RxNodeDecl<El<HTMLLabelElement, M, void>>): RxNode<El<HTMLLabelElement, M, void>> { return RxNode.acquire(HtmlTags.label, declaration, preset) }
-export function Legend<M = unknown>(declaration?: RxNodeDecl<El<HTMLLegendElement, M, void>>, preset?: RxNodeDecl<El<HTMLLegendElement, M, void>>): RxNode<El<HTMLLegendElement, M, void>> { return RxNode.acquire(HtmlTags.legend, declaration, preset) }
-export function LI<M = unknown>(declaration?: RxNodeDecl<El<HTMLLIElement, M, void>>, preset?: RxNodeDecl<El<HTMLLIElement, M, void>>): RxNode<El<HTMLLIElement, M, void>> { return RxNode.acquire(HtmlTags.li, declaration, preset) }
-export function Link<M = unknown>(declaration?: RxNodeDecl<El<HTMLLinkElement, M, void>>, preset?: RxNodeDecl<El<HTMLLinkElement, M, void>>): RxNode<El<HTMLLinkElement, M, void>> { return RxNode.acquire(HtmlTags.link, declaration, preset) }
-export function Main<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.main, declaration, preset) }
-export function Map<M = unknown>(declaration?: RxNodeDecl<El<HTMLMapElement, M, void>>, preset?: RxNodeDecl<El<HTMLMapElement, M, void>>): RxNode<El<HTMLMapElement, M, void>> { return RxNode.acquire(HtmlTags.map, declaration, preset) }
-export function Mark<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.mark, declaration, preset) }
-export function Menu<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.menu, declaration, preset) }
-export function MenuItem<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.menuitem, declaration, preset) }
-export function Meta<M = unknown>(declaration?: RxNodeDecl<El<HTMLMetaElement, M, void>>, preset?: RxNodeDecl<El<HTMLMetaElement, M, void>>): RxNode<El<HTMLMetaElement, M, void>> { return RxNode.acquire(HtmlTags.meta, declaration, preset) }
-export function Meter<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.meter, declaration, preset) }
-export function Nav<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.nav, declaration, preset) }
-export function NoIndex<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.noindex, declaration, preset) }
-export function NoScript<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.noscript, declaration, preset) }
-export function Obj<M = unknown>(declaration?: RxNodeDecl<El<HTMLObjectElement, M, void>>, preset?: RxNodeDecl<El<HTMLObjectElement, M, void>>): RxNode<El<HTMLObjectElement, M, void>> { return RxNode.acquire(HtmlTags.object, declaration, preset) }
-export function OL<M = unknown>(declaration?: RxNodeDecl<El<HTMLOListElement, M, void>>, preset?: RxNodeDecl<El<HTMLOListElement, M, void>>): RxNode<El<HTMLOListElement, M, void>> { return RxNode.acquire(HtmlTags.ol, declaration, preset) }
-export function OptGroup<M = unknown>(declaration?: RxNodeDecl<El<HTMLOptGroupElement, M, void>>, preset?: RxNodeDecl<El<HTMLOptGroupElement, M, void>>): RxNode<El<HTMLOptGroupElement, M, void>> { return RxNode.acquire(HtmlTags.optgroup, declaration, preset) }
-export function Option<M = unknown>(declaration?: RxNodeDecl<El<HTMLOptionElement, M, void>>, preset?: RxNodeDecl<El<HTMLOptionElement, M, void>>): RxNode<El<HTMLOptionElement, M, void>> { return RxNode.acquire(HtmlTags.option, declaration, preset) }
-export function Output<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.output, declaration, preset) }
-export function P<M = unknown>(declaration?: RxNodeDecl<El<HTMLParagraphElement, M, void>>, preset?: RxNodeDecl<El<HTMLParagraphElement, M, void>>): RxNode<El<HTMLParagraphElement, M, void>> { return RxNode.acquire(HtmlTags.p, declaration, preset) }
-export function Param<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.param, declaration, preset) }
-export function Picture<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.picture, declaration, preset) }
-export function Pre<M = unknown>(declaration?: RxNodeDecl<El<HTMLPreElement, M, void>>, preset?: RxNodeDecl<El<HTMLPreElement, M, void>>): RxNode<El<HTMLPreElement, M, void>> { return RxNode.acquire(HtmlTags.pre, declaration, preset) }
-export function Progress<M = unknown>(declaration?: RxNodeDecl<El<HTMLProgressElement, M, void>>, preset?: RxNodeDecl<El<HTMLProgressElement, M, void>>): RxNode<El<HTMLProgressElement, M, void>> { return RxNode.acquire(HtmlTags.progress, declaration, preset) }
-export function Q<M = unknown>(declaration?: RxNodeDecl<El<HTMLQuoteElement, M, void>>, preset?: RxNodeDecl<El<HTMLQuoteElement, M, void>>): RxNode<El<HTMLQuoteElement, M, void>> { return RxNode.acquire(HtmlTags.q, declaration, preset) }
-export function RP<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.rp, declaration, preset) }
-export function RT<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.rt, declaration, preset) }
-export function Ruby<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.ruby, declaration, preset) }
-export function S<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.s, declaration, preset) }
-export function Samp<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.samp, declaration, preset) }
-export function Script<M = unknown>(declaration?: RxNodeDecl<El<HTMLScriptElement, M, void>>, preset?: RxNodeDecl<El<HTMLScriptElement, M, void>>): RxNode<El<HTMLScriptElement, M, void>> { return RxNode.acquire(HtmlTags.script, declaration, preset) }
-export function Sctn<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.section, declaration, preset) }
-export function Select<M = unknown>(declaration?: RxNodeDecl<El<HTMLSelectElement, M, void>>, preset?: RxNodeDecl<El<HTMLSelectElement, M, void>>): RxNode<El<HTMLSelectElement, M, void>> { return RxNode.acquire(HtmlTags.select, declaration, preset) }
-export function Small<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.small, declaration, preset) }
-export function Source<M = unknown>(declaration?: RxNodeDecl<El<HTMLSourceElement, M, void>>, preset?: RxNodeDecl<El<HTMLSourceElement, M, void>>): RxNode<El<HTMLSourceElement, M, void>> { return RxNode.acquire(HtmlTags.source, declaration, preset) }
-export function Span<M = unknown>(declaration?: RxNodeDecl<El<HTMLSpanElement, M, void>>, preset?: RxNodeDecl<El<HTMLSpanElement, M, void>>): RxNode<El<HTMLSpanElement, M, void>> { return RxNode.acquire(HtmlTags.span, declaration, preset) }
-export function Strong<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.strong, declaration, preset) }
-export function Style<M = unknown>(declaration?: RxNodeDecl<El<HTMLStyleElement, M, void>>, preset?: RxNodeDecl<El<HTMLStyleElement, M, void>>): RxNode<El<HTMLStyleElement, M, void>> { return RxNode.acquire(HtmlTags.style, declaration, preset) }
-export function Sub<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.sub, declaration, preset) }
-export function Summary<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.summary, declaration, preset) }
-export function Sup<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.sup, declaration, preset) }
-export function Tbl<M = unknown>(declaration?: RxNodeDecl<El<HTMLTableElement, M, void>>, preset?: RxNodeDecl<El<HTMLTableElement, M, void>>): RxNode<El<HTMLTableElement, M, void>> { return RxNode.acquire(HtmlTags.table, declaration, preset) }
-export function Template<M = unknown>(declaration?: RxNodeDecl<El<HTMLTemplateElement, M, void>>, preset?: RxNodeDecl<El<HTMLTemplateElement, M, void>>): RxNode<El<HTMLTemplateElement, M, void>> { return RxNode.acquire(HtmlTags.template, declaration, preset) }
-export function TBody<M = unknown>(declaration?: RxNodeDecl<El<HTMLTableSectionElement, M, void>>, preset?: RxNodeDecl<El<HTMLTableSectionElement, M, void>>): RxNode<El<HTMLTableSectionElement, M, void>> { return RxNode.acquire(HtmlTags.tbody, declaration, preset) }
-export function TD<M = unknown>(declaration?: RxNodeDecl<El<HTMLTableCellElement, M, void>>, preset?: RxNodeDecl<El<HTMLTableCellElement, M, void>>): RxNode<El<HTMLTableCellElement, M, void>> { return RxNode.acquire(HtmlTags.td, declaration, preset) }
-export function TextArea<M = unknown>(declaration?: RxNodeDecl<El<HTMLTextAreaElement, M, void>>, preset?: RxNodeDecl<El<HTMLTextAreaElement, M, void>>): RxNode<El<HTMLTextAreaElement, M, void>> { return RxNode.acquire(HtmlTags.textarea, declaration, preset) }
-export function TFoot<M = unknown>(declaration?: RxNodeDecl<El<HTMLTableSectionElement, M, void>>, preset?: RxNodeDecl<El<HTMLTableSectionElement, M, void>>): RxNode<El<HTMLTableSectionElement, M, void>> { return RxNode.acquire(HtmlTags.tfoot, declaration, preset) }
-export function TH<M = unknown>(declaration?: RxNodeDecl<El<HTMLTableCellElement, M, void>>, preset?: RxNodeDecl<El<HTMLTableCellElement, M, void>>): RxNode<El<HTMLTableCellElement, M, void>> { return RxNode.acquire(HtmlTags.th, declaration, preset) }
-export function THead<M = unknown>(declaration?: RxNodeDecl<El<HTMLTableSectionElement, M, void>>, preset?: RxNodeDecl<El<HTMLTableSectionElement, M, void>>): RxNode<El<HTMLTableSectionElement, M, void>> { return RxNode.acquire(HtmlTags.thead, declaration, preset) }
-export function Time<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.time, declaration, preset) }
-export function Title<M = unknown>(declaration?: RxNodeDecl<El<HTMLTitleElement, M, void>>, preset?: RxNodeDecl<El<HTMLTitleElement, M, void>>): RxNode<El<HTMLTitleElement, M, void>> { return RxNode.acquire(HtmlTags.title, declaration, preset) }
-export function TR<M = unknown>(declaration?: RxNodeDecl<El<HTMLTableRowElement, M, void>>, preset?: RxNodeDecl<El<HTMLTableRowElement, M, void>>): RxNode<El<HTMLTableRowElement, M, void>> { return RxNode.acquire(HtmlTags.tr, declaration, preset) }
-export function Track<M = unknown>(declaration?: RxNodeDecl<El<HTMLTrackElement, M, void>>, preset?: RxNodeDecl<El<HTMLTrackElement, M, void>>): RxNode<El<HTMLTrackElement, M, void>> { return RxNode.acquire(HtmlTags.track, declaration, preset) }
-export function U<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.u, declaration, preset) }
-export function UL<M = unknown>(declaration?: RxNodeDecl<El<HTMLUListElement, M, void>>, preset?: RxNodeDecl<El<HTMLUListElement, M, void>>): RxNode<El<HTMLUListElement, M, void>> { return RxNode.acquire(HtmlTags.ul, declaration, preset) }
-export function Var<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.var, declaration, preset) }
-export function Video<M = unknown>(declaration?: RxNodeDecl<El<HTMLVideoElement, M, void>>, preset?: RxNodeDecl<El<HTMLVideoElement, M, void>>): RxNode<El<HTMLVideoElement, M, void>> { return RxNode.acquire(HtmlTags.video, declaration, preset) }
-export function Wbr<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M, void>>, preset?: RxNodeDecl<El<HTMLElement, M, void>>): RxNode<El<HTMLElement, M, void>> { return RxNode.acquire(HtmlTags.wbr, declaration, preset) }
+export function A<M = unknown>(declaration?: RxNodeDecl<El<HTMLAnchorElement, M>>, preset?: RxNodeDecl<El<HTMLAnchorElement, M>>): RxNode<El<HTMLAnchorElement, M>> { return RxNode.acquire(HtmlTags.a, declaration, preset) }
+export function Abbr<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.abbr, declaration, preset) }
+export function Address<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.address, declaration, preset) }
+export function Area<M = unknown>(declaration?: RxNodeDecl<El<HTMLAreaElement, M>>, preset?: RxNodeDecl<El<HTMLAreaElement, M>>): RxNode<El<HTMLAreaElement, M>> { return RxNode.acquire(HtmlTags.area, declaration, preset) }
+export function Article<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.article, declaration, preset) }
+export function Aside<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.aside, declaration, preset) }
+export function Audio<M = unknown>(declaration?: RxNodeDecl<El<HTMLAudioElement, M>>, preset?: RxNodeDecl<El<HTMLAudioElement, M>>): RxNode<El<HTMLAudioElement, M>> { return RxNode.acquire(HtmlTags.audio, declaration, preset) }
+export function B<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.b, declaration, preset) }
+export function Base<M = unknown>(declaration?: RxNodeDecl<El<HTMLBaseElement, M>>, preset?: RxNodeDecl<El<HTMLBaseElement, M>>): RxNode<El<HTMLBaseElement, M>> { return RxNode.acquire(HtmlTags.base, declaration, preset) }
+export function Bdi<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.bdi, declaration, preset) }
+export function Bdo<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.bdo, declaration, preset) }
+export function Big<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.big, declaration, preset) }
+export function BlockQuote<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.blockquote, declaration, preset) }
+export function Body<M = unknown>(declaration?: RxNodeDecl<El<HTMLBodyElement, M>>, preset?: RxNodeDecl<El<HTMLBodyElement, M>>): RxNode<El<HTMLBodyElement, M>> { return RxNode.acquire(HtmlTags.body, declaration, preset) }
+export function BR<M = unknown>(declaration?: RxNodeDecl<El<HTMLBRElement, M>>, preset?: RxNodeDecl<El<HTMLBRElement, M>>): RxNode<El<HTMLBRElement, M>> { return RxNode.acquire(HtmlTags.br, declaration, preset) }
+export function Button<M = unknown>(declaration?: RxNodeDecl<El<HTMLButtonElement, M>>, preset?: RxNodeDecl<El<HTMLButtonElement, M>>): RxNode<El<HTMLButtonElement, M>> { return RxNode.acquire(HtmlTags.button, declaration, preset) }
+export function Canvas<M = unknown>(declaration?: RxNodeDecl<El<HTMLCanvasElement, M>>, preset?: RxNodeDecl<El<HTMLCanvasElement, M>>): RxNode<El<HTMLCanvasElement, M>> { return RxNode.acquire(HtmlTags.canvas, declaration, preset) }
+export function Caption<M = unknown>(declaration?: RxNodeDecl<El<HTMLTableCaptionElement, M>>, preset?: RxNodeDecl<El<HTMLTableCaptionElement, M>>): RxNode<El<HTMLTableCaptionElement, M>> { return RxNode.acquire(HtmlTags.caption, declaration, preset) }
+export function Cite<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.cite, declaration, preset) }
+export function Code<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.code, declaration, preset) }
+export function Col<M = unknown>(declaration?: RxNodeDecl<El<HTMLTableColElement, M>>, preset?: RxNodeDecl<El<HTMLTableColElement, M>>): RxNode<El<HTMLTableColElement, M>> { return RxNode.acquire(HtmlTags.col, declaration, preset) }
+export function ColGroup<M = unknown>(declaration?: RxNodeDecl<El<HTMLTableColElement, M>>, preset?: RxNodeDecl<El<HTMLTableColElement, M>>): RxNode<El<HTMLTableColElement, M>> { return RxNode.acquire(HtmlTags.colgroup, declaration, preset) }
+export function Data<M = unknown>(declaration?: RxNodeDecl<El<HTMLDataElement, M>>, preset?: RxNodeDecl<El<HTMLDataElement, M>>): RxNode<El<HTMLDataElement, M>> { return RxNode.acquire(HtmlTags.data, declaration, preset) }
+export function DataList<M = unknown>(declaration?: RxNodeDecl<El<HTMLDataListElement, M>>, preset?: RxNodeDecl<El<HTMLDataListElement, M>>): RxNode<El<HTMLDataListElement, M>> { return RxNode.acquire(HtmlTags.datalist, declaration, preset) }
+export function DD<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.dd, declaration, preset) }
+export function Del<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.del, declaration, preset) }
+export function Details<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.details, declaration, preset) }
+export function Dfn<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.dfn, declaration, preset) }
+export function Div<M = unknown>(declaration?: RxNodeDecl<El<HTMLDivElement, M>>, preset?: RxNodeDecl<El<HTMLDivElement, M>>): RxNode<El<HTMLDivElement, M>> { return RxNode.acquire(HtmlTags.div, declaration, preset) }
+export function DL<M = unknown>(declaration?: RxNodeDecl<El<HTMLDListElement, M>>, preset?: RxNodeDecl<El<HTMLDListElement, M>>): RxNode<El<HTMLDListElement, M>> { return RxNode.acquire(HtmlTags.dl, declaration, preset) }
+export function DT<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.dt, declaration, preset) }
+export function EM<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.em, declaration, preset) }
+export function Embed<M = unknown>(declaration?: RxNodeDecl<El<HTMLEmbedElement, M>>, preset?: RxNodeDecl<El<HTMLEmbedElement, M>>): RxNode<El<HTMLEmbedElement, M>> { return RxNode.acquire(HtmlTags.embed, declaration, preset) }
+export function FieldSet<M = unknown>(declaration?: RxNodeDecl<El<HTMLFieldSetElement, M>>, preset?: RxNodeDecl<El<HTMLFieldSetElement, M>>): RxNode<El<HTMLFieldSetElement, M>> { return RxNode.acquire(HtmlTags.fieldset, declaration, preset) }
+export function FigCaption<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.figcaption, declaration, preset) }
+export function Figure<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.figure, declaration, preset) }
+export function Footer<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.footer, declaration, preset) }
+export function Form<M = unknown>(declaration?: RxNodeDecl<El<HTMLFormElement, M>>, preset?: RxNodeDecl<El<HTMLFormElement, M>>): RxNode<El<HTMLFormElement, M>> { return RxNode.acquire(HtmlTags.form, declaration, preset) }
+export function H1<M = unknown>(declaration?: RxNodeDecl<El<HTMLHeadingElement, M>>, preset?: RxNodeDecl<El<HTMLHeadingElement, M>>): RxNode<El<HTMLHeadingElement, M>> { return RxNode.acquire(HtmlTags.h1, declaration, preset) }
+export function H2<M = unknown>(declaration?: RxNodeDecl<El<HTMLHeadingElement, M>>, preset?: RxNodeDecl<El<HTMLHeadingElement, M>>): RxNode<El<HTMLHeadingElement, M>> { return RxNode.acquire(HtmlTags.h2, declaration, preset) }
+export function H3<M = unknown>(declaration?: RxNodeDecl<El<HTMLHeadingElement, M>>, preset?: RxNodeDecl<El<HTMLHeadingElement, M>>): RxNode<El<HTMLHeadingElement, M>> { return RxNode.acquire(HtmlTags.h3, declaration, preset) }
+export function H4<M = unknown>(declaration?: RxNodeDecl<El<HTMLHeadingElement, M>>, preset?: RxNodeDecl<El<HTMLHeadingElement, M>>): RxNode<El<HTMLHeadingElement, M>> { return RxNode.acquire(HtmlTags.h4, declaration, preset) }
+export function H5<M = unknown>(declaration?: RxNodeDecl<El<HTMLHeadingElement, M>>, preset?: RxNodeDecl<El<HTMLHeadingElement, M>>): RxNode<El<HTMLHeadingElement, M>> { return RxNode.acquire(HtmlTags.h5, declaration, preset) }
+export function H6<M = unknown>(declaration?: RxNodeDecl<El<HTMLHeadingElement, M>>, preset?: RxNodeDecl<El<HTMLHeadingElement, M>>): RxNode<El<HTMLHeadingElement, M>> { return RxNode.acquire(HtmlTags.h6, declaration, preset) }
+export function Head<M = unknown>(declaration?: RxNodeDecl<El<HTMLHeadElement, M>>, preset?: RxNodeDecl<El<HTMLHeadElement, M>>): RxNode<El<HTMLHeadElement, M>> { return RxNode.acquire(HtmlTags.head, declaration, preset) }
+export function Header<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.header, declaration, preset) }
+export function HGroup<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.hgroup, declaration, preset) }
+export function HR<M = unknown>(declaration?: RxNodeDecl<El<HTMLHRElement, M>>, preset?: RxNodeDecl<El<HTMLHRElement, M>>): RxNode<El<HTMLHRElement, M>> { return RxNode.acquire(HtmlTags.hr, declaration, preset) }
+export function Html<M = unknown>(declaration?: RxNodeDecl<El<HTMLHtmlElement, M>>, preset?: RxNodeDecl<El<HTMLHtmlElement, M>>): RxNode<El<HTMLHtmlElement, M>> { return RxNode.acquire(HtmlTags.html, declaration, preset) }
+export function I<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.i, declaration, preset) }
+export function IFrame<M = unknown>(declaration?: RxNodeDecl<El<HTMLIFrameElement, M>>, preset?: RxNodeDecl<El<HTMLIFrameElement, M>>): RxNode<El<HTMLIFrameElement, M>> { return RxNode.acquire(HtmlTags.iframe, declaration, preset) }
+export function Img<M = unknown>(declaration?: RxNodeDecl<El<HTMLImageElement, M>>, preset?: RxNodeDecl<El<HTMLImageElement, M>>): RxNode<El<HTMLImageElement, M>> { return RxNode.acquire(HtmlTags.img, declaration, preset) }
+export function Input<M = unknown>(declaration?: RxNodeDecl<El<HTMLInputElement, M>>, preset?: RxNodeDecl<El<HTMLInputElement, M>>): RxNode<El<HTMLInputElement, M>> { return RxNode.acquire(HtmlTags.input, declaration, preset) }
+export function Ins<M = unknown>(declaration?: RxNodeDecl<El<HTMLModElement, M>>, preset?: RxNodeDecl<El<HTMLModElement, M>>): RxNode<El<HTMLModElement, M>> { return RxNode.acquire(HtmlTags.ins, declaration, preset) }
+export function Kbd<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.kbd, declaration, preset) }
+export function KeyGen<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.keygen, declaration, preset) }
+export function Label<M = unknown>(declaration?: RxNodeDecl<El<HTMLLabelElement, M>>, preset?: RxNodeDecl<El<HTMLLabelElement, M>>): RxNode<El<HTMLLabelElement, M>> { return RxNode.acquire(HtmlTags.label, declaration, preset) }
+export function Legend<M = unknown>(declaration?: RxNodeDecl<El<HTMLLegendElement, M>>, preset?: RxNodeDecl<El<HTMLLegendElement, M>>): RxNode<El<HTMLLegendElement, M>> { return RxNode.acquire(HtmlTags.legend, declaration, preset) }
+export function LI<M = unknown>(declaration?: RxNodeDecl<El<HTMLLIElement, M>>, preset?: RxNodeDecl<El<HTMLLIElement, M>>): RxNode<El<HTMLLIElement, M>> { return RxNode.acquire(HtmlTags.li, declaration, preset) }
+export function Link<M = unknown>(declaration?: RxNodeDecl<El<HTMLLinkElement, M>>, preset?: RxNodeDecl<El<HTMLLinkElement, M>>): RxNode<El<HTMLLinkElement, M>> { return RxNode.acquire(HtmlTags.link, declaration, preset) }
+export function Main<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.main, declaration, preset) }
+export function Map<M = unknown>(declaration?: RxNodeDecl<El<HTMLMapElement, M>>, preset?: RxNodeDecl<El<HTMLMapElement, M>>): RxNode<El<HTMLMapElement, M>> { return RxNode.acquire(HtmlTags.map, declaration, preset) }
+export function Mark<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.mark, declaration, preset) }
+export function Menu<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.menu, declaration, preset) }
+export function MenuItem<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.menuitem, declaration, preset) }
+export function Meta<M = unknown>(declaration?: RxNodeDecl<El<HTMLMetaElement, M>>, preset?: RxNodeDecl<El<HTMLMetaElement, M>>): RxNode<El<HTMLMetaElement, M>> { return RxNode.acquire(HtmlTags.meta, declaration, preset) }
+export function Meter<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.meter, declaration, preset) }
+export function Nav<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.nav, declaration, preset) }
+export function NoIndex<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.noindex, declaration, preset) }
+export function NoScript<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.noscript, declaration, preset) }
+export function Obj<M = unknown>(declaration?: RxNodeDecl<El<HTMLObjectElement, M>>, preset?: RxNodeDecl<El<HTMLObjectElement, M>>): RxNode<El<HTMLObjectElement, M>> { return RxNode.acquire(HtmlTags.object, declaration, preset) }
+export function OL<M = unknown>(declaration?: RxNodeDecl<El<HTMLOListElement, M>>, preset?: RxNodeDecl<El<HTMLOListElement, M>>): RxNode<El<HTMLOListElement, M>> { return RxNode.acquire(HtmlTags.ol, declaration, preset) }
+export function OptGroup<M = unknown>(declaration?: RxNodeDecl<El<HTMLOptGroupElement, M>>, preset?: RxNodeDecl<El<HTMLOptGroupElement, M>>): RxNode<El<HTMLOptGroupElement, M>> { return RxNode.acquire(HtmlTags.optgroup, declaration, preset) }
+export function Option<M = unknown>(declaration?: RxNodeDecl<El<HTMLOptionElement, M>>, preset?: RxNodeDecl<El<HTMLOptionElement, M>>): RxNode<El<HTMLOptionElement, M>> { return RxNode.acquire(HtmlTags.option, declaration, preset) }
+export function Output<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.output, declaration, preset) }
+export function P<M = unknown>(declaration?: RxNodeDecl<El<HTMLParagraphElement, M>>, preset?: RxNodeDecl<El<HTMLParagraphElement, M>>): RxNode<El<HTMLParagraphElement, M>> { return RxNode.acquire(HtmlTags.p, declaration, preset) }
+export function Param<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.param, declaration, preset) }
+export function Picture<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.picture, declaration, preset) }
+export function Pre<M = unknown>(declaration?: RxNodeDecl<El<HTMLPreElement, M>>, preset?: RxNodeDecl<El<HTMLPreElement, M>>): RxNode<El<HTMLPreElement, M>> { return RxNode.acquire(HtmlTags.pre, declaration, preset) }
+export function Progress<M = unknown>(declaration?: RxNodeDecl<El<HTMLProgressElement, M>>, preset?: RxNodeDecl<El<HTMLProgressElement, M>>): RxNode<El<HTMLProgressElement, M>> { return RxNode.acquire(HtmlTags.progress, declaration, preset) }
+export function Q<M = unknown>(declaration?: RxNodeDecl<El<HTMLQuoteElement, M>>, preset?: RxNodeDecl<El<HTMLQuoteElement, M>>): RxNode<El<HTMLQuoteElement, M>> { return RxNode.acquire(HtmlTags.q, declaration, preset) }
+export function RP<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.rp, declaration, preset) }
+export function RT<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.rt, declaration, preset) }
+export function Ruby<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.ruby, declaration, preset) }
+export function S<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.s, declaration, preset) }
+export function Samp<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.samp, declaration, preset) }
+export function Script<M = unknown>(declaration?: RxNodeDecl<El<HTMLScriptElement, M>>, preset?: RxNodeDecl<El<HTMLScriptElement, M>>): RxNode<El<HTMLScriptElement, M>> { return RxNode.acquire(HtmlTags.script, declaration, preset) }
+export function Sctn<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.section, declaration, preset) }
+export function Select<M = unknown>(declaration?: RxNodeDecl<El<HTMLSelectElement, M>>, preset?: RxNodeDecl<El<HTMLSelectElement, M>>): RxNode<El<HTMLSelectElement, M>> { return RxNode.acquire(HtmlTags.select, declaration, preset) }
+export function Small<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.small, declaration, preset) }
+export function Source<M = unknown>(declaration?: RxNodeDecl<El<HTMLSourceElement, M>>, preset?: RxNodeDecl<El<HTMLSourceElement, M>>): RxNode<El<HTMLSourceElement, M>> { return RxNode.acquire(HtmlTags.source, declaration, preset) }
+export function Span<M = unknown>(declaration?: RxNodeDecl<El<HTMLSpanElement, M>>, preset?: RxNodeDecl<El<HTMLSpanElement, M>>): RxNode<El<HTMLSpanElement, M>> { return RxNode.acquire(HtmlTags.span, declaration, preset) }
+export function Strong<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.strong, declaration, preset) }
+export function Style<M = unknown>(declaration?: RxNodeDecl<El<HTMLStyleElement, M>>, preset?: RxNodeDecl<El<HTMLStyleElement, M>>): RxNode<El<HTMLStyleElement, M>> { return RxNode.acquire(HtmlTags.style, declaration, preset) }
+export function Sub<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.sub, declaration, preset) }
+export function Summary<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.summary, declaration, preset) }
+export function Sup<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.sup, declaration, preset) }
+export function Tbl<M = unknown>(declaration?: RxNodeDecl<El<HTMLTableElement, M>>, preset?: RxNodeDecl<El<HTMLTableElement, M>>): RxNode<El<HTMLTableElement, M>> { return RxNode.acquire(HtmlTags.table, declaration, preset) }
+export function Template<M = unknown>(declaration?: RxNodeDecl<El<HTMLTemplateElement, M>>, preset?: RxNodeDecl<El<HTMLTemplateElement, M>>): RxNode<El<HTMLTemplateElement, M>> { return RxNode.acquire(HtmlTags.template, declaration, preset) }
+export function TBody<M = unknown>(declaration?: RxNodeDecl<El<HTMLTableSectionElement, M>>, preset?: RxNodeDecl<El<HTMLTableSectionElement, M>>): RxNode<El<HTMLTableSectionElement, M>> { return RxNode.acquire(HtmlTags.tbody, declaration, preset) }
+export function TD<M = unknown>(declaration?: RxNodeDecl<El<HTMLTableCellElement, M>>, preset?: RxNodeDecl<El<HTMLTableCellElement, M>>): RxNode<El<HTMLTableCellElement, M>> { return RxNode.acquire(HtmlTags.td, declaration, preset) }
+export function TextArea<M = unknown>(declaration?: RxNodeDecl<El<HTMLTextAreaElement, M>>, preset?: RxNodeDecl<El<HTMLTextAreaElement, M>>): RxNode<El<HTMLTextAreaElement, M>> { return RxNode.acquire(HtmlTags.textarea, declaration, preset) }
+export function TFoot<M = unknown>(declaration?: RxNodeDecl<El<HTMLTableSectionElement, M>>, preset?: RxNodeDecl<El<HTMLTableSectionElement, M>>): RxNode<El<HTMLTableSectionElement, M>> { return RxNode.acquire(HtmlTags.tfoot, declaration, preset) }
+export function TH<M = unknown>(declaration?: RxNodeDecl<El<HTMLTableCellElement, M>>, preset?: RxNodeDecl<El<HTMLTableCellElement, M>>): RxNode<El<HTMLTableCellElement, M>> { return RxNode.acquire(HtmlTags.th, declaration, preset) }
+export function THead<M = unknown>(declaration?: RxNodeDecl<El<HTMLTableSectionElement, M>>, preset?: RxNodeDecl<El<HTMLTableSectionElement, M>>): RxNode<El<HTMLTableSectionElement, M>> { return RxNode.acquire(HtmlTags.thead, declaration, preset) }
+export function Time<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.time, declaration, preset) }
+export function Title<M = unknown>(declaration?: RxNodeDecl<El<HTMLTitleElement, M>>, preset?: RxNodeDecl<El<HTMLTitleElement, M>>): RxNode<El<HTMLTitleElement, M>> { return RxNode.acquire(HtmlTags.title, declaration, preset) }
+export function TR<M = unknown>(declaration?: RxNodeDecl<El<HTMLTableRowElement, M>>, preset?: RxNodeDecl<El<HTMLTableRowElement, M>>): RxNode<El<HTMLTableRowElement, M>> { return RxNode.acquire(HtmlTags.tr, declaration, preset) }
+export function Track<M = unknown>(declaration?: RxNodeDecl<El<HTMLTrackElement, M>>, preset?: RxNodeDecl<El<HTMLTrackElement, M>>): RxNode<El<HTMLTrackElement, M>> { return RxNode.acquire(HtmlTags.track, declaration, preset) }
+export function U<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.u, declaration, preset) }
+export function UL<M = unknown>(declaration?: RxNodeDecl<El<HTMLUListElement, M>>, preset?: RxNodeDecl<El<HTMLUListElement, M>>): RxNode<El<HTMLUListElement, M>> { return RxNode.acquire(HtmlTags.ul, declaration, preset) }
+export function Var<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.var, declaration, preset) }
+export function Video<M = unknown>(declaration?: RxNodeDecl<El<HTMLVideoElement, M>>, preset?: RxNodeDecl<El<HTMLVideoElement, M>>): RxNode<El<HTMLVideoElement, M>> { return RxNode.acquire(HtmlTags.video, declaration, preset) }
+export function Wbr<M = unknown>(declaration?: RxNodeDecl<El<HTMLElement, M>>, preset?: RxNodeDecl<El<HTMLElement, M>>): RxNode<El<HTMLElement, M>> { return RxNode.acquire(HtmlTags.wbr, declaration, preset) }
 
-export function Svg<M = unknown>(declaration?: RxNodeDecl<El<SVGSVGElement, M, void>>, preset?: RxNodeDecl<El<SVGSVGElement, M, void>>): RxNode<El<SVGSVGElement, M, void>> { return RxNode.acquire(SvgTags.svg, declaration, preset) }
-export function SvgA<M = unknown>(declaration?: RxNodeDecl<El<SVGAElement, M, void>>, preset?: RxNodeDecl<El<SVGAElement, M, void>>): RxNode<El<SVGAElement, M, void>> { return RxNode.acquire(SvgTags.a, declaration, preset) }
-export function Animate<M = unknown>(declaration?: RxNodeDecl<El<SVGAnimateElement, M, void>>, preset?: RxNodeDecl<El<SVGAnimateElement, M, void>>): RxNode<El<SVGAnimateElement, M, void>> { return RxNode.acquire(SvgTags.animate, declaration, preset) }
-export function AnimateMotion<M = unknown>(declaration?: RxNodeDecl<El<SVGAnimateMotionElement, M, void>>, preset?: RxNodeDecl<El<SVGAnimateMotionElement, M, void>>): RxNode<El<SVGAnimateMotionElement, M, void>> { return RxNode.acquire(SvgTags.animateMotion, declaration, preset) }
-export function AnimateTransform<M = unknown>(declaration?: RxNodeDecl<El<SVGAnimateTransformElement, M, void>>, preset?: RxNodeDecl<El<SVGAnimateTransformElement, M, void>>): RxNode<El<SVGAnimateTransformElement, M, void>> { return RxNode.acquire(SvgTags.animateTransform, declaration, preset) }
-export function Circle<M = unknown>(declaration?: RxNodeDecl<El<SVGCircleElement, M, void>>, preset?: RxNodeDecl<El<SVGCircleElement, M, void>>): RxNode<El<SVGCircleElement, M, void>> { return RxNode.acquire(SvgTags.circle, declaration, preset) }
-export function ClipPath<M = unknown>(declaration?: RxNodeDecl<El<SVGClipPathElement, M, void>>, preset?: RxNodeDecl<El<SVGClipPathElement, M, void>>): RxNode<El<SVGClipPathElement, M, void>> { return RxNode.acquire(SvgTags.clipPath, declaration, preset) }
-export function Defs<M = unknown>(declaration?: RxNodeDecl<El<SVGDefsElement, M, void>>, preset?: RxNodeDecl<El<SVGDefsElement, M, void>>): RxNode<El<SVGDefsElement, M, void>> { return RxNode.acquire(SvgTags.defs, declaration, preset) }
-export function Desc<M = unknown>(declaration?: RxNodeDecl<El<SVGDescElement, M, void>>, preset?: RxNodeDecl<El<SVGDescElement, M, void>>): RxNode<El<SVGDescElement, M, void>> { return RxNode.acquire(SvgTags.desc, declaration, preset) }
-export function Ellipse<M = unknown>(declaration?: RxNodeDecl<El<SVGEllipseElement, M, void>>, preset?: RxNodeDecl<El<SVGEllipseElement, M, void>>): RxNode<El<SVGEllipseElement, M, void>> { return RxNode.acquire(SvgTags.ellipse, declaration, preset) }
-export function FeBlend<M = unknown>(declaration?: RxNodeDecl<El<SVGFEBlendElement, M, void>>, preset?: RxNodeDecl<El<SVGFEBlendElement, M, void>>): RxNode<El<SVGFEBlendElement, M, void>> { return RxNode.acquire(SvgTags.feBlend, declaration, preset) }
-export function FeColorMatrix<M = unknown>(declaration?: RxNodeDecl<El<SVGFEColorMatrixElement, M, void>>, preset?: RxNodeDecl<El<SVGFEColorMatrixElement, M, void>>): RxNode<El<SVGFEColorMatrixElement, M, void>> { return RxNode.acquire(SvgTags.feColorMatrix, declaration, preset) }
-export function FeComponentTransfer<M = unknown>(declaration?: RxNodeDecl<El<SVGFEComponentTransferElement, M, void>>, preset?: RxNodeDecl<El<SVGFEComponentTransferElement, M, void>>): RxNode<El<SVGFEComponentTransferElement, M, void>> { return RxNode.acquire(SvgTags.feComponentTransfer, declaration, preset) }
-export function FeComposite<M = unknown>(declaration?: RxNodeDecl<El<SVGFECompositeElement, M, void>>, preset?: RxNodeDecl<El<SVGFECompositeElement, M, void>>): RxNode<El<SVGFECompositeElement, M, void>> { return RxNode.acquire(SvgTags.feComposite, declaration, preset) }
-export function FeConvolveMatrix<M = unknown>(declaration?: RxNodeDecl<El<SVGFEConvolveMatrixElement, M, void>>, preset?: RxNodeDecl<El<SVGFEConvolveMatrixElement, M, void>>): RxNode<El<SVGFEConvolveMatrixElement, M, void>> { return RxNode.acquire(SvgTags.feConvolveMatrix, declaration, preset) }
-export function FeDiffuseLighting<M = unknown>(declaration?: RxNodeDecl<El<SVGFEDiffuseLightingElement, M, void>>, preset?: RxNodeDecl<El<SVGFEDiffuseLightingElement, M, void>>): RxNode<El<SVGFEDiffuseLightingElement, M, void>> { return RxNode.acquire(SvgTags.feDiffuseLighting, declaration, preset) }
-export function FeDisplacementMap<M = unknown>(declaration?: RxNodeDecl<El<SVGFEDisplacementMapElement, M, void>>, preset?: RxNodeDecl<El<SVGFEDisplacementMapElement, M, void>>): RxNode<El<SVGFEDisplacementMapElement, M, void>> { return RxNode.acquire(SvgTags.feDisplacementMap, declaration, preset) }
-export function FeDistantLight<M = unknown>(declaration?: RxNodeDecl<El<SVGFEDistantLightElement, M, void>>, preset?: RxNodeDecl<El<SVGFEDistantLightElement, M, void>>): RxNode<El<SVGFEDistantLightElement, M, void>> { return RxNode.acquire(SvgTags.feDistantLight, declaration, preset) }
-export function FeDropShadow<M = unknown>(declaration?: RxNodeDecl<El<SVGFEDropShadowElement, M, void>>, preset?: RxNodeDecl<El<SVGFEDropShadowElement, M, void>>): RxNode<El<SVGFEDropShadowElement, M, void>> { return RxNode.acquire(SvgTags.feDropShadow, declaration, preset) }
-export function FeFlood<M = unknown>(declaration?: RxNodeDecl<El<SVGFEFloodElement, M, void>>, preset?: RxNodeDecl<El<SVGFEFloodElement, M, void>>): RxNode<El<SVGFEFloodElement, M, void>> { return RxNode.acquire(SvgTags.feFlood, declaration, preset) }
-export function FeFuncA<M = unknown>(declaration?: RxNodeDecl<El<SVGFEFuncAElement, M, void>>, preset?: RxNodeDecl<El<SVGFEFuncAElement, M, void>>): RxNode<El<SVGFEFuncAElement, M, void>> { return RxNode.acquire(SvgTags.feFuncA, declaration, preset) }
-export function FeFuncB<M = unknown>(declaration?: RxNodeDecl<El<SVGFEFuncBElement, M, void>>, preset?: RxNodeDecl<El<SVGFEFuncBElement, M, void>>): RxNode<El<SVGFEFuncBElement, M, void>> { return RxNode.acquire(SvgTags.feFuncB, declaration, preset) }
-export function FeFuncG<M = unknown>(declaration?: RxNodeDecl<El<SVGFEFuncGElement, M, void>>, preset?: RxNodeDecl<El<SVGFEFuncGElement, M, void>>): RxNode<El<SVGFEFuncGElement, M, void>> { return RxNode.acquire(SvgTags.feFuncG, declaration, preset) }
-export function FeFuncR<M = unknown>(declaration?: RxNodeDecl<El<SVGFEFuncRElement, M, void>>, preset?: RxNodeDecl<El<SVGFEFuncRElement, M, void>>): RxNode<El<SVGFEFuncRElement, M, void>> { return RxNode.acquire(SvgTags.feFuncR, declaration, preset) }
-export function FeGaussianBlur<M = unknown>(declaration?: RxNodeDecl<El<SVGFEGaussianBlurElement, M, void>>, preset?: RxNodeDecl<El<SVGFEGaussianBlurElement, M, void>>): RxNode<El<SVGFEGaussianBlurElement, M, void>> { return RxNode.acquire(SvgTags.feGaussianBlur, declaration, preset) }
-export function FeImage<M = unknown>(declaration?: RxNodeDecl<El<SVGFEImageElement, M, void>>, preset?: RxNodeDecl<El<SVGFEImageElement, M, void>>): RxNode<El<SVGFEImageElement, M, void>> { return RxNode.acquire(SvgTags.feImage, declaration, preset) }
-export function FeMerge<M = unknown>(declaration?: RxNodeDecl<El<SVGFEMergeElement, M, void>>, preset?: RxNodeDecl<El<SVGFEMergeElement, M, void>>): RxNode<El<SVGFEMergeElement, M, void>> { return RxNode.acquire(SvgTags.feMerge, declaration, preset) }
-export function FeMergeNode<M = unknown>(declaration?: RxNodeDecl<El<SVGFEMergeNodeElement, M, void>>, preset?: RxNodeDecl<El<SVGFEMergeNodeElement, M, void>>): RxNode<El<SVGFEMergeNodeElement, M, void>> { return RxNode.acquire(SvgTags.feMergeNode, declaration, preset) }
-export function FeMorphology<M = unknown>(declaration?: RxNodeDecl<El<SVGFEMorphologyElement, M, void>>, preset?: RxNodeDecl<El<SVGFEMorphologyElement, M, void>>): RxNode<El<SVGFEMorphologyElement, M, void>> { return RxNode.acquire(SvgTags.feMorphology, declaration, preset) }
-export function FeOffset<M = unknown>(declaration?: RxNodeDecl<El<SVGFEOffsetElement, M, void>>, preset?: RxNodeDecl<El<SVGFEOffsetElement, M, void>>): RxNode<El<SVGFEOffsetElement, M, void>> { return RxNode.acquire(SvgTags.feOffset, declaration, preset) }
-export function FePointLight<M = unknown>(declaration?: RxNodeDecl<El<SVGFEPointLightElement, M, void>>, preset?: RxNodeDecl<El<SVGFEPointLightElement, M, void>>): RxNode<El<SVGFEPointLightElement, M, void>> { return RxNode.acquire(SvgTags.fePointLight, declaration, preset) }
-export function FeSpecularLighting<M = unknown>(declaration?: RxNodeDecl<El<SVGFESpecularLightingElement, M, void>>, preset?: RxNodeDecl<El<SVGFESpecularLightingElement, M, void>>): RxNode<El<SVGFESpecularLightingElement, M, void>> { return RxNode.acquire(SvgTags.feSpecularLighting, declaration, preset) }
-export function FeSpotLight<M = unknown>(declaration?: RxNodeDecl<El<SVGFESpotLightElement, M, void>>, preset?: RxNodeDecl<El<SVGFESpotLightElement, M, void>>): RxNode<El<SVGFESpotLightElement, M, void>> { return RxNode.acquire(SvgTags.feSpotLight, declaration, preset) }
-export function FeTile<M = unknown>(declaration?: RxNodeDecl<El<SVGFETileElement, M, void>>, preset?: RxNodeDecl<El<SVGFETileElement, M, void>>): RxNode<El<SVGFETileElement, M, void>> { return RxNode.acquire(SvgTags.feTile, declaration, preset) }
-export function FeTurbulence<M = unknown>(declaration?: RxNodeDecl<El<SVGFETurbulenceElement, M, void>>, preset?: RxNodeDecl<El<SVGFETurbulenceElement, M, void>>): RxNode<El<SVGFETurbulenceElement, M, void>> { return RxNode.acquire(SvgTags.feTurbulence, declaration, preset) }
-export function Filter<M = unknown>(declaration?: RxNodeDecl<El<SVGFilterElement, M, void>>, preset?: RxNodeDecl<El<SVGFilterElement, M, void>>): RxNode<El<SVGFilterElement, M, void>> { return RxNode.acquire(SvgTags.filter, declaration, preset) }
-export function ForeignObject<M = unknown>(declaration?: RxNodeDecl<El<SVGForeignObjectElement, M, void>>, preset?: RxNodeDecl<El<SVGForeignObjectElement, M, void>>): RxNode<El<SVGForeignObjectElement, M, void>> { return RxNode.acquire(SvgTags.foreignObject, declaration, preset) }
-export function G<M = unknown>(declaration?: RxNodeDecl<El<SVGGElement, M, void>>, preset?: RxNodeDecl<El<SVGGElement, M, void>>): RxNode<El<SVGGElement, M, void>> { return RxNode.acquire(SvgTags.g, declaration, preset) }
-export function SvgImage<M = unknown>(declaration?: RxNodeDecl<El<SVGImageElement, M, void>>, preset?: RxNodeDecl<El<SVGImageElement, M, void>>): RxNode<El<SVGImageElement, M, void>> { return RxNode.acquire(SvgTags.image, declaration, preset) }
-export function SvgLine<M = unknown>(declaration?: RxNodeDecl<El<SVGLineElement, M, void>>, preset?: RxNodeDecl<El<SVGLineElement, M, void>>): RxNode<El<SVGLineElement, M, void>> { return RxNode.acquire(SvgTags.line, declaration, preset) }
-export function LinearGradient<M = unknown>(declaration?: RxNodeDecl<El<SVGLinearGradientElement, M, void>>, preset?: RxNodeDecl<El<SVGLinearGradientElement, M, void>>): RxNode<El<SVGLinearGradientElement, M, void>> { return RxNode.acquire(SvgTags.linearGradient, declaration, preset) }
-export function Marker<M = unknown>(declaration?: RxNodeDecl<El<SVGMarkerElement, M, void>>, preset?: RxNodeDecl<El<SVGMarkerElement, M, void>>): RxNode<El<SVGMarkerElement, M, void>> { return RxNode.acquire(SvgTags.marker, declaration, preset) }
-export function Mask<M = unknown>(declaration?: RxNodeDecl<El<SVGMaskElement, M, void>>, preset?: RxNodeDecl<El<SVGMaskElement, M, void>>): RxNode<El<SVGMaskElement, M, void>> { return RxNode.acquire(SvgTags.mask, declaration, preset) }
-export function MetaData<M = unknown>(declaration?: RxNodeDecl<El<SVGMetadataElement, M, void>>, preset?: RxNodeDecl<El<SVGMetadataElement, M, void>>): RxNode<El<SVGMetadataElement, M, void>> { return RxNode.acquire(SvgTags.metadata, declaration, preset) }
-export function MPath<M = unknown>(declaration?: RxNodeDecl<El<SVGElement, M, void>>, preset?: RxNodeDecl<El<SVGElement, M, void>>): RxNode<El<SVGElement, M, void>> { return RxNode.acquire(SvgTags.mpath, declaration, preset) }
-export function Path<M = unknown>(declaration?: RxNodeDecl<El<SVGPathElement, M, void>>, preset?: RxNodeDecl<El<SVGPathElement, M, void>>): RxNode<El<SVGPathElement, M, void>> { return RxNode.acquire(SvgTags.path, declaration, preset) }
-export function Pattern<M = unknown>(declaration?: RxNodeDecl<El<SVGPatternElement, M, void>>, preset?: RxNodeDecl<El<SVGPatternElement, M, void>>): RxNode<El<SVGPatternElement, M, void>> { return RxNode.acquire(SvgTags.pattern, declaration, preset) }
-export function Polygon<M = unknown>(declaration?: RxNodeDecl<El<SVGPolygonElement, M, void>>, preset?: RxNodeDecl<El<SVGPolygonElement, M, void>>): RxNode<El<SVGPolygonElement, M, void>> { return RxNode.acquire(SvgTags.polygon, declaration, preset) }
-export function PolyLine<M = unknown>(declaration?: RxNodeDecl<El<SVGPolylineElement, M, void>>, preset?: RxNodeDecl<El<SVGPolylineElement, M, void>>): RxNode<El<SVGPolylineElement, M, void>> { return RxNode.acquire(SvgTags.polyline, declaration, preset) }
-export function RadialGradient<M = unknown>(declaration?: RxNodeDecl<El<SVGRadialGradientElement, M, void>>, preset?: RxNodeDecl<El<SVGRadialGradientElement, M, void>>): RxNode<El<SVGRadialGradientElement, M, void>> { return RxNode.acquire(SvgTags.radialGradient, declaration, preset) }
-export function Rect<M = unknown>(declaration?: RxNodeDecl<El<SVGRectElement, M, void>>, preset?: RxNodeDecl<El<SVGRectElement, M, void>>): RxNode<El<SVGRectElement, M, void>> { return RxNode.acquire(SvgTags.rect, declaration, preset) }
-export function Stop<M = unknown>(declaration?: RxNodeDecl<El<SVGStopElement, M, void>>, preset?: RxNodeDecl<El<SVGStopElement, M, void>>): RxNode<El<SVGStopElement, M, void>> { return RxNode.acquire(SvgTags.stop, declaration, preset) }
-export function SvgSwitch<M = unknown>(declaration?: RxNodeDecl<El<SVGSwitchElement, M, void>>, preset?: RxNodeDecl<El<SVGSwitchElement, M, void>>): RxNode<El<SVGSwitchElement, M, void>> { return RxNode.acquire(SvgTags.switch, declaration, preset) }
-export function Symbol<M = unknown>(declaration?: RxNodeDecl<El<SVGSymbolElement, M, void>>, preset?: RxNodeDecl<El<SVGSymbolElement, M, void>>): RxNode<El<SVGSymbolElement, M, void>> { return RxNode.acquire(SvgTags.symbol, declaration, preset) }
-export function Text<M = unknown>(declaration?: RxNodeDecl<El<SVGTextElement, M, void>>, preset?: RxNodeDecl<El<SVGTextElement, M, void>>): RxNode<El<SVGTextElement, M, void>> { return RxNode.acquire(SvgTags.text, declaration, preset) }
-export function TextPath<M = unknown>(declaration?: RxNodeDecl<El<SVGTextPathElement, M, void>>, preset?: RxNodeDecl<El<SVGTextPathElement, M, void>>): RxNode<El<SVGTextPathElement, M, void>> { return RxNode.acquire(SvgTags.textPath, declaration, preset) }
-export function TSpan<M = unknown>(declaration?: RxNodeDecl<El<SVGTSpanElement, M, void>>, preset?: RxNodeDecl<El<SVGTSpanElement, M, void>>): RxNode<El<SVGTSpanElement, M, void>> { return RxNode.acquire(SvgTags.tspan, declaration, preset) }
-export function Use<M = unknown>(declaration?: RxNodeDecl<El<SVGUseElement, M, void>>, preset?: RxNodeDecl<El<SVGUseElement, M, void>>): RxNode<El<SVGUseElement, M, void>> { return RxNode.acquire(SvgTags.use, declaration, preset) }
-export function View<M = unknown>(declaration?: RxNodeDecl<El<SVGViewElement, M, void>>, preset?: RxNodeDecl<El<SVGViewElement, M, void>>): RxNode<El<SVGViewElement, M, void>> { return RxNode.acquire(SvgTags.view, declaration, preset) }
+export function Svg<M = unknown>(declaration?: RxNodeDecl<El<SVGSVGElement, M>>, preset?: RxNodeDecl<El<SVGSVGElement, M>>): RxNode<El<SVGSVGElement, M>> { return RxNode.acquire(SvgTags.svg, declaration, preset) }
+export function SvgA<M = unknown>(declaration?: RxNodeDecl<El<SVGAElement, M>>, preset?: RxNodeDecl<El<SVGAElement, M>>): RxNode<El<SVGAElement, M>> { return RxNode.acquire(SvgTags.a, declaration, preset) }
+export function Animate<M = unknown>(declaration?: RxNodeDecl<El<SVGAnimateElement, M>>, preset?: RxNodeDecl<El<SVGAnimateElement, M>>): RxNode<El<SVGAnimateElement, M>> { return RxNode.acquire(SvgTags.animate, declaration, preset) }
+export function AnimateMotion<M = unknown>(declaration?: RxNodeDecl<El<SVGAnimateMotionElement, M>>, preset?: RxNodeDecl<El<SVGAnimateMotionElement, M>>): RxNode<El<SVGAnimateMotionElement, M>> { return RxNode.acquire(SvgTags.animateMotion, declaration, preset) }
+export function AnimateTransform<M = unknown>(declaration?: RxNodeDecl<El<SVGAnimateTransformElement, M>>, preset?: RxNodeDecl<El<SVGAnimateTransformElement, M>>): RxNode<El<SVGAnimateTransformElement, M>> { return RxNode.acquire(SvgTags.animateTransform, declaration, preset) }
+export function Circle<M = unknown>(declaration?: RxNodeDecl<El<SVGCircleElement, M>>, preset?: RxNodeDecl<El<SVGCircleElement, M>>): RxNode<El<SVGCircleElement, M>> { return RxNode.acquire(SvgTags.circle, declaration, preset) }
+export function ClipPath<M = unknown>(declaration?: RxNodeDecl<El<SVGClipPathElement, M>>, preset?: RxNodeDecl<El<SVGClipPathElement, M>>): RxNode<El<SVGClipPathElement, M>> { return RxNode.acquire(SvgTags.clipPath, declaration, preset) }
+export function Defs<M = unknown>(declaration?: RxNodeDecl<El<SVGDefsElement, M>>, preset?: RxNodeDecl<El<SVGDefsElement, M>>): RxNode<El<SVGDefsElement, M>> { return RxNode.acquire(SvgTags.defs, declaration, preset) }
+export function Desc<M = unknown>(declaration?: RxNodeDecl<El<SVGDescElement, M>>, preset?: RxNodeDecl<El<SVGDescElement, M>>): RxNode<El<SVGDescElement, M>> { return RxNode.acquire(SvgTags.desc, declaration, preset) }
+export function Ellipse<M = unknown>(declaration?: RxNodeDecl<El<SVGEllipseElement, M>>, preset?: RxNodeDecl<El<SVGEllipseElement, M>>): RxNode<El<SVGEllipseElement, M>> { return RxNode.acquire(SvgTags.ellipse, declaration, preset) }
+export function FeBlend<M = unknown>(declaration?: RxNodeDecl<El<SVGFEBlendElement, M>>, preset?: RxNodeDecl<El<SVGFEBlendElement, M>>): RxNode<El<SVGFEBlendElement, M>> { return RxNode.acquire(SvgTags.feBlend, declaration, preset) }
+export function FeColorMatrix<M = unknown>(declaration?: RxNodeDecl<El<SVGFEColorMatrixElement, M>>, preset?: RxNodeDecl<El<SVGFEColorMatrixElement, M>>): RxNode<El<SVGFEColorMatrixElement, M>> { return RxNode.acquire(SvgTags.feColorMatrix, declaration, preset) }
+export function FeComponentTransfer<M = unknown>(declaration?: RxNodeDecl<El<SVGFEComponentTransferElement, M>>, preset?: RxNodeDecl<El<SVGFEComponentTransferElement, M>>): RxNode<El<SVGFEComponentTransferElement, M>> { return RxNode.acquire(SvgTags.feComponentTransfer, declaration, preset) }
+export function FeComposite<M = unknown>(declaration?: RxNodeDecl<El<SVGFECompositeElement, M>>, preset?: RxNodeDecl<El<SVGFECompositeElement, M>>): RxNode<El<SVGFECompositeElement, M>> { return RxNode.acquire(SvgTags.feComposite, declaration, preset) }
+export function FeConvolveMatrix<M = unknown>(declaration?: RxNodeDecl<El<SVGFEConvolveMatrixElement, M>>, preset?: RxNodeDecl<El<SVGFEConvolveMatrixElement, M>>): RxNode<El<SVGFEConvolveMatrixElement, M>> { return RxNode.acquire(SvgTags.feConvolveMatrix, declaration, preset) }
+export function FeDiffuseLighting<M = unknown>(declaration?: RxNodeDecl<El<SVGFEDiffuseLightingElement, M>>, preset?: RxNodeDecl<El<SVGFEDiffuseLightingElement, M>>): RxNode<El<SVGFEDiffuseLightingElement, M>> { return RxNode.acquire(SvgTags.feDiffuseLighting, declaration, preset) }
+export function FeDisplacementMap<M = unknown>(declaration?: RxNodeDecl<El<SVGFEDisplacementMapElement, M>>, preset?: RxNodeDecl<El<SVGFEDisplacementMapElement, M>>): RxNode<El<SVGFEDisplacementMapElement, M>> { return RxNode.acquire(SvgTags.feDisplacementMap, declaration, preset) }
+export function FeDistantLight<M = unknown>(declaration?: RxNodeDecl<El<SVGFEDistantLightElement, M>>, preset?: RxNodeDecl<El<SVGFEDistantLightElement, M>>): RxNode<El<SVGFEDistantLightElement, M>> { return RxNode.acquire(SvgTags.feDistantLight, declaration, preset) }
+export function FeDropShadow<M = unknown>(declaration?: RxNodeDecl<El<SVGFEDropShadowElement, M>>, preset?: RxNodeDecl<El<SVGFEDropShadowElement, M>>): RxNode<El<SVGFEDropShadowElement, M>> { return RxNode.acquire(SvgTags.feDropShadow, declaration, preset) }
+export function FeFlood<M = unknown>(declaration?: RxNodeDecl<El<SVGFEFloodElement, M>>, preset?: RxNodeDecl<El<SVGFEFloodElement, M>>): RxNode<El<SVGFEFloodElement, M>> { return RxNode.acquire(SvgTags.feFlood, declaration, preset) }
+export function FeFuncA<M = unknown>(declaration?: RxNodeDecl<El<SVGFEFuncAElement, M>>, preset?: RxNodeDecl<El<SVGFEFuncAElement, M>>): RxNode<El<SVGFEFuncAElement, M>> { return RxNode.acquire(SvgTags.feFuncA, declaration, preset) }
+export function FeFuncB<M = unknown>(declaration?: RxNodeDecl<El<SVGFEFuncBElement, M>>, preset?: RxNodeDecl<El<SVGFEFuncBElement, M>>): RxNode<El<SVGFEFuncBElement, M>> { return RxNode.acquire(SvgTags.feFuncB, declaration, preset) }
+export function FeFuncG<M = unknown>(declaration?: RxNodeDecl<El<SVGFEFuncGElement, M>>, preset?: RxNodeDecl<El<SVGFEFuncGElement, M>>): RxNode<El<SVGFEFuncGElement, M>> { return RxNode.acquire(SvgTags.feFuncG, declaration, preset) }
+export function FeFuncR<M = unknown>(declaration?: RxNodeDecl<El<SVGFEFuncRElement, M>>, preset?: RxNodeDecl<El<SVGFEFuncRElement, M>>): RxNode<El<SVGFEFuncRElement, M>> { return RxNode.acquire(SvgTags.feFuncR, declaration, preset) }
+export function FeGaussianBlur<M = unknown>(declaration?: RxNodeDecl<El<SVGFEGaussianBlurElement, M>>, preset?: RxNodeDecl<El<SVGFEGaussianBlurElement, M>>): RxNode<El<SVGFEGaussianBlurElement, M>> { return RxNode.acquire(SvgTags.feGaussianBlur, declaration, preset) }
+export function FeImage<M = unknown>(declaration?: RxNodeDecl<El<SVGFEImageElement, M>>, preset?: RxNodeDecl<El<SVGFEImageElement, M>>): RxNode<El<SVGFEImageElement, M>> { return RxNode.acquire(SvgTags.feImage, declaration, preset) }
+export function FeMerge<M = unknown>(declaration?: RxNodeDecl<El<SVGFEMergeElement, M>>, preset?: RxNodeDecl<El<SVGFEMergeElement, M>>): RxNode<El<SVGFEMergeElement, M>> { return RxNode.acquire(SvgTags.feMerge, declaration, preset) }
+export function FeMergeNode<M = unknown>(declaration?: RxNodeDecl<El<SVGFEMergeNodeElement, M>>, preset?: RxNodeDecl<El<SVGFEMergeNodeElement, M>>): RxNode<El<SVGFEMergeNodeElement, M>> { return RxNode.acquire(SvgTags.feMergeNode, declaration, preset) }
+export function FeMorphology<M = unknown>(declaration?: RxNodeDecl<El<SVGFEMorphologyElement, M>>, preset?: RxNodeDecl<El<SVGFEMorphologyElement, M>>): RxNode<El<SVGFEMorphologyElement, M>> { return RxNode.acquire(SvgTags.feMorphology, declaration, preset) }
+export function FeOffset<M = unknown>(declaration?: RxNodeDecl<El<SVGFEOffsetElement, M>>, preset?: RxNodeDecl<El<SVGFEOffsetElement, M>>): RxNode<El<SVGFEOffsetElement, M>> { return RxNode.acquire(SvgTags.feOffset, declaration, preset) }
+export function FePointLight<M = unknown>(declaration?: RxNodeDecl<El<SVGFEPointLightElement, M>>, preset?: RxNodeDecl<El<SVGFEPointLightElement, M>>): RxNode<El<SVGFEPointLightElement, M>> { return RxNode.acquire(SvgTags.fePointLight, declaration, preset) }
+export function FeSpecularLighting<M = unknown>(declaration?: RxNodeDecl<El<SVGFESpecularLightingElement, M>>, preset?: RxNodeDecl<El<SVGFESpecularLightingElement, M>>): RxNode<El<SVGFESpecularLightingElement, M>> { return RxNode.acquire(SvgTags.feSpecularLighting, declaration, preset) }
+export function FeSpotLight<M = unknown>(declaration?: RxNodeDecl<El<SVGFESpotLightElement, M>>, preset?: RxNodeDecl<El<SVGFESpotLightElement, M>>): RxNode<El<SVGFESpotLightElement, M>> { return RxNode.acquire(SvgTags.feSpotLight, declaration, preset) }
+export function FeTile<M = unknown>(declaration?: RxNodeDecl<El<SVGFETileElement, M>>, preset?: RxNodeDecl<El<SVGFETileElement, M>>): RxNode<El<SVGFETileElement, M>> { return RxNode.acquire(SvgTags.feTile, declaration, preset) }
+export function FeTurbulence<M = unknown>(declaration?: RxNodeDecl<El<SVGFETurbulenceElement, M>>, preset?: RxNodeDecl<El<SVGFETurbulenceElement, M>>): RxNode<El<SVGFETurbulenceElement, M>> { return RxNode.acquire(SvgTags.feTurbulence, declaration, preset) }
+export function Filter<M = unknown>(declaration?: RxNodeDecl<El<SVGFilterElement, M>>, preset?: RxNodeDecl<El<SVGFilterElement, M>>): RxNode<El<SVGFilterElement, M>> { return RxNode.acquire(SvgTags.filter, declaration, preset) }
+export function ForeignObject<M = unknown>(declaration?: RxNodeDecl<El<SVGForeignObjectElement, M>>, preset?: RxNodeDecl<El<SVGForeignObjectElement, M>>): RxNode<El<SVGForeignObjectElement, M>> { return RxNode.acquire(SvgTags.foreignObject, declaration, preset) }
+export function G<M = unknown>(declaration?: RxNodeDecl<El<SVGGElement, M>>, preset?: RxNodeDecl<El<SVGGElement, M>>): RxNode<El<SVGGElement, M>> { return RxNode.acquire(SvgTags.g, declaration, preset) }
+export function SvgImage<M = unknown>(declaration?: RxNodeDecl<El<SVGImageElement, M>>, preset?: RxNodeDecl<El<SVGImageElement, M>>): RxNode<El<SVGImageElement, M>> { return RxNode.acquire(SvgTags.image, declaration, preset) }
+export function SvgLine<M = unknown>(declaration?: RxNodeDecl<El<SVGLineElement, M>>, preset?: RxNodeDecl<El<SVGLineElement, M>>): RxNode<El<SVGLineElement, M>> { return RxNode.acquire(SvgTags.line, declaration, preset) }
+export function LinearGradient<M = unknown>(declaration?: RxNodeDecl<El<SVGLinearGradientElement, M>>, preset?: RxNodeDecl<El<SVGLinearGradientElement, M>>): RxNode<El<SVGLinearGradientElement, M>> { return RxNode.acquire(SvgTags.linearGradient, declaration, preset) }
+export function Marker<M = unknown>(declaration?: RxNodeDecl<El<SVGMarkerElement, M>>, preset?: RxNodeDecl<El<SVGMarkerElement, M>>): RxNode<El<SVGMarkerElement, M>> { return RxNode.acquire(SvgTags.marker, declaration, preset) }
+export function Mask<M = unknown>(declaration?: RxNodeDecl<El<SVGMaskElement, M>>, preset?: RxNodeDecl<El<SVGMaskElement, M>>): RxNode<El<SVGMaskElement, M>> { return RxNode.acquire(SvgTags.mask, declaration, preset) }
+export function MetaData<M = unknown>(declaration?: RxNodeDecl<El<SVGMetadataElement, M>>, preset?: RxNodeDecl<El<SVGMetadataElement, M>>): RxNode<El<SVGMetadataElement, M>> { return RxNode.acquire(SvgTags.metadata, declaration, preset) }
+export function MPath<M = unknown>(declaration?: RxNodeDecl<El<SVGElement, M>>, preset?: RxNodeDecl<El<SVGElement, M>>): RxNode<El<SVGElement, M>> { return RxNode.acquire(SvgTags.mpath, declaration, preset) }
+export function Path<M = unknown>(declaration?: RxNodeDecl<El<SVGPathElement, M>>, preset?: RxNodeDecl<El<SVGPathElement, M>>): RxNode<El<SVGPathElement, M>> { return RxNode.acquire(SvgTags.path, declaration, preset) }
+export function Pattern<M = unknown>(declaration?: RxNodeDecl<El<SVGPatternElement, M>>, preset?: RxNodeDecl<El<SVGPatternElement, M>>): RxNode<El<SVGPatternElement, M>> { return RxNode.acquire(SvgTags.pattern, declaration, preset) }
+export function Polygon<M = unknown>(declaration?: RxNodeDecl<El<SVGPolygonElement, M>>, preset?: RxNodeDecl<El<SVGPolygonElement, M>>): RxNode<El<SVGPolygonElement, M>> { return RxNode.acquire(SvgTags.polygon, declaration, preset) }
+export function PolyLine<M = unknown>(declaration?: RxNodeDecl<El<SVGPolylineElement, M>>, preset?: RxNodeDecl<El<SVGPolylineElement, M>>): RxNode<El<SVGPolylineElement, M>> { return RxNode.acquire(SvgTags.polyline, declaration, preset) }
+export function RadialGradient<M = unknown>(declaration?: RxNodeDecl<El<SVGRadialGradientElement, M>>, preset?: RxNodeDecl<El<SVGRadialGradientElement, M>>): RxNode<El<SVGRadialGradientElement, M>> { return RxNode.acquire(SvgTags.radialGradient, declaration, preset) }
+export function Rect<M = unknown>(declaration?: RxNodeDecl<El<SVGRectElement, M>>, preset?: RxNodeDecl<El<SVGRectElement, M>>): RxNode<El<SVGRectElement, M>> { return RxNode.acquire(SvgTags.rect, declaration, preset) }
+export function Stop<M = unknown>(declaration?: RxNodeDecl<El<SVGStopElement, M>>, preset?: RxNodeDecl<El<SVGStopElement, M>>): RxNode<El<SVGStopElement, M>> { return RxNode.acquire(SvgTags.stop, declaration, preset) }
+export function SvgSwitch<M = unknown>(declaration?: RxNodeDecl<El<SVGSwitchElement, M>>, preset?: RxNodeDecl<El<SVGSwitchElement, M>>): RxNode<El<SVGSwitchElement, M>> { return RxNode.acquire(SvgTags.switch, declaration, preset) }
+export function Symbol<M = unknown>(declaration?: RxNodeDecl<El<SVGSymbolElement, M>>, preset?: RxNodeDecl<El<SVGSymbolElement, M>>): RxNode<El<SVGSymbolElement, M>> { return RxNode.acquire(SvgTags.symbol, declaration, preset) }
+export function Text<M = unknown>(declaration?: RxNodeDecl<El<SVGTextElement, M>>, preset?: RxNodeDecl<El<SVGTextElement, M>>): RxNode<El<SVGTextElement, M>> { return RxNode.acquire(SvgTags.text, declaration, preset) }
+export function TextPath<M = unknown>(declaration?: RxNodeDecl<El<SVGTextPathElement, M>>, preset?: RxNodeDecl<El<SVGTextPathElement, M>>): RxNode<El<SVGTextPathElement, M>> { return RxNode.acquire(SvgTags.textPath, declaration, preset) }
+export function TSpan<M = unknown>(declaration?: RxNodeDecl<El<SVGTSpanElement, M>>, preset?: RxNodeDecl<El<SVGTSpanElement, M>>): RxNode<El<SVGTSpanElement, M>> { return RxNode.acquire(SvgTags.tspan, declaration, preset) }
+export function Use<M = unknown>(declaration?: RxNodeDecl<El<SVGUseElement, M>>, preset?: RxNodeDecl<El<SVGUseElement, M>>): RxNode<El<SVGUseElement, M>> { return RxNode.acquire(SvgTags.use, declaration, preset) }
+export function View<M = unknown>(declaration?: RxNodeDecl<El<SVGViewElement, M>>, preset?: RxNodeDecl<El<SVGViewElement, M>>): RxNode<El<SVGViewElement, M>> { return RxNode.acquire(SvgTags.view, declaration, preset) }
 
 const HtmlTags = {
   a: new HtmlElementDriver<HTMLAnchorElement>("a", false, el => el.kind = ElKind.Native),
diff --git a/source/html/sensors/ResizeSensor.ts b/source/html/sensors/ResizeSensor.ts
index 865be68..5e330c6 100644
--- a/source/html/sensors/ResizeSensor.ts
+++ b/source/html/sensors/ResizeSensor.ts
@@ -30,7 +30,7 @@ export class ResizeSensor extends Sensor {
     this.doReset()
   }
 
-  observeResizing(element: El<any, any ,any>, value: boolean, boxSizing: ResizeObserverBoxOptions = "content-box"): void {
+  observeResizing(element: El<any, any>, value: boolean, boxSizing: ResizeObserverBoxOptions = "content-box"): void {
     const native = element.native
     if (native instanceof Element) {
       if (value) {